Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

14.1 KB
Raw Blame
import { ViewCreateButton } from '@app/components/view-shell/ViewCreateButton';
import { createAiDocument } from '@app/features/block-ai/queries/create-ai';
import { createFigDocument } from '@app/features/block-fig/queries/create-fig';
import { createPsdDocument } from '@app/features/block-psd/queries/create-psd';
import { useSpreadsheetAccess } from '@app/features/block-spreadsheet/primitives/use-spreadsheet-access';
import { createSpreadsheetDocument } from '@app/features/block-spreadsheet/queries/create-spreadsheet';
import { openChatWithAgent } from '@app/features/chat/ChatWithAgentButton';
import { t } from '@app/lib/i18n';
import type { BlockTool } from '@components/app/ResponsiveBlockToolbar';
import { useSplitLayout } from '@components/app/split-layout/layout';
import type { BlockAlias, BlockName } from '@core/block';
import { EntityIcon } from '@core/component/EntityIcon';
import { toast } from '@core/component/Toast/Toast';
import {
  enableAiEditor,
  enableChatV3Agents,
  enableFigViewer,
  enablePsdEditor,
  isFeatureEnabled,
} from '@core/constant/featureFlags';
import { pressedKeys } from '@core/hotkey/state';
import { type HotkeyToken, TOKENS } from '@core/hotkey/tokens';
import {
  createCanvasFile,
  createChat,
  createMarkdownFile,
  createTask,
} from '@core/util/create';
import { fireAndForget } from '@core/util/fireAndForget';
import type { ObjectLike } from '@core/util/result';
import PlusIcon from '@icon/system/regular/plus.svg';
import { PROPERTY_OPTION_IDS, SYSTEM_PROPERTY_IDS } from '@property/constants';
import { createProject } from '@queries/storage/projects';
import { Dialog, Dropdown, Surface } from '@ui';
import { type Component, createSignal, For } from 'solid-js';

type MenuItemProps = {
  label: string;
  Icon: Component;
  action: () => void | Promise<void>;
};

type CreateBlockSpec = {
  label: string;
  blockName: BlockName | BlockAlias;
  hotkeyToken: HotkeyToken;
  icon: Component;
  loading?: boolean;
  createFn: (projectId: string) => Promise<string>;
  params?: ObjectLike;
};

const BLOCK_CREATE_SPECS: CreateBlockSpec[] = [
  {
    get label() {
      return t('create.spreadsheetLabel');
    },
    blockName: 'spreadsheet',
    hotkeyToken: TOKENS.create.spreadsheet,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon
          targetType="spreadsheet"
          size="shrinkFill"
          theme="monochrome"
        />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const documentId = await createSpreadsheetDocument({ projectId });
      if (!documentId) throw new Error(t('create.failedToCreateSpreadsheet'));
      return documentId;
    },
  },
  {
    get label() {
      return t('create.noteLabel');
    },
    blockName: 'md' as BlockName,
    hotkeyToken: TOKENS.create.note,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="md" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const result = await createMarkdownFile({
        title: '',
        content: '',
        projectId,
      });
      if (!result) throw new Error(t('create.failedToCreateMarkdownFile'));
      return result;
    },
    params: { fromScratch: true },
  },
  {
    get label() {
      return t('create.taskLabel');
    },
    blockName: 'task' as BlockAlias,
    hotkeyToken: TOKENS.create.task,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="task" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const result = await createTask({
        title: '',
        content: '',
        projectId,
        propertyValues: [
          {
            propertyId: SYSTEM_PROPERTY_IDS.STATUS,
            value: {
              type: 'select_option',
              option_id: PROPERTY_OPTION_IDS.STATUS.NOT_STARTED,
            },
          },
        ],
      });
      if (!result) throw new Error(t('create.failedToCreateTask'));
      return result;
    },
  },
  {
    get label() {
      return t('create.aiChatLabel');
    },
    blockName: 'chat' as BlockName,
    hotkeyToken: TOKENS.create.chat,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="chat" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    createFn: async (projectId) => {
      const result = await createChat({ projectId });
      if ('error' in result) {
        console.error(result.error);
        throw new Error(t('create.failedToCreateChat'));
      }
      return result.chatId;
    },
  },
  {
    get label() {
      return t('create.canvasLabel');
    },
    blockName: 'canvas' as BlockName,
    hotkeyToken: TOKENS.create.canvas,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="canvas" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const result = await createCanvasFile({
        title: 'New Canvas',
        projectId,
      });
      if ('error' in result) {
        console.error(result.error);
        throw new Error(t('create.failedToCreateCanvas'));
      }
      return result.documentId;
    },
  },
  {
    get label() {
      return t('create.photoshopLabel');
    },
    blockName: 'psd' as BlockName,
    hotkeyToken: TOKENS.create.photoshop,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="psd" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const id = await createPsdDocument({ projectId, source: 'project' });
      if (!id) throw new Error(t('create.failedToCreatePhotoshopFile'));
      return id;
    },
  },
  {
    get label() {
      return t('create.designLabel');
    },
    blockName: 'fig' as BlockName,
    hotkeyToken: TOKENS.create.design,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="fig" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const id = await createFigDocument({ projectId, source: 'project' });
      if (!id) throw new Error(t('create.failedToCreateDesign'));
      return id;
    },
  },
  {
    get label() {
      return t('create.illustratorLabel');
    },
    blockName: 'ai' as BlockName,
    hotkeyToken: TOKENS.create.illustration,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="ai" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    loading: true,
    createFn: async (projectId) => {
      const id = await createAiDocument({ projectId, source: 'project' });
      if (!id) throw new Error(t('create.failedToCreateIllustratorFile'));
      return id;
    },
  },
  {
    get label() {
      return t('create.folderLabel');
    },
    blockName: 'project' as BlockName,
    hotkeyToken: TOKENS.create.project,
    icon: () => (
      <div class="size-4 shrink-0">
        <EntityIcon targetType="project" size="shrinkFill" theme="monochrome" />
      </div>
    ),
    createFn: async (projectId) => {
      const result = await createProject({
        name: 'New Project',
        parentId: projectId,
      });
      if (!result) throw new Error(t('create.failedToCreateFolder'));
      return result;
    },
  },
];

