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.

12.0 KB
Raw Blame
import { useListNavigationHotkeys } from '@app/components/entity-detail/use-list-navigation-hotkeys';
import { ViewShell } from '@app/components/view-shell';
import { displaySubject } from '@app/features/email-compose/core/subject-text';
import type { EmailThreadHost } from '@app/features/email-thread/context/email-thread-context';
import { createEmailThreadSource } from '@app/features/email-thread/queries/thread-source';
import { useBlockEntityCommands } from '@app/features/next-soup/actions';
import { createSearchParams, useRouteParams } from '@app/lib/split-router';
import { usePending } from '@app/observability/flow';
import { emailThreadRoute } from '@app/routes/routes';
import {
  EmailThreadControlGroups,
  EmailThreadHeaderActions,
} from '@block-email/component/EmailThreadHeaderActions';
import { EmailThreadLoadGate } from '@block-email/component/EmailThreadLoadGate';
import {
  type EmailThreadToolsOptions,
  useEmailThreadTools,
} from '@block-email/component/useEmailThreadTools';
import { EmailThreadHostView } from '@block-email/EmailThreadHostView';
import { registerEmailHotkeys } from '@block-email/util/emailHotkeys';
import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
import { SidePanel } from '@components/app/side-panel';
import { SplitFileMenu } from '@components/app/split-layout/components/SplitFileMenu';
import {
  useCanAutofocusSplitContent,
  useSplitDisplayName,
  useSplitPanelOrThrow,
} from '@components/app/split-layout/layoutUtils';
import { createSplitAutofocus } from '@components/app/split-layout/utils/createSplitAutofocus';
import { toEntityLoadError } from '@core/component/EntityLoadGate';
import { getPermissions } from '@core/component/SharePermissions';
import { ShareTrigger } from '@core/component/TopBar/ShareButton';
import { useShareModal } from '@core/component/TopBar/shareModal';
import { ENABLE_EMAIL_SHARING } from '@core/constant/featureFlags';
import { TOKENS } from '@core/hotkey/tokens';
import { registerScopeSignalHotkey } from '@core/hotkey/utils';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
import { fireAndForget } from '@core/util/fireAndForget';
import { buildEntityData } from '@entity';
import ArrowLeftIcon from '@phosphor/arrow-left.svg';
import { useThreadQuery } from '@queries/email/thread';
import { representativeThreadMessage } from '@queries/email/thread-subject';
import { Button } from '@ui';
import {
  createEffect,
  createMemo,
  createSignal,
  onCleanup,
  Show,
} from 'solid-js';
import { Portal } from 'solid-js/web';
import { emailDetailSearch } from '../email-route';
import { useEmailView } from '../email-view-context';
import { useEmailReaderPane } from '../reader-pane';
import type { EmailThreadTarget } from '../types';
import { useEmailDetailListNavigation } from '../use-email-detail-list-navigation';

/**
 * Where the title menu sits after the subject's last word. It unsets itself on
 * unmount so a standalone draft, which has no subject line, gets the menu in
 * the header instead.
 */
function TitleMenuMount(props: {
  ref: (element: HTMLElement | undefined) => void;
}) {
  onCleanup(() => props.ref(undefined));
  return <span ref={props.ref} class="ml-1.5 inline-flex align-middle" />;
}

/** The thread's title menu and header controls, which need the loaded thread. */
function EmailDetailHeader(
  props: EmailThreadToolsOptions & {
    titleMenuMount: HTMLElement | undefined;
    controlsMount: HTMLDivElement | undefined;
    onEmailReminderSaved: () => void | Promise<void>;
  }
) {
  const { emailEntity, permissions, menuTools, controls } =
    useEmailThreadTools(props);
  return (
    <>
      <Show when={props.titleMenuMount} keyed>
        {(mount) => (
          <Portal mount={mount} ref={(div) => (div.style.display = 'contents')}>
            <SplitFileMenu
              id={props.id}
              itemType="email"
              entityKind="email"
              name={props.title}
              entity={emailEntity()}
              permissions={permissions()}
              ops={[]}
              tools={menuTools}
              onEmailReminderSaved={props.onEmailReminderSaved}
            />
          </Portal>
        )}
      </Show>
      <Show when={props.controlsMount}>
        {(mount) => (
          <Portal mount={mount()}>
            <EmailThreadControlGroups
              controls={controls}
              navigation={props.listNavigation}
            />
          </Portal>
        )}
      </Show>
    </>
  );
}

