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.

61.9 KB
Raw Blame
import { DocumentOutline } from '@app/components/DocumentOutline';
import { FloatRegion } from '@components/app/mobile/float-regions/FloatRegion';
import {
  MobileCreateMenu,
  type MobileCreateMenuItem,
} from '@components/app/mobile/MobileCreateMenu';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
import { virtualKeyboardVisible } from '@core/mobile/virtualKeyboard';
import { fireAndForget } from '@core/util/fireAndForget';
import ArrowSquareOut from '@icon/system/regular/arrow-square-out.svg';
import CalendarCheck from '@icon/system/regular/calendar-check.svg';
import Database from '@icon/system/regular/database.svg';
import Plus from '@icon/system/regular/plus.svg';
import ShieldCheck from '@icon/system/regular/shield-check.svg';
import Warning from '@icon/system/regular/warning.svg';
import { makeEventListener } from '@solid-primitives/event-listener';
import { createResizeObserver } from '@solid-primitives/resize-observer';
import {
  Badge,
  Button,
  badgeTriggerClasses,
  Dialog,
  Dropdown,
  Panel,
} from '@ui';
import { errAsync, okAsync, ResultAsync } from 'neverthrow';
import {
  type Accessor,
  createMemo,
  createSignal,
  createUniqueId,
  For,
  type JSX,
  Match,
  Show,
  Switch,
  untrack,
} from 'solid-js';
import { match } from 'ts-pattern';
import { v7 as uuidv7 } from 'uuid';
import {
  BookingCard,
  BookingLinkMenu,
  type BookingLinkState,
} from '../components/builder/booking-card';
import { BookingLinkDialog } from '../components/builder/booking-link-dialog';
import {
  BuilderSkeleton,
  ConversionNotice,
  DropIndicator,
  HiddenColumns,
  TitleCard,
} from '../components/builder/builder-chrome';
import {
  DragHandle,
  DragInstructions,
} from '../components/builder/drag-handle';
import { InsertionPoint } from '../components/builder/insertion-point';
import { OptionListEditor } from '../components/builder/option-list-editor';
import { QuestionPreview } from '../components/builder/question-body';
import { QuestionFooter } from '../components/builder/question-footer';
import { QuestionRow } from '../components/builder/question-row';
import {
  GateCard,
  RoutingFooter,
  SectionCard,
  SectionCondition,
  SectionMenu,
} from '../components/builder/section-card';
import {
  AddQuestionMenu,
  type RelationTable,
  TypeMenu,
} from '../components/builder/type-menu';
import { QuestionTypeIcon } from '../components/question-type-icon';
import {
  type FormDetailSource,
  type FormLayoutCollaboration,
  type FormTableSource,
  type FormWriteFailure,
  useFormContext,
} from '../context/form-context';
import type { Box, MeasuredSection } from '../core/drop-target';
import { placementOf, stepPlacement } from '../core/drop-target';
import {
  bookingStep,
  brokenRuleColumns,
  type QuestionPlacement,
  questionNumbers,
  ruleColumns,
} from '../core/form-layout';
import type {
  FormBookingTarget,
  FormColumn,
  FormDetail,
  FormLayout,
  FormSection,
  GateRules,
  SectionKind,
} from '../core/form-model';
import { availabilityLine, formAvailability } from '../core/form-status';
import {
  placementDescription,
  routingLine,
  sectionName,
  sectionPosition,
} from '../core/layout-messages';
import {
  hasOptions,
  QUESTION_TYPE_CHOICES,
  type QuestionTypeChoice,
  type QuestionTypeId,
  questionTypeLabel,
  questionTypeOf,
} from '../core/question-types';
import { rulesSentence } from '../core/rule-sentence';
import {
  type Builder,
  createBuilder,
  type NewSectionKind,
} from '../primitives/create-builder';
import {
  createBuilderDrag,
  type DragTarget,
} from '../primitives/create-builder-drag';

function boxOf(element: Element): Box {
  const { top, bottom, left, right } = element.getBoundingClientRect();
  return { top, bottom, left, right };
}

type TrackWrites = (flush: () => ResultAsync<void, FormWriteFailure>) => void;

type BuilderViewProps = {
  source: FormDetailSource;
  detail: FormDetail;
  /** The layout every editor of the form edits at once. */
  collaboration: FormLayoutCollaboration;
  active?: boolean;
  /** Registers writes a preview waits for, while the builder is open. */
  trackWrites: TrackWrites;
  onOpenDatabase: (databaseId: string) => void;
};

/**
 * The Build tab (RFC 02 §3): sections and questions on a centered column,
 * the rail beside it. Column facts go to the database's ops, presentation to
 * the layout every editor shares. Nothing is editable until it opened.
 */
export function BuilderView(props: BuilderViewProps) {
  const context = useFormContext();
  const table = context.createTableSource(
    () => props.detail.form.databaseId,
    () => props.detail.form.tableId
  );
  context.followTable(
    () => props.detail.form.databaseId,
    () => fireAndForget(props.source.refetch(), 'form-builder')
  );
  const columnWrites = createMemo(() =>
    context.columns(props.detail.form.databaseId, props.detail.form.tableId)
  );
  const builder = createBuilder({
    active: () => props.active ?? true,
    detail: props.source.detail,
    // Column facts come from both reads, so the builder's read-back takes both.
    refetch: async () => {
      await Promise.all([props.source.refetch(), table.refetch()]);
    },
    tableColumns: table.columns,
    collaboration: props.collaboration,
    columnWrites,
    notify: context.notify,
    mintId: uuidv7,
  });
  // A preview waits for new columns, and the questions naming them.
  props.trackWrites(() => ResultAsync.fromSafePromise(builder.settled()));
  // Away from this window, the other editors see nothing selected here.
  makeEventListener(window, 'blur', () => builder.setPresent(false));
  makeEventListener(window, 'focus', () => builder.setPresent(true));
  const failure = () => {
    const status = props.collaboration.status();
    return status.kind === 'error' ? status.message : undefined;
  };
  return (
    <Show
      when={builder.layout()}
      fallback={
        <Show when={failure()} fallback={<BuilderSkeleton />}>
          {(message) => (
            <div class="mx-auto w-full max-w-[680px] px-4 py-6">
              <LayoutFailure message={message()} />
            </div>
          )}
        </Show>
      }
    >
      {(layout) => (
        <BuilderCanvas
          {...props}
          builder={builder}
          layout={layout}
          table={table}
          failure={failure()}
        />
      )}
    </Show>
  );
}

