@svgrid/enterprise 3.1.8 → 3.1.9

package/dist/fields/grid-access.js

@@ -0,0 +1,120 @@
+/**
+ * What the fields module's own surfaces (the view bar, the gallery and form
+ * views, a board view's moves) need from a grid: the grid behind an api, the
+ * data columns with their types, the primary field, and a way to write a
+ * value that goes through the grid's edit path.
+ */
+import { getAdvancedFilterEngine } from '@svgrid/grid';
+// The grid behind each api object (the grid keeps one api per grid).
+const grids = new WeakMap();
+/** Called on every draw of a grid with fields turned on. */
+export function rememberGrid(ctrl) {
+    const api = ctrl?.buildApi?.();
+    if (api && !grids.has(api))
+        grids.set(api, ctrl);
+}
+/** The grid an api belongs to; undefined until that grid has drawn once. */
+export function gridOf(api) {
+    return api && typeof api === 'object' ? grids.get(api) : undefined;
+}
+export const columnIdOf = (def) => String(def.id ?? def.field ?? '');
+/** Every data column (declared ones with a field), in screen order, hidden ones last. */
+export function fieldColumns(ctrl) {
+    const hidden = (ctrl?.hiddenColumns ?? {});
+    const declared = leaves((ctrl?.internalColumns ?? [])).filter((d) => d.field != null);
+    const byId = new Map(declared.map((d) => [columnIdOf(d), d]));
+    const shownOrder = (ctrl?.allColumns ?? []).map((c) => c.id).filter((id) => byId.has(id));
+    const rest = declared.map(columnIdOf).filter((id) => !shownOrder.includes(id));
+    return [...shownOrder, ...rest].map((id) => {
+        const def = byId.get(id);
+        return {
+            id,
+            field: String(def.field),
+            header: typeof def.header === 'string' ? def.header : id,
+            fieldType: def.fieldType,
+            def,
+            visible: !hidden[id] && def.visible !== false && shownOrder.includes(id),
+        };
+    });
+}
+function leaves(cols) {
+    return cols.flatMap((c) => (Array.isArray(c.columns) && c.columns.length ? leaves(c.columns) : [c]));
+}
+/** The primary field's column id: the `primaryField` prop, matched by id or field. */
+export function primaryIdOf(ctrl) {
+    const p = ctrl?.props?.primaryField;
+    if (typeof p !== 'string' || !p)
+        return null;
+    const cols = leaves((ctrl?.internalColumns ?? []));
+    const hit = cols.find((d) => columnIdOf(d) === p) ?? cols.find((d) => d.field === p);
+    return hit ? columnIdOf(hit) : null;
+}
+/**
+ * Write a value the way an edit in the cell does (undo, validation,
+ * onCellValueChange, last-modified fields). False when the row is not shown
+ * or the cell cannot be edited.
+ */
+export function writeCell(ctrl, rowId, columnId, value) {
+    const at = (ctrl?.allRows ?? []).findIndex((r) => r.id === rowId);
+    if (at < 0 || !ctrl.startEditing?.(at, columnId))
+        return false;
+    ctrl.updateEditingCellValue(value);
+    ctrl.saveEditingCell();
+    return true;
+}
+/** A row's value for a column, through the grid's edit overlay (as the cells read it). */
+export function cellValue(ctrl, row, column) {
+    const base = row.getCellValueByColumnId ? row.getCellValueByColumnId(column.id) : row.original?.[column.field];
+    return ctrl?.getCellDisplayValue ? ctrl.getCellDisplayValue(row.id, column.id, base) : base;
+}
+/** A value as its cell writes it as text (the column's formatter), for titles and search. */
+export function cellText(column, value, row) {
+    const f = column.def.formatter;
+    if (f) {
+        try {
+            return String(f({ value, row, column: { id: column.id, columnDef: column.def } }) ?? '');
+        }
+        catch {
+            /* fall through to the raw value */
+        }
+    }
+    if (Array.isArray(value))
+        return value.map((v) => (v && typeof v === 'object' ? (v.name ?? '') : String(v))).join(', ');
+    return value == null ? '' : String(value);
+}
+/** The rows the grid shows, filtered and sorted, without group header rows. */
+export function dataRows(ctrl) {
+    return (ctrl?.allRows ?? []).filter((r) => r.__treeRow || !(typeof r.getCanExpand === 'function' && r.getCanExpand()));
+}
+const isBanner = (r) => !r.__treeRow && typeof r.getCanExpand === 'function' && r.getCanExpand();
+/**
+ * The grid's advanced filter as a test of one record, or null when nothing
+ * filters. The grid filters after it groups, so a group's own rows still hold
+ * the records the filter hides; this is how a group header leaves them out.
+ */
+export function leafFilter(ctrl) {
+    const expr = ctrl?.advancedFilter;
+    const engine = expr ? getAdvancedFilterEngine() : null;
+    if (!engine)
+        return null;
+    try {
+        return engine(expr, { getValue: ctrl.getRowColumnValue, rows: [] }) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The records under a group row, those the filter keeps. */
+export function groupLeaves(row, keep) {
+    const out = [];
+    const walk = (r) => {
+        for (const s of r.subRows ?? []) {
+            if (isBanner(s))
+                walk(s);
+            else if (!keep || keep(s))
+                out.push(s);
+        }
+    };
+    walk(row);
+    return out;
+}

package/dist/fields/index.d.ts

@@ -0,0 +1,34 @@
+export { registerFieldType, getFieldType, listFieldTypes, fieldPropsOf, fillFieldColumn, type FieldTypeDef, type FieldCellProps, } from './registry.svelte.js';
+export { linkHref, linkText, type LinkKind } from './links.js';
+export { setFieldUsers, getFieldUsers, setCurrentUser, getCurrentUser, registerLinkedTable, unregisterLinkedTable, getLinkedTable, listLinkedTables, type FieldUser, type LinkedTable, } from './sources.svelte.js';
+export { compileFormula, formulaError, FORMULA_FUNCTIONS, FormulaError } from './formula.js';
+export { formatNumber, formatCurrency, formatPercent, formatDuration, parseDuration, formatDate } from './format.js';
+export { BRIGHT, OPTION_COLORS } from './palette.js';
+export { convertValue, countCleared } from './convert.js';
+export { openFieldEditor, closeFieldEditor, openRecord, closeRecord, type OpenRecordRequest } from './editor-request.svelte.js';
+export { default as SvBaseViewBar } from './SvBaseViewBar.svelte';
+export { default as SvBaseForm } from './SvBaseForm.svelte';
+export { default as SvBase } from './SvBase.svelte';
+export { blankTable, newRecordId, type BaseTable } from './base-tables.js';
+export { baseSource, createBaseSync, type BaseSource, type BaseSourceOptions, type BaseSyncStatus, type ForeignKeyLink, type JunctionLink, } from './base-sync.js';
+export { baseFieldsFromSchema, baseTablesFromSchemas, baseSpecFromSchemas, baseTablesFromSpec, type BaseTableSpec, type BaseLinkSpec } from './base-schema.js';
+export { baseToSql, sqlName, type BaseToSqlOptions, type BaseTableComment, type BaseJunctionComment } from './base-sql.js';
+export { applyBaseComments, withInverses, type BaseComments } from './base-schema.js';
+export { baseFromDatabase, describeDatabase, createBaseEndpoint, baseFromEndpoint, baseFromSupabase, type DatabaseOptions, type BaseEndpointOptions, type SupabaseBaseOptions } from './base-connect.js';
+export { registerAutomationAction, listAutomationActions, MAX_DEPTH as AUTOMATION_MAX_DEPTH, type BaseAutomation, type AutomationTrigger, type AutomationAction, type AutomationRun, type AutomationStep, type AutomationActionContext, type RegisteredAutomationAction, } from './automations.svelte.js';
+export { createAutomationServer, type AutomationServer, type AutomationServerOptions, type AutomationNotice } from './automation-server.js';
+export type { WebhookAction, EmailAction, OutgoingEmail } from './automation-outbound.js';
+export { setRecordComments, type RecordComment, type RecordCommentContext, type RecordCommentStore } from './activity.svelte.js';
+export { baseCondition, baseFilterOf } from './base-alerts.js';
+export { compileFieldFilter, describeFieldFilter, filterKindOf, operatorsFor, ME, type FieldFilter, type FieldCondition, type FieldConditionGroup, type FilterKind, type FilterOp, } from './filter-model.js';
+export type { FieldView, FieldViewType, ColorSetting } from './view-model.js';
+export type { FieldPropertyDef, FieldEditorContext, FieldFillContext, FieldRowContext } from './registry.svelte.js';
+export { BUILTIN_FIELD_TYPES } from './builtin-types.js';
+export { setAttachmentUploader, attachmentsFromText, attachmentsText, toAttachments, type Attachment, type AttachmentFieldProps, type AttachmentUploader, type AttachmentUploadContext, } from './attachments.js';
+/**
+ * Turn field types on for every `<SvGrid>` on the page: registers the
+ * built-in types and plugs the cell drawing into the grid. Safe to call more
+ * than once. Part of SvGrid Base, a Suite product: without a Suite key the
+ * grid shows the Enterprise watermark and the feature still runs.
+ */
+export declare function enableFields(): void;

package/dist/fields/index.js

@@ -0,0 +1,312 @@
+/**
+ * @svgrid/enterprise/fields - field types for `<SvGrid>`, the engine of SvGrid
+ * Base (a Suite product; `@svgrid/enterprise/base` is the product entry).
+ *
+ * ```ts
+ * import { enableFields } from '@svgrid/enterprise/fields'
+ * enableFields()
+ *
+ * const columns = [
+ *   { field: 'site', header: 'Site', fieldType: 'url' },
+ *   { field: 'score', header: 'Score', fieldType: 'rating' },
+ *   { field: 'status', header: 'Status', fieldType: 'singleSelect',
+ *     fieldProps: { options: [{ value: 'Done', color: '#16a34a' }] } },
+ * ]
+ * ```
+ *
+ * Also draws the grid's `rowAdder` line ("+ Add row" under the last row) and
+ * its `rowColor` marks (a status color on each row's header), the `columnAdder`
+ * "+" with its field editor, and the `fieldMenu` actions in the column menu.
+ *
+ * A separate module, not part of `installEnterprise()`: an app that does not
+ * call `enableFields()` does not ship it, and `@svgrid/grid` carries only the
+ * `registerGridExtension` seam it plugs into.
+ */
+import { registerCellEditor, registerGridExtension, registerGridShortcuts } from '@svgrid/grid';
+import { nudgeEnterpriseFor } from '../license.js';
+import FieldCell from './FieldCell.svelte';
+import RowAdder from './RowAdder.svelte';
+import FootRowAdder from './FootRowAdder.svelte';
+import AttachmentEditor from './AttachmentEditor.svelte';
+import FieldsHeaderEnd from './FieldsHeaderEnd.svelte';
+import { askDeleteField, openFieldEditor, openRecord } from './editor-request.svelte.js';
+import { enableAdvancedFilter, registerFilterKind } from '../advanced-filter-enable.js';
+import { compileFieldFilter, newCondition, resolveMeWith } from './filter-model.js';
+import { hasBar, openBarPanel } from './bar-request.svelte.js';
+import { groupRules, userSorts, writeSortState } from './viewbar/sort-state.js';
+import { sortLabels } from './view-model.js';
+import { noteChange } from './activity.svelte.js';
+import { getLinkedTable } from './sources.svelte.js';
+import { linkNames, registerBaseCondition } from './base-alerts.js';
+import { duplicateField, hideField, indexBeside, removeField } from './field-ops.js';
+import { linkReaders } from './base-tables.js';
+import { formulaReaders } from './formula.js';
+import { BUILTIN_FIELD_TYPES } from './builtin-types.js';
+import { rowColorOf, rowColorRootClass, tallRowClass, rowMarkColor, rowMarkLabel } from './row-colors.js';
+import { chooseRowColor } from './row-color-choice.svelte.js';
+import { fieldPropsOf, fillFieldColumn, getFieldType, originalColumn, registerFieldType, typeDrawsCell } from './registry.svelte.js';
+import RatingEditor from './RatingEditor.svelte';
+import LinkPickerEditor from './LinkPickerEditor.svelte';
+import SelectEditor from './SelectEditor.svelte';
+import NumberEditor from './NumberEditor.svelte';
+import LongTextEditor from './LongTextEditor.svelte';
+import RowHeader from './RowHeader.svelte';
+import GroupHeader from './GroupHeader.svelte';
+import SummaryCell from './SummaryCell.svelte';
+import { getCurrentUser } from './sources.svelte.js';
+import { fieldColumns, gridOf, primaryIdOf, rememberGrid } from './grid-access.js';
+export { registerFieldType, getFieldType, listFieldTypes, fieldPropsOf, fillFieldColumn, } from './registry.svelte.js';
+export { linkHref, linkText } from './links.js';
+export { setFieldUsers, getFieldUsers, setCurrentUser, getCurrentUser, registerLinkedTable, unregisterLinkedTable, getLinkedTable, listLinkedTables, } from './sources.svelte.js';
+export { compileFormula, formulaError, FORMULA_FUNCTIONS, FormulaError } from './formula.js';
+export { formatNumber, formatCurrency, formatPercent, formatDuration, parseDuration, formatDate } from './format.js';
+export { BRIGHT, OPTION_COLORS } from './palette.js';
+export { convertValue, countCleared } from './convert.js';
+export { openFieldEditor, closeFieldEditor, openRecord, closeRecord } from './editor-request.svelte.js';
+export { default as SvBaseViewBar } from './SvBaseViewBar.svelte';
+export { default as SvBaseForm } from './SvBaseForm.svelte';
+export { default as SvBase } from './SvBase.svelte';
+export { blankTable, newRecordId } from './base-tables.js';
+export { baseSource, createBaseSync, } from './base-sync.js';
+export { baseFieldsFromSchema, baseTablesFromSchemas, baseSpecFromSchemas, baseTablesFromSpec } from './base-schema.js';
+export { baseToSql, sqlName } from './base-sql.js';
+export { applyBaseComments, withInverses } from './base-schema.js';
+export { baseFromDatabase, describeDatabase, createBaseEndpoint, baseFromEndpoint, baseFromSupabase } from './base-connect.js';
+export { registerAutomationAction, listAutomationActions, MAX_DEPTH as AUTOMATION_MAX_DEPTH, } from './automations.svelte.js';
+export { createAutomationServer } from './automation-server.js';
+export { setRecordComments } from './activity.svelte.js';
+export { baseCondition, baseFilterOf } from './base-alerts.js';
+export { compileFieldFilter, describeFieldFilter, filterKindOf, operatorsFor, ME, } from './filter-model.js';
+export { BUILTIN_FIELD_TYPES } from './builtin-types.js';
+export { setAttachmentUploader, attachmentsFromText, attachmentsText, toAttachments, } from './attachments.js';
+const MENU_ICON = {
+    edit: 'M4 20h4L19 9l-4-4L4 16zM14 6l4 4',
+    left: 'M10 6l-6 6 6 6M4 12h11M20 5v14',
+    right: 'M14 6l6 6-6 6M20 12H9M4 5v14',
+    duplicate: 'M8 8h12v12H8zM16 8V4H4v12h4',
+    hide: 'M3 3l18 18M10.6 10.6a2 2 0 0 0 2.8 2.8M9.9 5.1A9.8 9.8 0 0 1 12 5c5 0 9 5 10 7a13.4 13.4 0 0 1-3 3.9M6.6 6.6A13.5 13.5 0 0 0 2 12c1 2 5 7 10 7a9.6 9.6 0 0 0 4.4-1.1',
+    remove: 'M4 7h16M9 7V4h6v3M6 7l1 13h10l1-13',
+    color: 'M12 3l6 7a6.5 6.5 0 1 1-12 0l6-7z',
+    filter: 'M4 5h16l-6 7v6l-4 2v-8z',
+    group: 'M4 5h16M4 10h10M4 15h16M4 20h10',
+    info: 'M12 3a9 9 0 1 0 0 18 9 9 0 0 0 0-18zM12 11v5M12 8h.01',
+};
+function fieldMenuItems(ctrl, columnId) {
+    // A single select can color the rows (their header) by its option colors.
+    const def = (ctrl?.internalColumns ?? []).find((c) => String(c.id ?? c.field) === columnId);
+    const colorItem = def?.fieldType === 'singleSelect' && def.field
+        ? rowColorOf(ctrl)?.field === def.field
+            ? { key: 'field-rowcolor', label: 'Stop coloring rows', icon: MENU_ICON.color, run: () => chooseRowColor(ctrl, null) }
+            : {
+                key: 'field-rowcolor',
+                label: 'Color rows by this field',
+                icon: MENU_ICON.color,
+                run: () => chooseRowColor(ctrl, { field: String(def.field), ...(ctrl.props.rowColor?.target ? { target: ctrl.props.rowColor.target } : {}) }),
+            }
+        : null;
+    // The primary field is always first and always there.
+    const primary = primaryIdOf(ctrl) === columnId;
+    // With a view bar over the grid: filter or group by this field, in the bar's panel.
+    const barItems = def && hasBar(ctrl)
+        ? [
+            ...(newCondition(columnId, def)
+                ? [{ key: 'field-filter', label: 'Filter by this field', icon: MENU_ICON.filter, separatorBefore: true, run: () => filterByField(ctrl, columnId, def) }]
+                : []),
+            ...(ctrl.groupingControlsEnabled
+                ? []
+                : [{ key: 'field-group', label: 'Group by this field', icon: MENU_ICON.group, run: () => groupByField(ctrl, columnId) }]),
+        ]
+        : [];
+    return [
+        ...(colorItem ? [colorItem] : []),
+        { key: 'field-edit', label: 'Edit field', icon: MENU_ICON.edit, run: () => openFieldEditor({ ctrl, mode: 'edit', columnId }) },
+        ...(primary ? [] : [{ key: 'field-left', label: 'Insert left', icon: MENU_ICON.left, run: () => openFieldEditor({ ctrl, mode: 'add', index: indexBeside(ctrl, columnId, 'left') }) }]),
+        { key: 'field-right', label: 'Insert right', icon: MENU_ICON.right, run: () => openFieldEditor({ ctrl, mode: 'add', index: indexBeside(ctrl, columnId, 'right') }) },
+        { key: 'field-duplicate', label: 'Duplicate field', icon: MENU_ICON.duplicate, run: () => duplicateField(ctrl, columnId) },
+        ...barItems,
+        ...(primary
+            ? []
+            : [
+                { key: 'field-hide', label: 'Hide field', icon: MENU_ICON.hide, run: () => hideField(ctrl, columnId) },
+                {
+                    key: 'field-delete', label: 'Delete field', icon: MENU_ICON.remove, separatorBefore: true,
+                    // A link with a field back in another table, or with lookups that read it: they all go, so ask first.
+                    // So does a field that formulas read: they would turn to #ERROR without a word.
+                    run: () => (def?.fieldType === 'link' && ((def.fieldProps?.inverse && getLinkedTable(def.fieldProps.table)) || linkReaders({ columns: ctrl.internalColumns }, def).length)) ||
+                        (def && formulaReaders(ctrl.internalColumns ?? [], def).length)
+                        ? askDeleteField({ ctrl, columnId })
+                        : removeField(ctrl, columnId),
+                },
+            ]),
+    ];
+}
+/** "Filter by this field": a new condition on it, in the bar's open Filter panel. */
+function filterByField(ctrl, columnId, def) {
+    const cond = newCondition(columnId, def);
+    if (!cond)
+        return;
+    const now = ctrl.advancedFilter;
+    const base = now?.kind === 'fieldFilter' ? now : { kind: 'fieldFilter', conjunction: 'and', conditions: [] };
+    ctrl.buildApi().setAdvancedFilter({ ...base, conditions: [...base.conditions, cond] });
+    openBarPanel(ctrl, 'filter');
+}
+/** "Group by this field": one more group level, in the bar's open Group panel. */
+function groupByField(ctrl, columnId) {
+    const groups = groupRules(ctrl);
+    if (!groups.some((g) => g.id === columnId))
+        writeSortState(ctrl.buildApi(), [...groups, { id: columnId, desc: false }], userSorts(ctrl));
+    openBarPanel(ctrl, 'group');
+}
+/** Last modified time / by after an edit. With nobody signed in, "by" keeps the last author. */
+function stampModified(ctrl, row, columnId) {
+    if (!row)
+        return;
+    const author = getCurrentUser()?.id;
+    for (const c of (ctrl?.internalColumns ?? [])) {
+        if (c.fieldType !== 'lastModifiedTime' && c.fieldType !== 'lastModifiedBy')
+            continue;
+        const id = String(c.id ?? c.field);
+        if (id === columnId || !c.field)
+            continue;
+        const p = fieldPropsOf(originalColumn(c));
+        if (p.watch === 'specific' && !(p.watchFields ?? []).includes(columnId))
+            continue;
+        if (c.fieldType === 'lastModifiedTime')
+            row[c.field] = new Date().toISOString();
+        else if (author !== undefined)
+            row[c.field] = author;
+    }
+}
+/** The record's activity: what a cell now holds after an edit. */
+function noteEdit(ctrl, row, columnId) {
+    if (!row)
+        return;
+    const def = (ctrl?.allColumns ?? []).find((c) => c.id === columnId)?.columnDef;
+    if (!def?.field)
+        return;
+    const rowId = ctrl.buildApi?.().getRowId?.(row);
+    if (rowId != null)
+        noteChange(ctrl, String(rowId), columnId, row[def.field]);
+}
+/** Space on a cell (not a checkbox, not while editing) expands its row, with `expandRows`. */
+function spaceOpensRecord(e, cmd) {
+    if (e.key !== ' ' || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || cmd.editing || !cmd.activeCell)
+        return false;
+    const ctrl = gridOf(cmd.api);
+    if (!ctrl?.props?.expandRows)
+        return false;
+    const col = (ctrl.allColumns ?? []).find((c) => c.id === cmd.activeCell.columnId);
+    if (col?.columnDef.editorType === 'checkbox')
+        return false;
+    const row = (ctrl.allRows ?? [])[cmd.activeCell.rowIndex];
+    if (!row)
+        return false;
+    e.preventDefault();
+    openRecord({ ctrl, rowId: row.id });
+    return true;
+}
+let enabled = false;
+/**
+ * Turn field types on for every `<SvGrid>` on the page: registers the
+ * built-in types and plugs the cell drawing into the grid. Safe to call more
+ * than once. Part of SvGrid Base, a Suite product: without a Suite key the
+ * grid shows the Enterprise watermark and the feature still runs.
+ */
+export function enableFields() {
+    if (enabled)
+        return;
+    enabled = true;
+    for (const type of BUILTIN_FIELD_TYPES) {
+        // A type the app registered first (same id) wins over the built-in.
+        if (!getFieldType(type.id))
+            registerFieldType(type);
+    }
+    registerGridExtension({
+        column: (def, columns) => fillFieldColumn(def, columns),
+        cell: FieldCell,
+        hasCell: (def) => typeDrawsCell(def ?? {}),
+        // Last modified time / by: stamp the row when one of the fields they watch changes.
+        cellEdited: (ctrl, info) => {
+            stampModified(ctrl, info.row, info.columnId);
+            noteEdit(ctrl, info.row, info.columnId);
+        },
+        // The `rowAdder` prop's line; it draws nothing when the prop is off. Under
+        // the summary row when there is one, after the last record otherwise.
+        bodyEnd: RowAdder,
+        footEnd: FootRowAdder,
+        // The `rowColor` prop: a color per rendered row, its label, and where it shows.
+        rowMarkColor: (ctrl, row) => rowMarkColor(ctrl, row),
+        rowMarkLabel: (ctrl, row) => rowMarkLabel(ctrl, row),
+        // The type's icon before the header label, as the field editor shows it.
+        headerIcon: (def) => (def?.fieldType ? getFieldType(def.fieldType)?.icon : null),
+        // A field's description, on hover over an info mark after its name.
+        headerNote: (def) => (def?.fieldType && typeof def.description === 'string' && def.description ? { text: def.description, icon: MENU_ICON.info } : null),
+        // The column menu sorts "1 → 9" or "A → Z" as the field reads.
+        sortLabels: (def) => (def?.fieldType ? sortLabels(def) : null),
+        // The primary field stays pinned first.
+        lockColumn: (ctrl, columnId) => primaryIdOf(ctrl) === columnId,
+        // `expandRows`: the row number turns into a checkbox and an expand button.
+        rowHeader: (ctrl) => (ctrl?.props?.expandRows ? RowHeader : null),
+        // A group's header: the value as its cell draws it, the count, the group's summaries, "+".
+        groupRow: (ctrl) => (fieldColumns(ctrl).some((c) => c.fieldType) ? GroupHeader : null),
+        // The footer summary row: each field picks its own summary.
+        summaryCell: () => SummaryCell,
+        rootClass: (ctrl) => {
+            // Lets the view bar, given an api, find its grid.
+            rememberGrid(ctrl);
+            // The view bar's filter shows on its Filter button, not as the grid's chip.
+            const ownFilter = ctrl?.advancedFilter?.kind === 'fieldFilter' ? 'sv-fields-own-filter' : '';
+            return [rowColorRootClass(ctrl), tallRowClass(ctrl), ownFilter].filter(Boolean).join(' ') || null;
+        },
+        // The "+" column (`columnAdder`) and the host of the field editor.
+        headerEnd: FieldsHeaderEnd,
+        // `fieldMenu`: field actions in each column's menu.
+        columnMenuItems: (ctrl, columnId) => (ctrl?.props?.fieldMenu ? fieldMenuItems(ctrl, columnId) : []),
+    });
+    // The attachment field edits in a dialog; the editor needs the column's
+    // fieldProps (accept, maxFiles, upload) and the row, so map them through.
+    // The rating editor follows the field's maximum, icon and color; the link
+    // editor picks rows of the linked table. `typeToEdit` is which keys typed
+    // on a selected cell open the editor (`typed` tells it the value is that
+    // text): a digit sets a rating, a number starts the number box, any text
+    // searches a select's options.
+    const editorProps = (ctx) => ({ value: ctx.value, typed: ctx.typed, columnDef: ctx.columnDef, columnId: ctx.columnId, row: ctx.row, onCommit: ctx.onCommit, onCancel: ctx.onCancel });
+    registerCellEditor('fieldRating', { component: RatingEditor, props: editorProps, typeToEdit: (c) => /^[0-9]$/.test(c) });
+    registerCellEditor('fieldLink', { component: LinkPickerEditor, props: editorProps, typeToEdit: false });
+    registerCellEditor('fieldNumber', {
+        component: NumberEditor,
+        props: (ctx) => ({ ...editorProps(ctx), onCommitAndMove: ctx.onCommitAndMove, onCommitAndMoveDown: ctx.onCommitAndMoveDown }),
+        typeToEdit: (c) => /[0-9.,:+\-(]/.test(c),
+    });
+    registerCellEditor('fieldLongText', {
+        component: LongTextEditor,
+        props: (ctx) => ({ ...editorProps(ctx), onCommitAndMove: ctx.onCommitAndMove }),
+    });
+    registerCellEditor('fieldSelect', {
+        component: SelectEditor,
+        props: (ctx) => ({ ...editorProps(ctx), grid: ctx.grid, onChange: ctx.onChange, onCommitAndMove: ctx.onCommitAndMove }),
+    });
+    registerCellEditor('attachment', {
+        component: AttachmentEditor,
+        props: (ctx) => ({
+            value: ctx.value,
+            columnDef: ctx.columnDef,
+            columnId: ctx.columnId,
+            row: ctx.row,
+            onCommit: ctx.onCommit,
+            onCancel: ctx.onCancel,
+        }),
+        typeToEdit: false,
+    });
+    // The view bar's filter: conditions per field type, as an advanced filter kind.
+    registerFilterKind('fieldFilter', (expr, ctx) => compileFieldFilter(expr, ctx.getValue, linkNames));
+    // A person condition's "Me" is whoever is signed in when the filter runs.
+    resolveMeWith(() => getCurrentUser()?.id);
+    // The same filter as an alert rule's condition (`baseCondition`).
+    registerBaseCondition();
+    enableAdvancedFilter();
+    registerGridShortcuts(spaceOpensRecord, { id: 'svgrid-fields-space' });
+    // SvGrid Base is a Suite product: without a key, or with a Grid-edition key,
+    // the grid shows the watermark and a notice. It never blocks.
+    nudgeEnterpriseFor('base', 'SvGrid Base');
+}

package/dist/fields/linked-fields.d.ts

@@ -0,0 +1,8 @@
+import { type LinkedField, type LinkedTable } from './sources.svelte.js';
+export declare function linkedFields(table: LinkedTable, row?: Record<string, unknown>): LinkedField[];
+/** A field's value in a linked record: computed for a formula, lookup, rollup or count. */
+export declare function linkedValue(f: LinkedField, row: Record<string, unknown>): unknown;
+/** A record of the table by id. */
+export declare function linkedRow(table: LinkedTable, rowId: string): Record<string, unknown> | undefined;
+/** A value as the field shows it, as text. */
+export declare function linkedText(f: LinkedField, value: unknown, row: unknown): string;

package/dist/fields/linked-fields.js

@@ -0,0 +1,40 @@
+/**
+ * A linked table's fields as columns a record view can draw: each declared
+ * field filled in by its type, or every key of the record when the table
+ * declares none.
+ */
+import { fillFieldColumn } from './registry.svelte.js';
+import { idOf, rowsOf } from './sources.svelte.js';
+export function linkedFields(table, row) {
+    const declared = table.fields?.length
+        ? table.fields
+        : Object.keys(row ?? {})
+            .filter((k) => k !== 'id')
+            .map((k) => ({ field: k, header: k }));
+    const withPrimary = declared.some((f) => f.field === table.primaryField) ? declared : [{ field: table.primaryField, header: 'Name' }, ...declared];
+    // A rollup or count reads a link field of the same table: every field is its context.
+    const all = withPrimary.map((f) => ({ id: f.field, ...f }));
+    return withPrimary.map((f) => {
+        const typed = 'fieldType' in f && f.fieldType;
+        const def = typed ? fillFieldColumn({ field: f.field, header: f.header, fieldType: f.fieldType, fieldProps: f.fieldProps }, all) : { field: f.field, header: f.header };
+        return { id: f.field, header: f.header, def };
+    });
+}
+/** A field's value in a linked record: computed for a formula, lookup, rollup or count. */
+export function linkedValue(f, row) {
+    const fn = f.def.fieldFn;
+    return fn ? fn(row) : row[f.def.field];
+}
+/** A record of the table by id. */
+export function linkedRow(table, rowId) {
+    return rowsOf(table).find((r) => idOf(table, r) === rowId);
+}
+/** A value as the field shows it, as text. */
+export function linkedText(f, value, row) {
+    const fmt = f.def.formatter;
+    if (fmt)
+        return String(fmt({ value, row, column: { id: f.id, columnDef: f.def } }) ?? '');
+    if (Array.isArray(value))
+        return value.join(', ');
+    return value == null ? '' : String(value);
+}

package/dist/fields/links.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hrefs for URL, email and phone cells. Cell values are data, so an href is
+ * built only for the schemes these fields mean: a value like
+ * `javascript:alert(1)` in a URL column must never become a link.
+ */
+export type LinkKind = 'url' | 'email' | 'phone';
+/** The href for a cell value, or null when the value is not a link of that kind. */
+export declare function linkHref(kind: LinkKind, value: unknown): string | null;
+/** What the cell shows: the value without the scheme noise. */
+export declare function linkText(kind: LinkKind, value: unknown): string;

package/dist/fields/links.js

@@ -0,0 +1,46 @@
+/**
+ * Hrefs for URL, email and phone cells. Cell values are data, so an href is
+ * built only for the schemes these fields mean: a value like
+ * `javascript:alert(1)` in a URL column must never become a link.
+ */
+const EMAIL = /^[^\s@<>()[\]\\,;:"]+@[^\s@<>()[\]\\,;:"]+\.[^\s@<>()[\]\\,;:"]+$/;
+/** The href for a cell value, or null when the value is not a link of that kind. */
+export function linkHref(kind, value) {
+    if (value == null)
+        return null;
+    const text = String(value).trim();
+    if (!text)
+        return null;
+    if (kind === 'email') {
+        const address = text.replace(/^mailto:/i, '');
+        return EMAIL.test(address) ? `mailto:${address}` : null;
+    }
+    if (kind === 'phone') {
+        // Digits, an optional leading +, and the separators people type.
+        const digits = text.replace(/^tel:/i, '').replace(/[\s().-]/g, '');
+        return /^\+?\d{3,20}$/.test(digits) ? `tel:${digits}` : null;
+    }
+    // url: only http(s). A bare host ("svgrid.com/docs") gets https://.
+    const withScheme = /^[a-z][a-z0-9+.-]*:/i.test(text) ? text : `https://${text}`;
+    let parsed;
+    try {
+        parsed = new URL(withScheme);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return null;
+    if (!parsed.hostname.includes('.') && parsed.hostname !== 'localhost')
+        return null;
+    return parsed.href;
+}
+/** What the cell shows: the value without the scheme noise. */
+export function linkText(kind, value) {
+    const text = value == null ? '' : String(value).trim();
+    if (kind === 'url')
+        return text.replace(/^https?:\/\//i, '').replace(/\/$/, '');
+    if (kind === 'email')
+        return text.replace(/^mailto:/i, '');
+    return text.replace(/^tel:/i, '');
+}

package/dist/fields/name-list.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A list of names as one line of text, the way a copy writes link and user
+ * cells: "Northwind, Acme". A name with a comma or a double quote is quoted
+ * CSV style ("Acme, Inc.", inner quotes doubled), so a paste splits it back
+ * into the same names.
+ */
+/** One name, quoted when it holds a comma or a double quote. */
+export declare const quoteName: (name: string) => string;
+/** Names joined with ", ", each quoted when it has to be. */
+export declare const joinNames: (names: ReadonlyArray<string>) => string;
+/**
+ * The names in a comma-separated line, trimmed, empty parts left out. A part
+ * that starts with a double quote runs to the closing quote, commas included,
+ * and `""` inside it is one quote. An unclosed quote runs to the end.
+ */
+export declare function splitNames(text: string): string[];

package/dist/fields/name-list.js

@@ -0,0 +1,49 @@
+/**
+ * A list of names as one line of text, the way a copy writes link and user
+ * cells: "Northwind, Acme". A name with a comma or a double quote is quoted
+ * CSV style ("Acme, Inc.", inner quotes doubled), so a paste splits it back
+ * into the same names.
+ */
+/** One name, quoted when it holds a comma or a double quote. */
+export const quoteName = (name) => (/[",]/.test(name) ? `"${name.replace(/"/g, '""')}"` : name);
+/** Names joined with ", ", each quoted when it has to be. */
+export const joinNames = (names) => names.map(quoteName).join(', ');
+/**
+ * The names in a comma-separated line, trimmed, empty parts left out. A part
+ * that starts with a double quote runs to the closing quote, commas included,
+ * and `""` inside it is one quote. An unclosed quote runs to the end.
+ */
+export function splitNames(text) {
+    const out = [];
+    const n = text.length;
+    let i = 0;
+    while (i <= n) {
+        while (i < n && /\s/.test(text[i]))
+            i += 1;
+        let part = '';
+        if (text[i] === '"') {
+            i += 1;
+            while (i < n) {
+                if (text[i] === '"') {
+                    if (text[i + 1] === '"') {
+                        part += '"';
+                        i += 2;
+                        continue;
+                    }
+                    i += 1;
+                    break;
+                }
+                part += text[i];
+                i += 1;
+            }
+        }
+        // Up to the next comma: a plain part, or what follows a closing quote.
+        const comma = text.indexOf(',', i);
+        const end = comma < 0 ? n : comma;
+        part = (part + text.slice(i, end)).trim();
+        if (part)
+            out.push(part);
+        i = end + 1;
+    }
+    return out;
+}