function makeCreateBlock({
  replaceSplit,
  insertSplit,
}: Pick<ReturnType<typeof useSplitLayout>, 'replaceSplit' | 'insertSplit'>) {
  return async (spec: {
    blockName: BlockName | BlockAlias;
    createFn: () => Promise<string>;
    loading?: boolean;
    params?: Record<string, unknown>;
  }) => {
    const { blockName, createFn, loading, params } = spec;

    const shouldInsert = pressedKeys().has('shift');

    const tryCreate = async () => {
      try {
        const id = await createFn();
        return id;
      } catch (cause) {
        toast.failure(cause instanceof Error ? cause.message : String(cause));
        return null;
      }
    };

    if (!loading) {
      const id = await tryCreate();
      if (!id) return;

      const block = { type: blockName, id, params };

      shouldInsert
        ? insertSplit(block, 'entity-actions-menu')
        : replaceSplit({ content: block, referredFrom: 'entity-actions-menu' });
    } else {
      const split = shouldInsert
        ? insertSplit(
            { type: 'component', id: 'loading' },
            'entity-actions-menu'
          )
        : replaceSplit({
            content: { type: 'component', id: 'loading' },
            referredFrom: 'entity-actions-menu',
          });

      const id = await tryCreate();
      if (!id) {
        split?.goBack();
        return;
      }

      if (split)
        split.replace({
          next: { type: blockName, id, params },
          mergeHistory: true,
          referredFrom: 'entity-actions-menu',
        });
    }
  };
}

