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.

4.6 KB
Raw Blame
import { useCreateContext } from '@app/features/command/context/create-context';
import {
  resolveEntityActionViewContext,
  toSingleEntityActionListState,
} from '@app/features/next-soup/actions';
import { openEntityInSplitFromUnifiedList } from '@app/features/next-soup/utils';
import { SoupEntityContextMenu } from '@app/features/soup';
import { useGlobalNotificationSource } from '@components/app/GlobalAppState';
import { useSplitLayout } from '@components/app/split-layout/layout';
import { useSplitPanelOrThrow } from '@components/app/split-layout/layoutUtils';
import { useUserId } from '@core/context/user';
import { fireAndForget } from '@core/util/fireAndForget';
import { markRowNotificationsSeenOnOpen } from '@notifications/mark-row-seen';
import { usePropertyUserDisplay } from '@property/hooks/usePropertyUserDisplay';
import { type Accessor, type JSX, Show } from 'solid-js';
import { type TaskBoardTask, toTaskBoardGrouping } from './core/task-board';
import { taskDueDatePredicate } from './core/task-due-date';
import { createTaskBoardQueries } from './queries/task-board-queries';
import { taskBoardComposerContext } from './task-composer';
import { useTasksView } from './tasks-view-context';
import { TaskBoardView } from './views/task-board-view';

/** Connects the task view to query adapters and app navigation. */
export function TasksBoard(props: { ref?: (element: HTMLDivElement) => void }) {
  const context = useTasksView();
  const { state, source, openTask, projectsEnabled, calendar } = context;
  const panel = useSplitPanelOrThrow();
  const notificationSource = useGlobalNotificationSource();
  const layout = useSplitLayout();
  const createContext = useCreateContext();
  const queries = createTaskBoardQueries({
    rows: source.boardRows ?? source.items,
    grouping: () => toTaskBoardGrouping(state.groupBy),
    searching: source.boardSearching ?? (() => !!state.search.trim()),
    userId: useUserId(),
    projectsEnabled,
    facets: () => state.facets,
    sort: () => state.sort,
    calendar,
    dueDate: () => taskDueDatePredicate(state.dueDate, calendar()),
  });
  const data = {
    ...queries,
    createAssigneeName: (id: Accessor<string>) =>
      usePropertyUserDisplay(id).name,
  };

  const viewContext = () =>
    resolveEntityActionViewContext({
      activeListView: panel.handle.content().id,
      activeTab: state.tab,
    });
  // Cards have no selection, so like Gantt bars the menu acts on its own task.
  const renderCard = (task: Accessor<TaskBoardTask>, content: JSX.Element) => {
    const entity = () => data.entity(task().id);
    return (
      <Show when={entity()} fallback={content}>
        {(current) => (
          <SoupEntityContextMenu
            as="div"
            entity={current()}
            list={toSingleEntityActionListState(entity)}
            selectedEntities={() => []}
            viewContext={viewContext()}
          >
            {content}
          </SoupEntityContextMenu>
        )}
      </Show>
    );
  };

  const canCreate = () => !!context.createTask || !context.scopeKey;
  const createTask = (columnId: string) => {
    const grouping = toTaskBoardGrouping(state.groupBy);
    if (!canCreate()) return;
    const composerContext = taskBoardComposerContext({
      grouping,
      columnId,
      calendar: calendar(),
      scopeKey: context.scopeKey ?? panel.handle.id,
      context: createContext.snapshot('task', panel.handle.id),
    });
    if (context.createTask) {
      context.createTask({ composerContext });
      return;
    }
    layout.popoverSplit({
      type: 'component',
      id: 'task-compose',
      params: { composerContext },
    });
  };

  return (
    <div class="flex size-full min-h-0 min-w-0 flex-col overflow-hidden">
      <TaskBoardView
        ref={props.ref}
        data={data}
        onCreate={canCreate() ? createTask : undefined}
        renderCard={renderCard}
        onOpen={(task, event) => {
          const opened = openTask(
            { id: task.id, fallbackName: task.name },
            { event }
          );

          if (opened) {
            return;
          }

          const entity = data.entity(task.id);

          if (!entity) {
            return;
          }

          markRowNotificationsSeenOnOpen(entity, notificationSource);
          fireAndForget(
            openEntityInSplitFromUnifiedList(entity, {
              splitHandle: panel.handle,
              referredFrom: 'tasks',
              openInNewSplit:
                event.shiftKey ||
                event.metaKey ||
                event.ctrlKey ||
                event.altKey,
            }),
            'open-entity-in-split'
          );
        }}
      />
    </div>
  );
}