Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
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>
);
}
}