export function EmailDetailView(props: {
  thread: EmailThreadTarget;
  targetMessageId?: string;
  targetRequest?: string;
}) {
  const { closeThread, selectedThread } = useEmailView();
  const panel = useSplitPanelOrThrow();
  // In the reading pane the thread keeps its keys in the reader's scope, and
  // Escape hands the keyboard back to the list instead of closing it.
  const pane = useEmailReaderPane();
  const keyScope = pane?.hotkeyScope ?? panel.splitHotkeyScope;
  const notificationSource = useGlobalNotificationSource();
  const canAutofocus = useCanAutofocusSplitContent();
  const [controlsMount, setControlsMount] = createSignal<HTMLDivElement>();
  const [subjectMenuMount, setSubjectMenuMount] = createSignal<HTMLElement>();
  const [headerMenuMount, setHeaderMenuMount] = createSignal<HTMLElement>();
  const threadId = () => props.thread.id;
  const threadQuery = useThreadQuery(threadId, () => ({
    enabled: !!threadId(),
  }));
  usePending('email.thread', () => threadQuery.isLoading);
  const source = createEmailThreadSource(threadId, threadQuery);
  const threadData = source.thread;
  const title = () => {
    const thread = threadData();
    return (
      (thread &&
        displaySubject(
          representativeThreadMessage(thread.messages)?.subject
        )) ||
      (props.thread.fallbackName &&
        displaySubject(props.thread.fallbackName)) ||
      'Email'
    );
  };
  useSplitDisplayName(title);
  const openShare = useShareModal(() => {
    const thread = threadData();
    if (!thread) return;
    return {
      id: props.thread.id,
      blockAlias: 'email',
      itemType: 'email',
      name: title(),
      userPermissions: getPermissions(thread.access_level),
    };
  });
  const commandEntity = createMemo(() => {
    if (!threadQuery.isSuccess) return undefined;
    const thread = threadData();
    if (!thread) return undefined;
    return buildEntityData({
      id: thread.db_id,
      name: displaySubject(
        representativeThreadMessage(thread.messages)?.subject
      ),
      blockName: 'email',
      isRead: thread.is_read,
      done: !thread.inbox_visible,
    });
  });
  useBlockEntityCommands({
    id: props.thread.id,
    scopeId: keyScope,
    resolveEntity: commandEntity,
    onDeleted: closeThread,
    onEmailReminderSaved: async () => {
      await listNavigation.afterReminderSaved?.();
    },
    extraFavoriteHotkey: { hotkey: 's', hotkeyToken: TOKENS.email.star },
    extraMuteHotkey: { hotkey: 'shift+m', hotkeyToken: TOKENS.email.mute },
  });

  let container: HTMLDivElement | undefined;
  const focusContainer = () => container?.focus({ preventScroll: true });
  createSplitAutofocus({
    element: () => container ?? null,
    enabled: () => canAutofocus && panel.isPanelActive() && !isTouchDevice(),
  });
  createEffect(() => {
    if (!pane || pane.focusRequest() !== props.thread.id) return;
    pane.clearFocusRequest();
    focusContainer();
  });
  const listNavigation = useEmailDetailListNavigation(threadId);
  const hotkeyScope = () => keyScope;
  const host: EmailThreadHost = {
    returnToList: closeThread,
    listNavigation,
    focusContainer,
    targetMessageId: () => props.targetMessageId,
    targetRequest: () => props.targetRequest,
    isActive: panel.isPanelActive,
    registerKeyboard: (handlers) => {
      registerEmailHotkeys(hotkeyScope(), handlers);
      registerScopeSignalHotkey(hotkeyScope, {
        hotkey: 'enter',
        description: 'Reply to message',
        keyDownHandler: handlers.activate,
        hotkeyToken: TOKENS.block.focus,
        hide: true,
      });
      registerScopeSignalHotkey(hotkeyScope, {
        hotkey: 'escape',
        description: 'Collapse message or back to list',
        // Escape unwinds thread state first (reply, expanded body, focused
        // message). Once nothing is left to unwind it goes back to the list
        // this thread was opened from.
        keyDownHandler: () => {
          if (handlers.cancel()) return true;
          (pane?.focusList ?? closeThread)();
          return true;
        },
        hotkeyToken: TOKENS.email.cancelReply,
        hide: true,
      });
    },
  };
  useListNavigationHotkeys({
    scopeId: keyScope,
    enabled: () =>
      panel.isPanelActive() && selectedThread()?.id === props.thread.id,
    navigation: listNavigation,
    arrowKeys: true,
  });
  const loadResult = {
    data: threadData,
    error: () =>
      threadQuery.isError ? toEntityLoadError(threadQuery.error) : undefined,
    isPending: () => threadQuery.isLoading,
  };

  return (
    <SidePanel.Root floating defaultOpen={false}>
      <div class="flex size-full min-h-0 min-w-0 flex-col overflow-hidden">
        <ViewShell.TopBar class="touch:flex">
          {/* The subject sits atop the thread, so the header only goes
              back; the reading pane already shows the list beside it. */}
          <Show when={!pane}>
            <Button
              variant="ghost"
              size="icon-md"
              tooltip="Back"
              aria-label="Back"
              onClick={closeThread}
            >
              <ArrowLeftIcon class="size-4 touch:size-6" />
            </Button>
          </Show>
          <div ref={setHeaderMenuMount} class="flex items-center" />
          <EmailThreadHeaderActions
            controls={<div ref={setControlsMount} class="flex items-center" />}
            share={
              <Show when={ENABLE_EMAIL_SHARING}>
                <ShareTrigger
                  size="md"
                  onClick={openShare}
                  id={props.thread.id}
                  blockType="email"
                  hotkeyScope={keyScope}
                />
              </Show>
            }
          />
        </ViewShell.TopBar>
        <div
          ref={container}
          class="relative min-h-0 min-w-0 flex-1"
          tabIndex={-1}
        >
          <EmailThreadLoadGate
            isLocalDraft={source.isLocalDraft()}
            result={loadResult}
            notificationSource={notificationSource}
            threadId={props.thread.id}
            linkId={threadData()?.link_id}
            onRetry={() => fireAndForget(threadQuery.refetch(), 'email-view')}
          >
            <EmailThreadHostView
              title={title()}
              titleTrailing={<TitleMenuMount ref={setSubjectMenuMount} />}
              threadId={threadId}
              source={source}
              threadTransport={() => threadQuery.transport}
              host={host}
              chrome={({ createTask, createEvent, canCreateEvent }) => (
                <EmailDetailHeader
                  onEmailReminderSaved={async () => {
                    await listNavigation.afterReminderSaved?.();
                  }}
                  id={props.thread.id}
                  title={title()}
                  onCreateTask={createTask}
                  onCreateEvent={createEvent}
                  canCreateEvent={canCreateEvent}
                  onMarkedUnread={closeThread}
                  onDeleted={closeThread}
                  listNavigation={listNavigation}
                  titleMenuMount={subjectMenuMount() ?? headerMenuMount()}
                  controlsMount={controlsMount()}
                />
              )}
              sidePanelHeaderToggle={false}
            />
          </EmailThreadLoadGate>
        </div>
      </div>
    </SidePanel.Root>
  );
}

export function EmailDetailRouteView() {
  const params = useRouteParams(emailThreadRoute);
  const [search] = createSearchParams(emailDetailSearch);

  return (
    <EmailDetailView
      thread={{ id: params.threadId }}
      targetMessageId={search.messageId || undefined}
      targetRequest={search.seek}
    />
  );
}