function ProjectCreateDialog(props: {
  open: boolean;
  onClose: () => void;
  projectId: string;
  name: string;
}) {
  const { replaceSplit, insertSplit } = useSplitLayout();
  const createBlock = makeCreateBlock({ replaceSplit, insertSplit });
  const spreadsheetAccess = useSpreadsheetAccess();
  const offered = (spec: CreateBlockSpec) => {
    if (spec.blockName === 'spreadsheet') return spreadsheetAccess();
    if (spec.blockName === 'psd') return isFeatureEnabled(enablePsdEditor);
    if (spec.blockName === 'fig') return isFeatureEnabled(enableFigViewer);
    if (spec.blockName === 'ai') return isFeatureEnabled(enableAiEditor);
    return true;
  };

  return (
    <Dialog open={props.open} onOpenChange={(o) => !o && props.onClose()}>
      <Surface depth={2} class="rounded-xl">
        <div class="*:max-h-[75vh]">
          <div class="p-2">
            <Dialog.Title class="text-base font-semibold text-ink pb-3">
              {t('create.createInName', { name: props.name })}
            </Dialog.Title>
            <For each={BLOCK_CREATE_SPECS.filter(offered)}>
              {(spec) => (
                <button
                  class="flex items-center gap-2 py-1 text-sm hover:bg-hover w-full text-left min-h-11"
                  onClick={() => {
                    props.onClose();
                    if (
                      spec.blockName === 'chat' &&
                      isFeatureEnabled(enableChatV3Agents)
                    ) {
                      fireAndForget(
                        openChatWithAgent({
                          type: 'project',
                          id: props.projectId,
                          name: props.name,
                        }),
                        'project-create'
                      );
                      return;
                    }
                    fireAndForget(
                      createBlock({
                        blockName: spec.blockName,
                        loading: spec.loading,
                        createFn: () => spec.createFn(props.projectId),
                        params: spec.params,
                      }),
                      'project-create'
                    );
                  }}
                >
                  <div class="size-4 shrink-0">
                    <spec.icon />
                  </div>
                  {spec.label}
                </button>
              )}
            </For>
          </div>
        </div>
      </Surface>
    </Dialog>
  );
}

function MenuItem(props: MenuItemProps) {
  return (
    <Dropdown.Item onSelect={props.action}>
      <div class="size-4 shrink-0">
        <props.Icon />
      </div>
      <span>{props.label}</span>
    </Dropdown.Item>
  );
}

function MenuContent(props: { projectId: string; name: string }) {
  const { replaceSplit, insertSplit } = useSplitLayout();
  const createBlock = makeCreateBlock({ replaceSplit, insertSplit });
  const spreadsheetAccess = useSpreadsheetAccess();
  const offered = (spec: CreateBlockSpec) => {
    if (spec.blockName === 'spreadsheet') return spreadsheetAccess();
    if (spec.blockName === 'psd') return isFeatureEnabled(enablePsdEditor);
    if (spec.blockName === 'fig') return isFeatureEnabled(enableFigViewer);
    if (spec.blockName === 'ai') return isFeatureEnabled(enableAiEditor);
    return true;
  };

  const items = (): MenuItemProps[] =>
    BLOCK_CREATE_SPECS.filter(offered).map((spec) => ({
      label: spec.label,
      Icon: spec.icon,
      action: () => {
        if (spec.blockName === 'chat' && isFeatureEnabled(enableChatV3Agents)) {
          fireAndForget(
            openChatWithAgent({
              type: 'project',
              id: props.projectId,
              name: props.name,
            }),
            'project-create'
          );
          return;
        }
        return createBlock({
          blockName: spec.blockName,
          loading: spec.loading,
          createFn: () => spec.createFn(props.projectId),
          params: spec.params,
        });
      },
    }));

  return (
    <Dropdown.Content class="min-w-max">
      <Dropdown.Group>
        <For each={items()}>{(item) => <MenuItem {...item} />}</For>
      </Dropdown.Group>
    </Dropdown.Content>
  );
}

export function useProjectCreateTools(
  projectId: string,
  name: () => string,
  condition?: () => boolean
): { tools: BlockTool[]; CreateDialog: Component } {
  const [open, setOpen] = createSignal(false);

  const tools: BlockTool[] = [
    {
      label: () => t('create.create'),
      icon: PlusIcon,
      // Using a setTimeout here so that the synthetic click event after the touch doesn't instantly select an item
      action: () => setTimeout(() => setOpen(true), 0),
      condition,
    },
  ];

  const CreateDialog: Component = () => (
    <ProjectCreateDialog
      open={open()}
      onClose={() => setOpen(false)}
      projectId={projectId}
      name={name()}
    />
  );

  return { tools, CreateDialog };
}

export function ProjectCreateMenu(props: { id: string; name: string }) {
  const [open, setOpen] = createSignal(false);
  return (
    <Dropdown open={open()} onOpenChange={setOpen}>
      <Dropdown.Trigger
        as={ViewCreateButton}
        presentation="toolbar"
        menu
        aria-label={t('create.createInFolder')}
      />
      <MenuContent projectId={props.id} name={props.name} />
    </Dropdown>
  );
}