function LayoutFailure(props: { message: string }) {
  return (
    <div
      role="alert"
      class="flex items-start gap-2 rounded-lg border border-failure bg-failure-bg px-3 py-2.5 text-sm text-failure-ink"
    >
      <Warning class="mt-0.5 size-4 shrink-0" aria-hidden="true" />
      {props.message}
    </div>
  );
}

/** Where edits stand when the server doesn't hold them all; nothing when it does. */
function saveNotice(collaboration: FormLayoutCollaboration) {
  if (collaboration.save() === 'unstored')
    return 'Your changes couldn’t be stored on this device. Keep this tab open until they’re saved.';
  if (collaboration.connection() === 'offline')
    return 'You’re offline. Your changes are kept on this device and sync when you reconnect.';
  if (collaboration.save() === 'unsaved')
    return 'Some changes haven’t reached the server yet. They’re kept on this device and sent again when it answers.';
  return undefined;
}

function BuilderCanvas(
  props: BuilderViewProps & {
    builder: Builder;
    layout: Accessor<FormLayout>;
    table: FormTableSource;
    /** Why the layout can't be edited now, while it shows what it last read. */
    failure: string | undefined;
  }
) {
  const context = useFormContext();
  const builder = props.builder;
  const table = props.table;
  const form = () => props.detail.form;
  const summary = context.responses.createSummary(
    () => props.detail.form.id,
    () => props.detail.access !== 'view'
  );
  // The form's name and description: a preview waits for them too.
  const metadataWrites = new Set<Promise<boolean>>();
  async function writeMetadata(written: PromiseLike<boolean>) {
    const pending = Promise.resolve(written);
    metadataWrites.add(pending);
    try {
      return await pending;
    } finally {
      metadataWrites.delete(pending);
    }
  }
  props.trackWrites(() =>
    ResultAsync.fromSafePromise(Promise.all(metadataWrites)).andThen((saved) =>
      saved.every(Boolean)
        ? okAsync(undefined)
        : errAsync({ message: 'The form’s name or description wasn’t saved.' })
    )
  );
  const editorsOn = (sectionId: string, questionId: string | null) =>
    props.collaboration
      .peers()
      .filter(
        (peer) =>
          peer.selection.sectionId === sectionId &&
          peer.selection.questionId === questionId
      );
  const editors = (sectionId: string, questionId: string | null) => (
    <Show when={editorsOn(sectionId, questionId).length > 0}>
      {context.ui.renderEditors({
        get peers() {
          return editorsOn(sectionId, questionId);
        },
        selected: questionId ? 'this question' : 'this section',
      })}
    </Show>
  );
  const [editingRules, setEditingRules] = createSignal<string>();
  /** The filter editor over the questions before a section, for its gate rules or condition. */
  const rulesEditor = (
    sectionId: string,
    rules: () => GateRules | null,
    onChange: (rules: GateRules | null) => void
  ) => (
    <div class="flex flex-col gap-2 rounded-lg border border-edge-muted bg-surface p-3">
      {
        // Rendered once per opening, its props read live: a save must not
        // remount the editor and drop a condition still being filled.
        untrack(() =>
          context.ui.renderConditionEditor({
            get columns() {
              return ruleColumns(layout(), sectionId).flatMap(
                (columnId): FormColumn[] => {
                  const found = builder.column(columnId);
                  return found ? [found] : [];
                }
              );
            },
            get rules() {
              return rules();
            },
            onChange,
          })
        )
      }
      <Button
        size="sm"
        variant="ghost"
        class="self-end"
        onClick={() => setEditingRules(undefined)}
      >
        Done
      </Button>
    </div>
  );
  const [choosingBooking, setChoosingBooking] = createSignal(false);
  let afterMenuClose: (() => void) | undefined;
  const sectionAddTriggers = new Map<string, HTMLButtonElement>();
  let dialogReturnFocus: HTMLButtonElement | undefined;
  const [pendingRelation, setPendingRelation] = createSignal<{
    choice: QuestionTypeChoice;
    placement: QuestionPlacement | undefined;
  }>();
  // One per mount: the same form can be built in two splits.
  const instructionsId = createUniqueId();
  let viewport: HTMLDivElement | undefined;
  const [outlineViewport, setOutlineViewport] = createSignal<HTMLDivElement>();
  const [viewportHeight, setViewportHeight] = createSignal(0);
  createResizeObserver(outlineViewport, (entries) => {
    setViewportHeight(entries.height);
  });
  let column: HTMLDivElement | undefined;

  const layout = props.layout;
  const sectionIds = () => layout().sections.map((section) => section.id);
  const sectionById = (sectionId: string) =>
    layout().sections.find((section) => section.id === sectionId);
  const questionSections = () =>
    layout().sections.filter((section) => section.kind === 'questions');
  const numbers = createMemo(() => questionNumbers(layout()));
  const relationTables = (): RelationTable[] =>
    table.tables().map((entry) => ({
      databaseId: props.detail.form.databaseId,
      tableId: entry.id,
      name: entry.name,
    }));
  const columnTitle = (columnId: string) =>
    builder.column(columnId)?.name ?? 'Untitled question';
  const questionTitle = (questionId: string) => {
    const placement = placementOf(layout(), questionId);
    const question = placement
      ? sectionById(placement.sectionId)?.questions.find(
          (item) => item.id === questionId
        )
      : undefined;
    return question ? columnTitle(question.columnId) : 'question';
  };

  function measureQuestions(): MeasuredSection[] {
    if (!viewport) return [];
    return [
      ...viewport.querySelectorAll<HTMLElement>('[data-form-section]'),
    ].map((section) => {
      const id = section.dataset.formSection ?? '';
      const list = section.querySelector(`[data-form-section-list="${id}"]`);
      return {
        id,
        kind: match(section.dataset.sectionKind)
          .returnType<SectionKind>()
          .with('gate', () => 'gate')
          .with('booking', () => 'booking')
          .otherwise(() => 'questions'),
        box: boxOf(section),
        list: boxOf(list ?? section),
        questions: [
          ...(list?.querySelectorAll<HTMLElement>('[data-form-question]') ??
            []),
        ].map((question) => ({
          id: question.dataset.formQuestion ?? '',
          box: boxOf(question),
        })),
      };
    });
  }

  const describe = (target: DragTarget) =>
    match(target)
      .with({ kind: 'question' }, ({ id }) => `question “${questionTitle(id)}”`)
      .with({ kind: 'section' }, ({ id }) => `“${sectionName(layout(), id)}”`)
      .with({ kind: 'new-section' }, ({ id }) =>
        id === 'gate' ? 'gate' : 'section'
      )
      .with(
        { kind: 'new-question' },
        ({ id }) => `${questionChoice(id).label} question`
      )
      .exhaustive();

  function questionChoice(id: QuestionTypeId) {
    const choice = QUESTION_TYPE_CHOICES.find((choice) => choice.id === id);
    if (!choice) throw new Error(`Unknown question palette type: ${id}`);
    return choice;
  }

  async function insertQuestion(
    choice: QuestionTypeChoice,
    placement?: QuestionPlacement,
    relation?: RelationTable
  ) {
    if (choice.kind === 'pick-table' && !relation) {
      setPendingRelation({ choice, placement });
      return;
    }
    const previousSelection = builder.selectedId();
    await builder.addQuestion(choice, relation, placement);
    const selected = builder.selectedId();
    if (!selected || selected === previousSelection) return;
    const question = viewport?.querySelector<HTMLElement>(
      `[data-form-question="${selected}"]`
    );
    question?.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
    question
      ?.querySelector<HTMLInputElement>('input[aria-label="Question"]')
      ?.focus({ preventScroll: true });
  }

  /** Focus a question's or section's drag handle, wherever it now renders. */
  const focusHandle = (target: DragTarget) =>
    viewport
      ?.querySelector<HTMLElement>(
        `[data-drag-handle="${target.kind}:${target.id}"]`
      )
      ?.focus({ preventScroll: false });

  const drag = createBuilderDrag({
    layout,
    viewport: () => viewport,
    canvas: () => column,
    measureQuestions,
    measureSections: () =>
      measureQuestions().map(({ id, box }) => ({ id, box })),
    refusalForQuestion: builder.questionMoveRefusal,
    refusalForSection: builder.sectionMoveRefusal,
    dropQuestion: (questionId, placement) => {
      builder.moveQuestion(questionId, placement);
      builder.select(questionId);
    },
    dropSection: builder.moveSection,
    dropNewSection: (kind, index) => {
      const id = builder.addSection(kind, index);
      if (id && kind === 'gate') setEditingRules(id);
      return id;
    },
    dropNewQuestion: (type, placement) =>
      fireAndForget(
        insertQuestion(questionChoice(type), placement),
        'form-builder'
      ),
    describe,
    describePlacement: (questionId, placement) =>
      placementDescription(layout(), questionId, placement),
    focusHandle,
  });

  const indicatorTop = () => {
    const lineY = drag.session()?.lineY;
    if (lineY === undefined || !column) return undefined;
    return lineY - column.getBoundingClientRect().top;
  };

  const moveByStep = (questionId: string, direction: 'up' | 'down') => {
    const from = placementOf(layout(), questionId);
    const to = from && stepPlacement(layout(), questionId, from, direction);
    if (!to) return;
    if (!builder.moveQuestion(questionId, to)) return;
    drag.refocus({ kind: 'question', id: questionId });
  };

  const moveToSection = (questionId: string, sectionId: string) => {
    const target = sectionById(sectionId);
    if (!target) return;
    builder.moveQuestion(questionId, {
      sectionId,
      index: target.questions.length,
    });
  };

  async function confirmDeleteColumn(questionId: string, columnId: string) {
    const name = columnTitle(columnId);
    const rows = summary.value()?.rows;
    const confirmed = await context.confirm({
      title: `Delete the column “${name}”?`,
      body: `This deletes the column from ${table.tableName() ?? 'the table'} with every answer in it${rows !== undefined ? ` (${rows === 1 ? '1 row' : `${rows} rows`})` : ''}. To keep the answers, remove the question from the form instead.`,
      confirmLabel: 'Delete column',
      tone: 'danger',
    });
    if (confirmed) await builder.deleteColumn(questionId);
  }

  async function confirmRemoveSection(section: FormSection) {
    if (section.kind === 'questions' && section.questions.length > 0) {
      const confirmed = await context.confirm({
        title: `Delete “${sectionName(layout(), section.id)}”?`,
        body: `Its ${section.questions.length === 1 ? 'question leaves' : `${section.questions.length} questions leave`} the form. The columns and their answers stay in the table.`,
        confirmLabel: 'Delete section',
        tone: 'danger',
      });
      if (!confirmed) return;
    }
    builder.removeSection(section.id);
  }

  const booking = () => bookingStep(layout());
  const bookingLinks = context.booking.createLinks(
    () => !props.detail.tableGone
  );
  /** What a booking card shows of its own `target`. */
  const bookingLinkState = (
    target: Accessor<FormBookingTarget | undefined>
  ): Accessor<BookingLinkState> => {
    const event = context.booking.createEvent(target);
    return () => {
      const read = event.value();
      if (read === undefined)
        return event.failure() ? { kind: 'unavailable' } : { kind: 'loading' };
      if (read === null) return { kind: 'unavailable' };
      return {
        kind: 'ready',
        title: read.event.title,
        durationMinutes: read.event.durationMinutes,
        host: read.profile.name,
      };
    };
  };

  /** Bring the booking step into view and focus it. */
  const revealBooking = (sectionId: string) =>
    queueMicrotask(() => {
      const card = viewport?.querySelector<HTMLElement>(
        `[data-form-section="${sectionId}"]`
      );
      card?.scrollIntoView({ block: 'center', behavior: 'smooth' });
      card?.focus({ preventScroll: true });
    });

  const bookingMenu = (menuProps: {
    trigger: JSX.Element;
    triggerLabel?: string;
    triggerClass: string;
    triggerVariant: 'outline' | 'secondary' | 'ghost';
    selected?: FormBookingTarget;
    onChoose: (target: FormBookingTarget) => void;
  }) => (
    <BookingLinkMenu
      links={bookingLinks.value()}
      failed={!!bookingLinks.failure()}
      selected={menuProps.selected}
      trigger={menuProps.trigger}
      triggerLabel={menuProps.triggerLabel}
      triggerClass={menuProps.triggerClass}
      triggerVariant={menuProps.triggerVariant}
      disabled={props.detail.tableGone}
      onChoose={menuProps.onChoose}
      onCreate={context.booking.openSettings}
    />
  );

  const addBooking = () => {
    const existing = booking();
    if (existing) revealBooking(existing.id);
    else setChoosingBooking(true);
  };
  // Touch floats these above the dock, in place of the page's New.
  const addActions = (): MobileCreateMenuItem[] => [
    {
      label: 'Section',
      icon: Plus,
      disabled: props.detail.tableGone,
      onSelect: () => addSectionAndFocus('questions'),
    },
    {
      label: 'Gate',
      icon: ShieldCheck,
      disabled: props.detail.tableGone,
      onSelect: () => addSectionAndFocus('gate'),
    },
    ...(booking() || context.booking.available()
      ? [
          {
            label: booking() ? 'View meeting link' : 'Meeting link',
            icon: CalendarCheck,
            disabled: props.detail.tableGone,
            onSelect: addBooking,
          },
        ]
      : []),
  ];

  const hiddenColumnRows = () =>
    builder.hiddenColumns().map((hidden) => ({
      id: hidden.id,
      name: hidden.name,
      type: questionTypeOf(hidden.kind, null),
      label: questionTypeLabel(hidden.kind, null),
    }));

  return (
    <div
      ref={(element) => {
        viewport = element;
        setOutlineViewport(element);
        setViewportHeight(element.clientHeight);
      }}
      data-form-builder-background
      class="@container/builder relative h-full min-h-0 overflow-y-auto bg-canvas-base touch:pb-(--mobile-content-inset-bottom)"
      onClick={(event) => {
        if (
          !(event.target instanceof HTMLElement) ||
          !event.target.hasAttribute('data-form-builder-background')
        )
          return;
        // Commit blur-saved inputs before their selected editor unmounts.
        const focused = document.activeElement;
        if (focused instanceof HTMLElement && viewport?.contains(focused))
          focused.blur();
        builder.select(undefined);
        setEditingRules(undefined);
      }}
    >
      <DragInstructions id={instructionsId} />
      <div aria-live="assertive" aria-atomic="true" class="sr-only">
        {drag.announcement()}
      </div>
      <div data-form-builder-background class="relative min-h-full px-6">
        <div class="mx-auto flex w-full max-w-3xl min-w-0 flex-col gap-6 pt-12 pb-24">
          <TitleCard
            databaseLink={
              <>
                <Button
                  variant="secondary"
                  size="sm"
                  class={badgeTriggerClasses({
                    variant: 'outline',
                    size: 'sm',
                    class: 'max-w-full text-ink-muted',
                  })}
                  aria-label={`Open database ${table.databaseName() ?? 'Database'}`}
                  tooltip={table.databaseName() ?? 'Database'}
                  onClick={() => props.onOpenDatabase(form().databaseId)}
                >
                  <Database class="size-3 text-code" aria-hidden="true" />
                  <span class="truncate">
                    {table.databaseName() ?? 'Database'}
                  </span>
                  <ArrowSquareOut class="size-3" aria-hidden="true" />
                </Button>
                <Badge variant="outline" size="sm">
                  {availabilityLine(
                    formAvailability(
                      form(),
                      props.detail.tableGone,
                      new Date()
                    ),
                    new Date()
                  )}
                </Badge>
              </>
            }
            name={form().name}
            description={form().description}
            onName={(name) =>
              writeMetadata(
                context.renameForm(form().id, name).match(
                  () => true,
                  (failure) => {
                    context.notify.failure(
                      `The form couldn’t be renamed: ${failure.message}`
                    );
                    return false;
                  }
                )
              )
            }
            onDescription={(description) =>
              writeMetadata(
                context.updateMetadata(form().id, { description }).match(
                  () => true,
                  (failure) => {
                    context.notify.failure(
                      `The description wasn’t saved: ${failure.message}`
                    );
                    return false;
                  }
                )
              )
            }
          />
          <div
            role="region"
            aria-label="Form canvas"
            data-form-builder-background
            class="flex w-full min-w-0 flex-col gap-4"
          >
            <Show when={props.detail.tableGone}>
              <div
                role="alert"
                class="flex items-start gap-2 rounded-lg border border-failure bg-failure-bg px-3 py-2.5 text-sm text-failure-ink"
              >
                <Warning class="mt-0.5 size-4 shrink-0" aria-hidden="true" />
                This form’s table was deleted or its database is in the trash.
                It can’t take responses until the database is restored.
              </div>
            </Show>
            <Show when={props.failure}>
              {(message) => <LayoutFailure message={message()} />}
            </Show>
            <Show when={props.collaboration.publicationError()}>
              {(problem) => (
                <LayoutFailure
                  message={`Respondents still see the last valid version of this form. ${problem()}`}
                />
              )}
            </Show>
            <Show when={saveNotice(props.collaboration)}>
              {(notice) => (
                <p
                  role="status"
                  class="rounded-lg border border-edge-muted bg-panel px-3 py-2 text-sm text-ink-muted"
                >
                  {notice()}
                </p>
              )}
            </Show>
            <Show when={builder.conversion()}>
              {(pending) => (
                <ConversionNotice
                  message={pending().message}
                  label={pending().label}
                  onConvert={() =>
                    fireAndForget(builder.convertQuestion(), 'form-builder')
                  }
                  onDismiss={builder.dismissConversion}
                />
              )}
            </Show>
            <div ref={column} class="relative flex flex-col gap-10">
              <Show when={layout().sections.length === 0}>
                <div class="flex min-h-72 items-center justify-center rounded-xl border border-dashed border-edge bg-surface p-6 text-sm text-ink-muted">
                  Click a question type or drag it here.
                </div>
              </Show>
              <For each={sectionIds()}>
                {(sectionId) => {
                  const section = () => sectionById(sectionId);
                  const index = () =>
                    layout().sections.findIndex(
                      (item) => item.id === sectionId
                    );
                  const sectionTarget: DragTarget = {
                    kind: 'section',
                    id: sectionId,
                  };
                  const handle = () => (
                    <DragHandle
                      instructionsId={instructionsId}
                      data-drag-handle={`section:${sectionId}`}
                      label={`Move ${sectionName(layout(), sectionId)}`}
                      dragging={drag.isDragging(sectionTarget)}
                      disabled={props.detail.tableGone}
                      handle={drag.handleProps(() => sectionTarget)}
                    />
                  );
                  const menu = () => (
                    <SectionMenu
                      label={`${sectionName(layout(), sectionId)} actions`}
                      canMoveUp={
                        index() > 0 &&
                        !builder.sectionMoveRefusal(sectionId, index() - 1)
                      }
                      canMoveDown={
                        index() < layout().sections.length - 1 &&
                        !builder.sectionMoveRefusal(sectionId, index() + 1)
                      }
                      deleteLabel={
                        section()?.kind === 'gate'
                          ? 'Delete gate'
                          : 'Delete section'
                      }
                      onMoveUp={() =>
                        builder.moveSection(sectionId, index() - 1)
                      }
                      onMoveDown={() =>
                        builder.moveSection(sectionId, index() + 1)
                      }
                      onAddCondition={
                        section()?.kind === 'questions' &&
                        !section()?.showWhen &&
                        editingRules() !== sectionId &&
                        ruleColumns(layout(), sectionId).length > 0
                          ? () => setEditingRules(sectionId)
                          : undefined
                      }
                      onDelete={() => {
                        const current = section();
                        if (current)
                          fireAndForget(
                            confirmRemoveSection(current),
                            'form-builder'
                          );
                      }}
                    />
                  );
                  return (
                    <div class="relative min-w-0">
                      <Show when={index() > 0 && !props.detail.tableGone}>
                        <InsertionPoint betweenSections>
                          <Dropdown>
                            <Dropdown.Trigger
                              variant="secondary"
                              size="sm"
                              class="h-6 shrink-0 bg-surface px-2"
                              aria-label={`Insert before ${sectionName(layout(), sectionId)}`}
                            >
                              <Plus class="size-3.5" />
                              Add
                            </Dropdown.Trigger>
                            <Dropdown.Content onCloseAutoFocus={runAfterClose}>
                              <Dropdown.Item
                                onSelect={() =>
                                  insertSectionBefore('questions', sectionId)
                                }
                              >
                                <Plus class="size-4" />
                                Section
                              </Dropdown.Item>
                              <Dropdown.Item
                                onSelect={() =>
                                  insertSectionBefore('gate', sectionId)
                                }
                              >
                                <ShieldCheck class="size-4" />
                                Gate
                              </Dropdown.Item>
                            </Dropdown.Content>
                          </Dropdown>
                        </InsertionPoint>
                      </Show>
                      <Show when={section()}>
                        {(current) => (
                          <Switch>
                            <Match when={current().kind === 'gate'}>
                              <GateCard
                                sectionId={sectionId}
                                eyebrow={`Gate ${sectionPosition(layout(), sectionId)}`}
                                title={current().title}
                                sentence={rulesSentence(
                                  current().gateRules,
                                  builder.columns()
                                )}
                                message={current().gateMessage}
                                dragging={drag.isDragging(sectionTarget)}
                                editingRules={editingRules() === sectionId}
                                brokenRules={
                                  brokenRuleColumns(layout(), sectionId).length
                                }
                                onRepair={() => builder.repairRules(sectionId)}
                                handle={handle()}
                                menu={menu()}
                                noQuestionsBefore={
                                  ruleColumns(layout(), sectionId).length === 0
                                }
                                onEditRules={() => setEditingRules(sectionId)}
                                onTitle={(title) =>
                                  builder.updateSection(sectionId, { title })
                                }
                                onMessage={(gateMessage) =>
                                  builder.updateSection(sectionId, {
                                    gateMessage,
                                  })
                                }
                                ruleEditor={rulesEditor(
                                  sectionId,
                                  () => current().gateRules,
                                  (gateRules) =>
                                    builder.updateSection(sectionId, {
                                      gateRules: gateRules ?? {
                                        conjunction: 'and',
                                        conditions: [],
                                      },
                                    })
                                )}
                              />
                            </Match>
                            <Match
                              when={current().kind === 'booking' && current()}
                            >
                              {(booking) => {
                                const link = bookingLinkState(
                                  () => booking().bookingTarget ?? undefined
                                );
                                return (
                                  <BookingCard
                                    sectionId={sectionId}
                                    title={current().title}
                                    description={current().description}
                                    link={link()}
                                    menu={
                                      <SectionMenu
                                        label={`${sectionName(layout(), sectionId)} actions`}
                                        canMoveUp={false}
                                        canMoveDown={false}
                                        deleteLabel="Remove booking step"
                                        onMoveUp={() => {}}
                                        onMoveDown={() => {}}
                                        onDelete={() =>
                                          builder.removeSection(sectionId)
                                        }
                                      />
                                    }
                                    change={bookingMenu({
                                      trigger: 'Change',
                                      triggerLabel: 'Change booking link',
                                      triggerClass: 'shrink-0',
                                      triggerVariant: 'secondary',
                                      selected:
                                        current().bookingTarget ?? undefined,
                                      onChoose: (target) =>
                                        builder.changeBookingTarget(
                                          sectionId,
                                          target
                                        ),
                                    })}
                                    onTitle={(title) =>
                                      builder.updateSection(sectionId, {
                                        title,
                                      })
                                    }
                                    onDescription={(description) =>
                                      builder.updateSection(sectionId, {
                                        description,
                                      })
                                    }
                                  />
                                );
                              }}
                            </Match>
                            <Match when={current().kind === 'questions'}>
                              <SectionCard
                                sectionId={sectionId}
                                eyebrow={`Section ${sectionPosition(layout(), sectionId)} of ${questionSections().length}`}
                                title={current().title}
                                description={current().description}
                                questionCount={current().questions.length}
                                empty={current().questions.length === 0}
                                dragging={drag.isDragging(sectionTarget)}
                                targeted={
                                  builder.targetSectionId() === sectionId
                                }
                                onTarget={() => builder.focusSection(sectionId)}
                                addQuestion={
                                  <AddQuestionMenu
                                    triggerClass="h-14 rounded-none border-0 bg-transparent px-5 text-sm"
                                    triggerRef={(element) => {
                                      sectionAddTriggers.set(
                                        sectionId,
                                        element
                                      );
                                    }}
                                    trigger={
                                      <>
                                        <Plus class="size-3.5" />
                                        Add question
                                      </>
                                    }
                                    tables={relationTables()}
                                    hiddenColumns={hiddenColumnRows()}
                                    disabled={props.detail.tableGone}
                                    onChoose={(choice, relation) => {
                                      afterMenuClose = () => {
                                        dialogReturnFocus =
                                          sectionAddTriggers.get(sectionId);
                                        fireAndForget(
                                          insertQuestion(
                                            choice,
                                            {
                                              sectionId,
                                              index: current().questions.length,
                                            },
                                            relation
                                          ),
                                          'form-builder'
                                        );
                                      };
                                    }}
                                    onCloseAutoFocus={runAfterClose}
                                    onAddColumn={(columnId) =>
                                      builder.addExistingColumn(columnId, {
                                        sectionId,
                                        index: current().questions.length,
                                      })
                                    }
                                  />
                                }
                                handle={handle()}
                                menu={menu()}
                                editors={editors(sectionId, null)}
                                condition={
                                  <Show
                                    when={
                                      current().showWhen ||
                                      editingRules() === sectionId
                                    }
                                  >
                                    <SectionCondition
                                      sentence={rulesSentence(
                                        current().showWhen,
                                        builder.columns()
                                      )}
                                      editing={editingRules() === sectionId}
                                      brokenRules={
                                        brokenRuleColumns(layout(), sectionId)
                                          .length
                                      }
                                      onRepair={() =>
                                        builder.repairRules(sectionId)
                                      }
                                      onEdit={() => setEditingRules(sectionId)}
                                      onRemove={() =>
                                        builder.updateSection(sectionId, {
                                          showWhen: null,
                                        })
                                      }
                                      editor={rulesEditor(
                                        sectionId,
                                        () => current().showWhen,
                                        (rules) =>
                                          builder.updateSection(sectionId, {
                                            showWhen:
                                              rules &&
                                              rules.conditions.length > 0
                                                ? rules
                                                : null,
                                          })
                                      )}
                                    />
                                  </Show>
                                }
                                onTitle={(title) =>
                                  builder.updateSection(sectionId, { title })
                                }
                                onDescription={(description) =>
                                  builder.updateSection(sectionId, {
                                    description,
                                  })
                                }
                                routing={
                                  <RoutingFooter
                                    next={routingLine(layout(), sectionId)}
                                  />
                                }
                              >
                                <For
                                  each={current().questions.map(
                                    (question) => question.id
                                  )}
                                >
                                  {(questionId, questionIndex) => (
                                    <div class="relative min-w-0">
                                      <Show
                                        when={
                                          questionIndex() > 0 &&
                                          !props.detail.tableGone
                                        }
                                      >
                                        <QuestionInsertion
                                          sectionId={sectionId}
                                          beforeId={questionId}
                                        />
                                      </Show>
                                      <QuestionItem
                                        questionId={questionId}
                                        sectionId={sectionId}
                                      />
                                    </div>
                                  )}
                                </For>
                              </SectionCard>
                            </Match>
                          </Switch>
                        )}
                      </Show>
                    </div>
                  );
                }}
              </For>
              <Show when={indicatorTop() !== undefined}>
                <DropIndicator
                  top={indicatorTop() ?? 0}
                  refusal={drag.session()?.refusal}
                />
              </Show>
            </div>
            <HiddenColumns
              columns={hiddenColumnRows()}
              onAdd={(columnId) => builder.addExistingColumn(columnId)}
            />
            <Show
              when={!isTouchDevice()}
              fallback={
                <FloatRegion
                  region="accessory"
                  active={() =>
                    (props.active ?? true) && !virtualKeyboardVisible()
                  }
                >
                  <div class="flex justify-end px-(--mobile-chrome-gutter)">
                    <MobileCreateMenu label="Add" items={addActions()} />
                  </div>
                </FloatRegion>
              }
            >
              <div
                class="mt-6 flex flex-wrap gap-3"
                role="group"
                aria-label="Add to form"
              >
                <Button
                  variant="secondary"
                  size="md"
                  class="h-14 min-w-max flex-1 justify-start gap-2 rounded-xl px-5"
                  disabled={props.detail.tableGone}
                  onClick={() => addSectionAndFocus('questions')}
                >
                  <Plus class="size-4" />
                  Add section
                </Button>
                <Button
                  variant="secondary"
                  size="md"
                  class="h-14 min-w-max flex-1 justify-start gap-2 rounded-xl px-5"
                  disabled={props.detail.tableGone}
                  onClick={() => addSectionAndFocus('gate')}
                >
                  <ShieldCheck class="size-4" />
                  Add gate
                </Button>
                <Show when={booking() || context.booking.available()}>
                  <Button
                    variant="secondary"
                    size="md"
                    class="h-14 min-w-max flex-1 justify-start gap-2 rounded-xl px-5"
                    disabled={props.detail.tableGone}
                    onClick={(event) => {
                      const existing = booking();
                      if (existing) {
                        revealBooking(existing.id);
                      } else {
                        dialogReturnFocus = event.currentTarget;
                        setChoosingBooking(true);
                      }
                    }}
                  >
                    <CalendarCheck class="size-4" />
                    {booking() ? 'View meeting link' : 'Add meeting link'}
                  </Button>
                </Show>
              </div>
            </Show>
          </div>
        </div>
        <div class="pointer-events-none absolute inset-y-0 left-4 z-1 hidden w-10 @min-[880px]/builder:block">
          <Show when={outlineViewport()}>
            {(mount) => (
              <DocumentOutline
                label="Form outline"
                items={layout().sections.flatMap((section) => [
                  {
                    key: section.id,
                    text: sectionName(layout(), section.id),
                    preview: section.questions
                      .map((q) => columnTitle(q.columnId))
                      .join(' · '),
                  },
                  ...section.questions.map((question) => ({
                    key: question.id,
                    text: columnTitle(question.columnId),
                    preview: questionTypeLabel(
                      builder.column(question.columnId)?.kind ?? {
                        type: 'text',
                      },
                      question.widget
                    ),
                  })),
                ])}
                activeKeys={
                  new Set(
                    [builder.selectedId() ?? builder.targetSectionId()].filter(
                      (id): id is string => !!id
                    )
                  )
                }
                viewportHeight={viewportHeight()}
                portalMount={mount()}
                onSelect={(key) => {
                  const section = sectionById(key);
                  if (section) builder.focusSection(key);
                  else builder.select(key);
                  viewport
                    ?.querySelector(
                      `[data-form-${section ? 'section' : 'question'}="${key}"]`
                    )
                    ?.scrollIntoView({
                      block: section ? 'start' : 'center',
                      behavior: 'instant',
                    });
                }}
              />
            )}
          </Show>
        </div>
      </div>
      <Show when={choosingBooking()}>
        <BookingLinkDialog
          links={bookingLinks.value()}
          failed={!!bookingLinks.failure()}
          onChoose={(target) => {
            const result = builder.addBooking(target);
            if (result) afterMenuClose = () => revealBooking(result.sectionId);
            setChoosingBooking(false);
          }}
          onCreate={() => {
            dialogReturnFocus = undefined;
            setChoosingBooking(false);
            context.booking.openSettings();
          }}
          onClose={() => setChoosingBooking(false)}
          onCloseAutoFocus={focusAfterDialog}
        />
      </Show>
      <Show when={pendingRelation()}>
        {(pending) => (
          <Dialog
            open
            onOpenChange={(open) => {
              if (!open) setPendingRelation(undefined);
            }}
            onCloseAutoFocus={focusAfterDialog}
            class="w-96 max-w-[calc(100vw-2rem)]"
          >
            <Panel>
              <Panel.Body>
                <div class="flex flex-col gap-3 p-5">
                  <Dialog.Title class="text-base font-semibold">
                    Choose a table
                  </Dialog.Title>
                  <Dialog.Description class="text-sm text-ink-muted">
                    Respondents choose a row from this table.
                  </Dialog.Description>
                  <For each={relationTables()}>
                    {(relation) => (
                      <Button
                        variant="secondary"
                        class="justify-start"
                        onClick={() => {
                          const current = pending();
                          setPendingRelation(undefined);
                          fireAndForget(
                            insertQuestion(
                              current.choice,
                              current.placement,
                              relation
                            ),
                            'form-builder'
                          );
                        }}
                      >
                        <Database class="size-4" />
                        {relation.name}
                      </Button>
                    )}
                  </For>
                  <Button
                    variant="ghost"
                    onClick={() => setPendingRelation(undefined)}
                  >
                    Cancel
                  </Button>
                </div>
              </Panel.Body>
            </Panel>
          </Dialog>
        )}
      </Show>
    </div>
  );

  function addSection(kind: NewSectionKind) {
    const id = builder.addSection(kind, layout().sections.length);
    if (!id) return;
    if (kind === 'gate') setEditingRules(id);
    return id;
  }

  function runAfterClose(event: Event) {
    const action = afterMenuClose;
    afterMenuClose = undefined;
    if (!action) return;
    event.preventDefault();
    // Kobalte restores focus and releases its modal lock after this callback.
    // Finish that cleanup before focusing an insertion or opening a drawer.
    queueMicrotask(action);
  }

  function focusAfterDialog(event: Event) {
    const trigger = dialogReturnFocus;
    dialogReturnFocus = undefined;
    if (afterMenuClose) {
      runAfterClose(event);
    } else if (trigger) {
      event.preventDefault();
      queueMicrotask(() => trigger.focus());
    }
  }

  function addSectionAndFocus(kind: NewSectionKind) {
    const id = addSection(kind);
    if (id) queueMicrotask(() => focusHandle({ kind: 'section', id }));
  }

  function insertSectionBefore(kind: NewSectionKind, beforeId: string) {
    const index = layout().sections.findIndex(
      (section) => section.id === beforeId
    );
    if (index < 0) return;
    const id = builder.addSection(kind, index);
    if (!id) return;
    if (kind === 'gate') setEditingRules(id);
    afterMenuClose = () => focusHandle({ kind: 'section', id });
  }

  function QuestionInsertion(insertion: {
    sectionId: string;
    beforeId: string;
  }) {
    let trigger: HTMLButtonElement | undefined;
    const placement = (): QuestionPlacement | undefined => {
      const index = sectionById(insertion.sectionId)?.questions.findIndex(
        (question) => question.id === insertion.beforeId
      );
      return index !== undefined && index >= 0
        ? { sectionId: insertion.sectionId, index }
        : undefined;
    };
    return (
      <InsertionPoint>
        <AddQuestionMenu
          triggerClass="h-6 w-auto! shrink-0 bg-surface px-2 text-xs"
          triggerRef={(element) => {
            trigger = element;
          }}
          trigger={
            <>
              <Plus class="size-3.5" />
              <span class="sr-only">
                Insert question before {questionTitle(insertion.beforeId)}
              </span>
            </>
          }
          tables={relationTables()}
          hiddenColumns={hiddenColumnRows()}
          onChoose={(choice, relation) => {
            afterMenuClose = () => {
              const at = placement();
              if (!at) return;
              dialogReturnFocus = trigger;
              fireAndForget(
                insertQuestion(choice, at, relation),
                'form-builder'
              );
            };
          }}
          onAddColumn={(columnId) => {
            afterMenuClose = () => {
              const at = placement();
              if (at) void builder.addExistingColumn(columnId, at);
            };
          }}
          onCloseAutoFocus={runAfterClose}
        />
      </InsertionPoint>
    );
  }

  function QuestionItem(itemProps: { questionId: string; sectionId: string }) {
    const question = () =>
      sectionById(itemProps.sectionId)?.questions.find(
        (item) => item.id === itemProps.questionId
      );
    const target: DragTarget = { kind: 'question', id: itemProps.questionId };
    return (
      <Show when={question()}>
        {(current) => {
          const columnOf = () => builder.column(current().columnId);
          return (
            <Show
              when={columnOf()}
              fallback={
                <div class="px-4 py-3 text-xs text-ink-muted">
                  This question’s column was deleted.
                </div>
              }
            >
              {(columnFacts) => {
                const typeId = () =>
                  questionTypeOf(columnFacts().kind, current().widget);
                const typeLabel = () =>
                  questionTypeLabel(columnFacts().kind, current().widget);
                const selected = () => builder.selectedId() === current().id;
                const relationName = () => {
                  const kind = columnFacts().kind;
                  return kind.type === 'relation'
                    ? table.tables().find((entry) => entry.id === kind.table)
                        ?.name
                    : undefined;
                };
                const placement = () => placementOf(layout(), current().id);
                const canStep = (direction: 'up' | 'down') => {
                  const from = placement();
                  const to =
                    from &&
                    stepPlacement(layout(), current().id, from, direction);
                  return !!to && !builder.questionMoveRefusal(current().id, to);
                };
                return (
                  <QuestionRow
                    questionId={current().id}
                    number={numbers().get(current().id) ?? 0}
                    title={columnFacts().name}
                    helpText={current().helpText}
                    required={current().required}
                    selected={selected()}
                    dragging={drag.isDragging(target)}
                    busy={builder.isColumnBusy(columnFacts().id)}
                    editors={editors(itemProps.sectionId, current().id)}
                    onSelect={() => builder.select(current().id)}
                    onRename={(name) =>
                      fireAndForget(
                        builder.renameQuestion(current().id, name),
                        'form-builder'
                      )
                    }
                    onHelpText={(helpText) =>
                      builder.updateQuestion(current().id, { helpText })
                    }
                    handle={
                      <DragHandle
                        instructionsId={instructionsId}
                        data-drag-handle={`question:${current().id}`}
                        label={`Move question “${columnFacts().name}”`}
                        dragging={drag.isDragging(target)}
                        disabled={props.detail.tableGone}
                        handle={drag.handleProps(() => target)}
                      />
                    }
                    typeChip={
                      <Show
                        when={selected()}
                        fallback={
                          <span class="inline-flex items-center gap-1.5 rounded-full border border-edge-muted px-2 py-0.5 text-xs text-ink-muted">
                            <QuestionTypeIcon
                              type={typeId()}
                              class="size-3.5"
                            />
                            {typeLabel()}
                          </span>
                        }
                      >
                        <TypeMenu
                          current={typeId()}
                          label={typeLabel()}
                          tables={relationTables()}
                          disabled={builder.isColumnBusy(columnFacts().id)}
                          onChoose={(choice, relation) =>
                            fireAndForget(
                              builder.changeType(
                                current().id,
                                choice,
                                relation
                              ),
                              'form-builder'
                            )
                          }
                        />
                      </Show>
                    }
                    preview={
                      <QuestionPreview
                        type={typeId()}
                        column={columnFacts()}
                        relationTableName={relationName()}
                      />
                    }
                    editor={
                      <Show
                        when={hasOptions(columnFacts().kind)}
                        fallback={
                          <div class="flex flex-col gap-1.5">
                            <QuestionPreview
                              type={typeId()}
                              column={columnFacts()}
                              relationTableName={relationName()}
                            />
                            <Show when={typeId() === 'relation'}>
                              <p class="text-xs text-ink-muted">
                                Respondents need access to{' '}
                                {relationName() ?? 'that table'} to pick its
                                rows.
                              </p>
                            </Show>
                          </div>
                        }
                      >
                        <OptionListEditor
                          options={columnFacts().options}
                          multi={
                            typeId() === 'checkboxes' || typeId() === 'tags'
                          }
                          onAdd={(label) =>
                            builder.addOption(current().id, label)
                          }
                          onRename={(optionId, label) =>
                            fireAndForget(
                              builder.updateOption(current().id, optionId, {
                                label,
                              }),
                              'form-builder'
                            )
                          }
                          onRecolor={(optionId, color) =>
                            fireAndForget(
                              builder.updateOption(current().id, optionId, {
                                color,
                              }),
                              'form-builder'
                            )
                          }
                          onDelete={(optionId) =>
                            fireAndForget(
                              builder.deleteOption(current().id, optionId),
                              'form-builder'
                            )
                          }
                        />
                      </Show>
                    }
                    footer={
                      <QuestionFooter
                        required={current().required}
                        canMoveUp={canStep('up')}
                        canMoveDown={canStep('down')}
                        sections={questionSections().map((section) => ({
                          id: section.id,
                          name: sectionName(layout(), section.id),
                          current: section.id === itemProps.sectionId,
                        }))}
                        onRequired={(required) =>
                          builder.updateQuestion(current().id, { required })
                        }
                        onDuplicate={() =>
                          fireAndForget(
                            builder.duplicateQuestion(current().id),
                            'form-builder'
                          )
                        }
                        onRemove={() => builder.removeQuestion(current().id)}
                        onMoveUp={() => moveByStep(current().id, 'up')}
                        onMoveDown={() => moveByStep(current().id, 'down')}
                        onMoveToSection={(sectionId) =>
                          moveToSection(current().id, sectionId)
                        }
                        onDeleteColumn={() =>
                          fireAndForget(
                            confirmDeleteColumn(current().id, columnFacts().id),
                            'form-builder'
                          )
                        }
                      />
                    }
                  />
                );
              }}
            </Show>
          );
        }}
      </Show>
    );
  }
}