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.2 KB
Raw Blame
import { useInfiniteScrollSentinel } from '@app/lib/primitives/infinite-scroll-sentinel';
import { toast } from '@core/component/Toast/Toast';
import { fireAndForget } from '@core/util/fireAndForget';
import PlusIcon from '@icon/system/regular/plus.svg';
import SpinnerIcon from '@icon/system/regular/spinner.svg';
import { SYSTEM_PROPERTY_IDS } from '@property/identifiers';
import { hasValue } from '@property/utils/typeGuards';
import { Button } from '@ui/components/Button';
import {
  type Accessor,
  createSignal,
  For,
  type JSX,
  Match,
  Show,
  Suspense,
  Switch,
} from 'solid-js';
import { TaskBoard } from '../components/task-board';
import {
  TaskBoardColumnIcon,
  TaskBoardProperty,
} from '../components/task-board-property';
import { TaskDeadlineMoveDialog } from '../components/task-deadline-move-dialog';
import { TASK_SORT_OPTIONS } from '../constants';
import type { TaskBoardData } from '../context/task-board';
import {
  type TaskBoardColumn,
  type TaskBoardGrouping,
  type TaskBoardTask,
  toTaskBoardGrouping,
} from '../core/task-board';
import { taskDueDateUrgency } from '../core/task-due-date';
import { createTaskBoard } from '../primitives/create-task-board';
import { createTaskDeadlineMove } from '../primitives/create-task-deadline-move';
import { taskBoardFacetId, taskBoardPropertyId } from '../queries/task-board';
import { useTasksView } from '../tasks-view-context';

const CARD_PROPERTY_IDS = [
  SYSTEM_PROPERTY_IDS.PRIORITY,
  SYSTEM_PROPERTY_IDS.DUE_DATE,
  SYSTEM_PROPERTY_IDS.PROJECT,
];

