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 { fireAndForget } from '@core/util/fireAndForget';
import ArrowLeftIcon from '@icon/system/regular/arrow-left.svg';
import ArrowRightIcon from '@icon/system/regular/arrow-right.svg';
import TableIcon from '@icon/system/regular/table.svg';
import TrashIcon from '@icon/system/regular/trash.svg';
import { ContextMenu } from '@kobalte/core/context-menu';
import { Key } from '@solid-primitives/keyed';
import { createResizeObserver } from '@solid-primitives/resize-observer';
import { DragDropProvider, DragOverlay } from '@thisbeyond/solid-dnd';
import { DeleteDialog } from '@ui/components/DeleteDialog';
import { Dropdown } from '@ui/components/Dropdown';
import { TabSelector } from '@ui/components/TabSelector';
import { Tooltip } from '@ui/components/Tooltip';
import {
createEffect,
createSignal,
createUniqueId,
type JSX,
on,
Show,
} from 'solid-js';
import { createHorizontalReorder } from '../../../components/drag-drop/create-horizontal-reorder';
import { createReorderItem } from '../../../components/drag-drop/create-reorder';
import { DragSessionSensors } from '../../../components/drag-drop/drag-session-sensors';
import { InsertionLine } from '../../../components/drag-drop/insertion-line';
import {
ContextMenuContent,
MenuItem,
MenuSeparator,
} from '../../../lib/core/component/ContextMenu';
import {
type DatabaseSchemaChange,
tableRenameMessage,
} from '../core/column-schema';
import { isDatabaseNameTaken } from '../core/property-creation';
import type { CreateTable } from '../core/table-creation';
import { createInlineRename } from './inline-rename';
import { NewTableTab } from './new-table-tab';
export function TableNavigation(props: {
tables: { id: string; name: string }[];
activeTableId: string | undefined;
canCreate: boolean;
/** Additional feature-owned creation/navigation items in the add menu. */
menuItems?: () => JSX.Element;
onSelect: (tableId: string) => void;
onCreate: CreateTable;
onRename?: (
tableId: string,
name: string,
previousName: string
) => DatabaseSchemaChange;
/** Persist a new tab order: every table id, left to right. */
onReorder?: (tableIds: string[]) => void;
/** Delete a table the viewer confirmed; never offered for a database's only table. */
onDelete?: (tableId: string) => void;
/** What else deleting a table removes, e.g. the forms writing to it. */
deleteConsequence?: (tableId: string) => string | undefined;
}) {
const [deleting, setDeleting] = createSignal<{ id: string; name: string }>();
const [open, setOpen] = createSignal(false);
const [createError, setCreateError] = createSignal('');
const [createdTableId, setCreatedTableId] = createSignal<string>();
const createErrorId = createUniqueId();
const closeDraft = (restoreFocus: boolean) => {
setOpen(false);
setCreateError('');
setCreatedTableId(undefined);
if (restoreFocus) queueMicrotask(() => createButton?.focus());
};
const [tabRail, setTabRail] = createSignal<HTMLDivElement>();
const renameErrorId = createUniqueId();
const [menuTarget, setMenuTarget] = createSignal<{
table: { id: string; name: string };
origin: HTMLElement;
}>();
let menuTrigger: HTMLSpanElement | undefined;
let renameInput: HTMLInputElement | undefined;
let createButton: HTMLButtonElement | undefined;
const canRename = () => props.canCreate && !!props.onRename;
const canReorder = () =>
props.canCreate && !!props.onReorder && props.tables.length > 1;
const canDelete = () =>
props.canCreate && !!props.onDelete && props.tables.length > 1;
const moveTable = (
tableId: string,
targetId: string,
edge: 'before' | 'after'
) => {
const order = props.tables.map((table) => table.id);
const remaining = order.filter((id) => id !== tableId);
const target = remaining.indexOf(targetId);
if (!order.includes(tableId) || target < 0) return;
remaining.splice(target + Number(edge === 'after'), 0, tableId);
if (remaining.join() === order.join()) return;
props.onReorder?.(remaining);
};
const tabReorder = createHorizontalReorder({
order: () => props.tables.map((table) => table.id),
getViewport: tabRail,
enabled: canReorder,
verticalSlack: DROP_SLACK_PX,
previewMarker: 'data-tab-drag-preview',
indicatorLeft: (boundary, rail) =>
boundary - rail.getBoundingClientRect().left + rail.scrollLeft,
onDrop: moveTable,
});
const neighbour = (tableId: string | undefined, direction: -1 | 1) => {
const index = props.tables.findIndex((table) => table.id === tableId);
return index < 0 ? undefined : props.tables[index + direction];
};
const moveBy = (tableId: string, direction: -1 | 1) => {
const target = neighbour(tableId, direction);
if (target)
moveTable(tableId, target.id, direction < 0 ? 'before' : 'after');
};
const tableRename = createInlineRename({
name: (target: RenamingTable) => target.name,
rename: (target, name) => {
if (!props.onRename) throw new Error('Renaming a table needs onRename');
return props.onRename(target.id, name, target.name);
},
failureMessage: tableRenameMessage,
emptyName: { message: 'Enter a table name.', onBlur: 'keep-editing' },
validate: (name, target) =>
isDatabaseNameTaken(
name,
props.tables
.filter((table) => table.id !== target.id)
.map((table) => table.name)
)
? 'A table with this name already exists. Try another name.'
: undefined,
input: () => renameInput,
restoreFocus: (target) => target.origin?.focus(),
});
const renaming = tableRename.target;
const rename = (
table: { id: string; name: string },
origin?: HTMLElement
) => {
if (!canRename()) return;
const width = origin?.getBoundingClientRect().width;
tableRename.begin({
id: table.id,
name: table.name,
width: width
? `${width}px`
: `${Math.max(10, Math.min(24, table.name.length + 5))}ch`,
origin,
});
};
const openMenu = (
table: { id: string; name: string },
origin: HTMLElement,
x: number,
y: number
) => {
if (!canRename() && !canReorder()) return;
setMenuTarget({ table: { ...table }, origin });
menuTrigger?.dispatchEvent(
new MouseEvent('contextmenu', {
bubbles: true,
cancelable: true,
clientX: x,
clientY: y,
})
);
};
const revealSelectedTable = () => {
const rail = tabRail();
const selected =
rail?.querySelector<HTMLElement>('input[aria-label="Table name"]') ??
rail?.querySelector<HTMLElement>('[data-selected]');
if (!rail || !selected) return;
const viewport = rail.getBoundingClientRect();
const tab = selected.getBoundingClientRect();
if (tab.left < viewport.left) rail.scrollLeft += tab.left - viewport.left;
else if (tab.right > viewport.right)
rail.scrollLeft += tab.right - viewport.right;
};
createResizeObserver(tabRail, revealSelectedTable);
createEffect(
on(
[
() => props.activeTableId,
() => props.tables,
() => renaming()?.id,
tabRail,
],
() => {
// Kobalte applies the selected attribute while rendering the tab list.
queueMicrotask(revealSelectedTable);
}
)
);
// Keep the menu outside Tabs because both primitives own a DOM collection.
return (
<ContextMenu>
<ContextMenu.Trigger
as="span"
ref={menuTrigger}
class="hidden"
aria-hidden="true"
/>
<TabSelector>
<span class="sr-only">Tables</span>
<Show
when={props.tables.length > 0 || open()}
fallback={
<span class="min-w-0 flex-1 text-xs text-ink-placeholder">
No tables yet
</span>
}
>
<DragDropProvider
collisionDetector={tabReorder.collisionDetector}
onDragStart={tabReorder.onDragStart}
onDragEnd={tabReorder.onDragEnd}
>
<DragSessionSensors
getViewport={tabRail}
axis="x"
onCancel={tabReorder.cancel}
/>
<TabSelector.Root
value={props.activeTableId ?? ''}
onChange={props.onSelect}
activationMode="manual"
class="min-w-0"
>
<TabSelector.List ref={setTabRail} aria-label="Database tables">
<Key
each={props.tables.filter(
(table) => table.id !== createdTableId()
)}
by="id"
>
{(table) => (
<DraggableTab
id={table().id}
canDrag={canReorder() && renaming()?.id !== table().id}
onDragStart={tabReorder.start}
style={{
width:
renaming()?.id === table().id
? renaming()?.width
: undefined,
}}
>
<Tooltip label={table().name}>
<TabSelector.Tab
value={table().id}
aria-haspopup={
canRename() || canReorder() ? 'menu' : undefined
}
aria-keyshortcuts={
canRename() ? 'F2 Shift+F10' : undefined
}
onDblClick={(
event: MouseEvent & {
currentTarget: HTMLButtonElement;
}
) => {
if (!canRename()) return;
event.preventDefault();
event.stopPropagation();
rename(table(), event.currentTarget);
}}
onContextMenu={(
event: MouseEvent & {
currentTarget: HTMLButtonElement;
}
) => {
if (!canRename() && !canReorder()) return;
event.preventDefault();
event.stopPropagation();
openMenu(
table(),
event.currentTarget,
event.clientX,
event.clientY
);
}}
onKeyDown={(event) => {
if (!canRename() && !canReorder()) return;
if (event.key === 'F2' && canRename()) {
event.preventDefault();
event.stopPropagation();
rename(table(), event.currentTarget);
} else if (
event.key === 'ContextMenu' ||
(event.shiftKey && event.key === 'F10')
) {
event.preventDefault();
event.stopPropagation();
const bounds =
event.currentTarget.getBoundingClientRect();
openMenu(
table(),
event.currentTarget,
bounds.left,
bounds.bottom
);
}
}}
classList={{ hidden: renaming()?.id === table().id }}
>
<TableIcon class="size-3.5 shrink-0" />
<span class="truncate">{table().name}</span>
</TabSelector.Tab>
</Tooltip>
<Show when={renaming()?.id === table().id}>
<input
ref={renameInput}
aria-label="Table name"
aria-invalid={!!tableRename.error()}
aria-describedby={
tableRename.error() ? renameErrorId : undefined
}
aria-busy={tableRename.pending()}
maxlength={200}
value={tableRename.draft()}
readOnly={tableRename.pending()}
onFocusIn={(event) => event.stopPropagation()}
onMouseDown={(event) => event.stopPropagation()}
class="h-8 w-full min-w-0 rounded-full border border-ink/40 bg-input px-3 text-xs text-ink outline-none not-touch:text-sm"
onInput={(event) =>
tableRename.setDraft(event.currentTarget.value)
}
onBlur={(event) => {
event.stopPropagation();
fireAndForget(tableRename.save(false), 'database');
}}
onKeyDown={(event) => {
event.stopPropagation();
if (event.isComposing || event.keyCode === 229)
return;
if (event.key === 'Enter') {
event.preventDefault();
fireAndForget(tableRename.save(true), 'database');
} else if (event.key === 'Escape') {
event.preventDefault();
tableRename.cancel(true);
}
}}
/>
</Show>
</DraggableTab>
)}
</Key>
<Show when={open()}>
<NewTableTab
existingNames={props.tables.map((table) => table.name)}
onCreate={props.onCreate}
onOpenTable={props.onSelect}
onClose={closeDraft}
onError={setCreateError}
onCreated={setCreatedTableId}
errorId={createErrorId}
/>
</Show>
<Show when={tabReorder.drop()}>
{(drop) => (
<InsertionLine
drop={drop()}
class="inset-y-1"
data-tab-drop-indicator
/>
)}
</Show>
</TabSelector.List>
</TabSelector.Root>
<DragOverlay
class="pointer-events-none select-none rounded-md bg-panel shadow-md"
style={{ 'z-index': 1000 }}
>
{tabReorder.preview()}
</DragOverlay>
</DragDropProvider>
</Show>
<Show when={props.canCreate || props.menuItems}>
<TabSelector.AddMenu
label="Add table or form"
onCloseAutoFocus={(event) => {
if (!open()) return;
event.preventDefault();
queueMicrotask(() =>
tabRail()
?.querySelector<HTMLInputElement>('form input')
?.focus()
);
}}
ref={(element) => {
createButton = element;
}}
>
<Show when={props.canCreate}>
<Dropdown.Item onSelect={() => setOpen(true)}>
<TableIcon class="size-4" />
New table
</Dropdown.Item>
</Show>
{props.menuItems?.()}
</TabSelector.AddMenu>
</Show>
</TabSelector>
<Show when={createError()}>
<p id={createErrorId} role="alert" class="mt-1 text-xs text-failure">
{createError()}
</p>
</Show>
<Show when={tableRename.error()}>
<p id={renameErrorId} role="alert" class="mt-1 text-xs text-failure">
{tableRename.error()}
</p>
</Show>
<ContextMenu.Portal>
<ContextMenuContent
class="min-w-44"
onCloseAutoFocus={(event) => {
event.preventDefault();
if (!renaming()) menuTarget()?.origin.focus();
}}
>
<MenuItem
text="Rename table"
closeOnSelect
shortcut="F2"
disabled={!canRename()}
onClick={() => {
const target = menuTarget();
if (target) rename(target.table, target.origin);
}}
/>
<Show when={props.onReorder}>
<MenuSeparator />
<MenuItem
text="Move left"
icon={ArrowLeftIcon}
closeOnSelect
disabled={!canReorder() || !neighbour(menuTarget()?.table.id, -1)}
onClick={() => {
const target = menuTarget();
if (target) moveBy(target.table.id, -1);
}}
/>
<MenuItem
text="Move right"
icon={ArrowRightIcon}
closeOnSelect
disabled={!canReorder() || !neighbour(menuTarget()?.table.id, 1)}
onClick={() => {
const target = menuTarget();
if (target) moveBy(target.table.id, 1);
}}
/>
</Show>
<Show when={props.onDelete}>
<MenuSeparator />
<MenuItem
text="Delete table"
icon={TrashIcon}
closeOnSelect
disabled={!canDelete()}
onClick={() => {
const target = menuTarget();
if (target && canDelete()) setDeleting({ ...target.table });
}}
/>
</Show>
</ContextMenuContent>
</ContextMenu.Portal>
<DeleteDialog
open={!!deleting()}
onOpenChange={(open) => {
if (!open) setDeleting(undefined);
}}
title="Delete table?"
deleteLabel="Delete table"
onDelete={() => {
const target = deleting();
setDeleting(undefined);
if (target && canDelete()) props.onDelete?.(target.id);
}}
body={
<>
<p>
“{deleting()?.name}” will be deleted for everyone, with its
columns, records and views.
</p>
<Show
when={(() => {
const target = deleting();
return target && props.deleteConsequence?.(target.id);
})()}
>
{(consequence) => <p class="mt-2">{consequence()}</p>}
</Show>
</>
}
/>
</ContextMenu>
);
}
type RenamingTable = {
id: string;
name: string;
/** The input keeps the tab's width, so the strip does not shift. */
width: string;
/** The tab that takes focus back once the rename is done. */
origin?: HTMLElement;
};
/** How far above or below the tab strip a drag may stray and still drop. */
const DROP_SLACK_PX = 24;
function DraggableTab(props: {
id: string;
canDrag: boolean;
onDragStart: (event: MouseEvent) => void;
style: JSX.CSSProperties;
children: JSX.Element;
}) {
const item = createReorderItem(props.id, {
canDrag: () => props.canDrag,
ignore: 'input',
start: (event) => props.onDragStart(event),
});
return (
<div
ref={item.ref}
class="flex shrink-0 items-center"
classList={{ 'opacity-40': item.dragging() }}
style={props.style}
onMouseDown={item.onMouseDown}
>
{props.children}
</div>
);
}