export function TaskBoardView(props: {
  data: TaskBoardData;
  onOpen(task: TaskBoardTask, event: MouseEvent): void;
  onCreate?: (columnId: string) => void;
  /** Wraps a card's content, such as in the host's context menu. */
  renderCard: (
    task: Accessor<TaskBoardTask>,
    content: JSX.Element
  ) => JSX.Element;
  ref?: (element: HTMLDivElement) => void;
}) {
  const { state, source, showTaskProject, setFacets, setState, calendar } =
    useTasksView();
  const grouping = () => toTaskBoardGrouping(state.groupBy);
  const scope = () =>
    JSON.stringify([
      state.tab,
      grouping(),
      state.search,
      state.facets,
      state.sort,
      state.dueDate,
      calendar().today,
      calendar().timeZone,
    ]);
  const deadlineMove = createTaskDeadlineMove({ calendar, scope });
  const board = createTaskBoard({
    grouping,
    scope,
    columns: props.data.columns,
    task: props.data.task,
    actions: props.data.actions,
    compareTasks: props.data.compareTasks,
    prepareMove: deadlineMove.prepare,
  });
  const [readError, setReadError] = createSignal<string>();
  const loading = source.boardLoading ?? source.isLoading;
  const sortLabel = () =>
    state.search.trim()
      ? 'search order'
      : (TASK_SORT_OPTIONS.find(
          (option) => option.id === (state.sort[0]?.id ?? 'updated_at')
        )?.label ?? 'Updated');
  const cardPropertyIds = () =>
    CARD_PROPERTY_IDS.filter((id) => {
      if (
        id !== SYSTEM_PROPERTY_IDS.DUE_DATE &&
        id === taskBoardPropertyId(grouping())
      ) {
        return false;
      }

      return id !== SYSTEM_PROPERTY_IDS.PROJECT || showTaskProject();
    });

  const revealHiddenColumns = () => {
    if (grouping() === 'due_date') {
      setState('dueDate', undefined);
      return;
    }
    const facets = { ...state.facets };
    delete facets[taskBoardFacetId(grouping())];
    setFacets(facets);
  };

  const read = async (operation: () => Promise<void>) => {
    setReadError(undefined);

    try {
      await operation();
    } catch {
      setReadError('Could not load tasks. Try again.');
    }
  };

  const renderProperty = (
    task: Accessor<TaskBoardTask>,
    readOnly: Accessor<boolean>,
    id: string,
    iconOnly: boolean,
    includeEmpty = true
  ) => (
    <Show when={props.data.property(task().id, id)}>
      {(property) => (
        <Show when={includeEmpty || hasValue(property())}>
          <Suspense fallback={<span class="size-6" />}>
            <TaskBoardProperty
              property={property()}
              taskId={task().id}
              canEdit={!readOnly() && props.data.canEditProperty(task().id, id)}
              iconOnly={iconOnly}
              dueDateUrgency={
                id === SYSTEM_PROPERTY_IDS.DUE_DATE
                  ? taskDueDateUrgency(
                      task().dueDate,
                      task().closed ?? true,
                      calendar()
                    )
                  : undefined
              }
              onSave={async (value, apiValues) => {
                try {
                  if (readOnly()) {
                    throw new Error('Task is no longer editable');
                  }

                  await props.data.saveProperty(task().id, value, apiValues);
                } catch (error) {
                  toast.failure(
                    `Could not update ${value.displayName.toLowerCase()}`
                  );
                  throw error;
                }
              }}
            />
          </Suspense>
        </Show>
      )}
    </Show>
  );

  const renderCardContent = (
    task: Accessor<TaskBoardTask>,
    readOnly: Accessor<boolean>
  ) => (
    <>
      <TaskBoard.CardHeader>
        <div data-kanban-no-drag class="flex shrink-0 items-center">
          {renderProperty(task, readOnly, SYSTEM_PROPERTY_IDS.STATUS, true)}
        </div>
        <button
          type="button"
          class="min-w-0 break-words text-left text-sm font-medium leading-6 text-ink hover:underline"
          onClick={(event) => {
            if (event.detail > 1) {
              return;
            }

            props.onOpen(task(), event);
          }}
        >
          {task().name || 'Untitled task'}
        </button>
        <div data-kanban-no-drag class="flex shrink-0 items-center">
          {renderProperty(task, readOnly, SYSTEM_PROPERTY_IDS.ASSIGNEES, true)}
        </div>
      </TaskBoard.CardHeader>
      <TaskBoard.CardFields>
        <div data-kanban-no-drag class="contents">
          <For each={cardPropertyIds()}>
            {(id) => {
              const iconOnly = id === SYSTEM_PROPERTY_IDS.PRIORITY;
              const includeEmpty = id === SYSTEM_PROPERTY_IDS.PRIORITY;

              return renderProperty(task, readOnly, id, iconOnly, includeEmpty);
            }}
          </For>
        </div>
      </TaskBoard.CardFields>
    </>
  );

  return (
    <div class="flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden">
      <Show when={loading()}>
        <p role="status" class="p-4 text-sm text-ink-muted">
          Loading tasks…
        </p>
      </Show>
      <Show when={source.error() || readError()}>
        <div
          role="alert"
          class="flex items-center gap-2 px-4 py-2 text-sm text-failure"
        >
          Could not load all tasks.
          <Button
            variant="ghost"
            size="sm"
            onClick={() => fireAndForget(read(source.refresh), 'tasks-view')}
          >
            Retry
          </Button>
        </div>
      </Show>
      <Show when={props.data.definitionError()}>
        <div role="alert" class="px-4 py-2 text-sm text-failure">
          Could not load task properties. Moving tasks is unavailable.
          <Button
            variant="ghost"
            size="sm"
            onClick={() =>
              fireAndForget(read(props.data.retryDefinitions), 'tasks-view')
            }
          >
            Retry
          </Button>
        </div>
      </Show>
      <Show when={board.error()}>
        {(error) => (
          <p role="alert" class="px-4 py-2 text-sm text-ink-muted">
            {error()}
          </p>
        )}
      </Show>
      <TaskBoard.Root
        ref={props.ref}
        animationScope={scope()}
        columns={board.columns()}
        canMove={board.canMove}
        onMove={board.move}
      >
        <TaskBoard.Columns
          endColumn={
            props.data.hiddenColumnCount() > 0
              ? () => (
                  <TaskBoard.HiddenColumns
                    count={props.data.hiddenColumnCount()}
                    partial={
                      grouping() === 'assignee' || grouping() === 'project'
                    }
                    onReveal={revealHiddenColumns}
                  />
                )
              : undefined
          }
        >
          {(column) => (
            <TaskBoard.Column>
              <TaskBoard.Header>
                <TaskBoardColumnHeader
                  column={column()}
                  grouping={grouping()}
                  createAssigneeName={props.data.createAssigneeName}
                />
                <Show when={props.onCreate}>
                  <div class="ml-auto flex shrink-0">
                    <Button
                      aria-label={`Add task to ${column().label}`}
                      tooltip={`Add task to ${column().label}`}
                      size="icon-sm"
                      variant="ghost"
                      onClick={() => props.onCreate?.(column().id)}
                    >
                      <PlusIcon class="size-3.5 touch:size-6 shrink-0 pointer-events-none" />
                    </Button>
                  </div>
                </Show>
              </TaskBoard.Header>
              <TaskBoard.DropOverlay>
                Board sorted by {sortLabel()}
              </TaskBoard.DropOverlay>
              <TaskBoard.Cards
                empty={
                  <p class="px-2 py-6 text-center text-xs text-ink-extra-muted">
                    No matching tasks
                  </p>
                }
                footer={
                  <Switch>
                    <Match when={column().hasMore}>
                      <TaskBoardColumnContinuation
                        isLoading={column().loadingMore}
                        failed={Boolean(source.groupError?.(column().id))}
                        onLoad={() =>
                          fireAndForget(
                            source.loadMoreGroup(column().id),
                            'tasks-view'
                          )
                        }
                      />
                    </Match>
                    {/* Ungrouped results (search) continue from any column's end. */}
                    <Match when={source.hasMore()}>
                      <TaskBoardColumnContinuation
                        isLoading={source.isLoadingMore()}
                        failed={Boolean(source.error())}
                        onLoad={() =>
                          fireAndForget(source.loadMore(), 'tasks-view')
                        }
                      />
                    </Match>
                  </Switch>
                }
              >
                {(task) => {
                  const readOnly = () =>
                    !props.data.actions.canEditTask(task().id) ||
                    board.pending(task().id);

                  return (
                    <TaskBoard.Card
                      task={task()}
                      canDrag={!readOnly()}
                      pending={board.pending(task().id)}
                      onOpen={props.onOpen}
                    >
                      {props.renderCard(
                        task,
                        renderCardContent(task, readOnly)
                      )}
                    </TaskBoard.Card>
                  );
                }}
              </TaskBoard.Cards>
            </TaskBoard.Column>
          )}
        </TaskBoard.Columns>
      </TaskBoard.Root>
      <TaskDeadlineMoveDialog
        picker={deadlineMove.picker()}
        onChange={deadlineMove.select}
        onApply={deadlineMove.apply}
        onCancel={deadlineMove.cancel}
      />
    </div>
  );
}

/** Requests the column's next page while near its visible cards; a failure waits for Retry. */
function TaskBoardColumnContinuation(props: {
  isLoading: boolean;
  failed: boolean;
  onLoad: () => void;
}) {
  const [sentinel, setSentinel] = createSignal<HTMLDivElement>();
  useInfiniteScrollSentinel({
    sentinel,
    hasNextPage: () => !props.failed,
    isFetchingNextPage: () => props.isLoading,
    fetchNextPage: () => props.onLoad(),
  });

  return (
    <div
      ref={setSentinel}
      aria-busy={!props.failed}
      class="flex flex-wrap items-center justify-center gap-2 py-3 text-xs text-ink-muted"
    >
      <Show
        when={props.failed}
        fallback={<SpinnerIcon class="size-4 animate-spin" />}
      >
        <span>Couldn’t load more tasks.</span>
        <Button size="sm" variant="secondary" onClick={() => props.onLoad()}>
          Retry
        </Button>
      </Show>
    </div>
  );
}

function TaskBoardColumnHeader(props: {
  column: TaskBoardColumn;
  grouping: TaskBoardGrouping;
  createAssigneeName: TaskBoardData['createAssigneeName'];
}) {
  const label = () => (
    <TaskBoard.ColumnLabel title={props.column.label}>
      {props.column.label}
    </TaskBoard.ColumnLabel>
  );
  const countLabel = () => {
    const loaded = props.column.tasks.length;

    if (props.column.count === undefined) {
      return `${loaded} loaded tasks`;
    }

    return `${loaded} loaded of ${props.column.count} tasks`;
  };

  return (
    <>
      <span
        class="flex size-5 shrink-0 items-center justify-center"
        aria-hidden="true"
      >
        <Suspense>
          <TaskBoardColumnIcon
            propertyDefinitionId={taskBoardPropertyId(props.grouping)}
            id={props.column.id}
          />
        </Suspense>
      </span>
      <Show
        when={props.grouping === 'assignee' && props.column.id}
        fallback={label()}
      >
        <Suspense fallback={label()}>
          <AssigneeColumnLabel
            id={props.column.id}
            fallback={props.column.label}
            createAssigneeName={props.createAssigneeName}
          />
        </Suspense>
      </Show>
      <TaskBoard.ColumnCount
        count={props.column.count ?? props.column.tasks.length}
        aria-label={countLabel()}
      />
    </>
  );
}

function AssigneeColumnLabel(props: {
  id: string;
  fallback: string;
  createAssigneeName: TaskBoardData['createAssigneeName'];
}) {
  const resolvedName = props.createAssigneeName(() => props.id);
  const name = () => resolvedName() || props.fallback;

  return <TaskBoard.ColumnLabel title={name()}>{name()}</TaskBoard.ColumnLabel>;
}