@svgrid/enterprise 3.1.7 → 3.1.9

package/dist/fields/row-colors.js

@@ -0,0 +1,90 @@
+/**
+ * The `rowColor` prop: a color per row from a select field's option colors,
+ * or from the first matching rule. The grid asks for rendered rows only
+ * (registerGridExtension's rowMarkColor / rowMarkLabel), so this never walks
+ * the data. Where the color is painted is CSS keyed on the root class.
+ */
+import { chosenRowColor } from './row-color-choice.svelte.js';
+import { recordHeightOf } from './row-height.js';
+// value -> color for each field, per column set (a new columns array rebuilds it).
+const optionColors = new WeakMap();
+function colorsFor(ctrl, field) {
+    const cols = ctrl.allColumns ?? [];
+    let byField = optionColors.get(cols);
+    if (!byField) {
+        byField = new Map();
+        optionColors.set(cols, byField);
+    }
+    let map = byField.get(field);
+    if (!map) {
+        map = new Map();
+        const def = cols.find((c) => c.columnDef.field === field)?.columnDef;
+        const fromProps = def?.fieldProps?.options;
+        const options = Array.isArray(fromProps) ? fromProps : Array.isArray(def?.editorOptions) ? def.editorOptions : [];
+        for (const o of options) {
+            if (o && typeof o === 'object' && o.color)
+                map.set(String(o.value), o.color);
+        }
+        byField.set(field, map);
+    }
+    return map;
+}
+function fieldValue(row, field) {
+    const v = row?.[field];
+    // A multiple select colors the row by its first value.
+    return Array.isArray(v) ? v[0] : v;
+}
+function matchRule(config, row) {
+    return config.rules?.find((r) => {
+        try {
+            return r.when(row);
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** The colors in force: one picked from the column menu, else the `rowColor` prop. */
+export function rowColorOf(ctrl) {
+    const chosen = chosenRowColor(ctrl);
+    return chosen !== undefined ? chosen : ctrl.props.rowColor;
+}
+export function rowMarkColor(ctrl, row) {
+    const config = rowColorOf(ctrl);
+    if (!config || row == null)
+        return null;
+    if (config.field) {
+        const v = fieldValue(row, config.field);
+        return v == null ? null : (colorsFor(ctrl, config.field).get(String(v)) ?? null);
+    }
+    return matchRule(config, row)?.color ?? null;
+}
+export function rowMarkLabel(ctrl, row) {
+    const config = rowColorOf(ctrl);
+    if (!config || row == null)
+        return null;
+    if (config.field) {
+        const v = fieldValue(row, config.field);
+        return v == null || v === '' ? null : String(v);
+    }
+    return matchRule(config, row)?.label ?? null;
+}
+export function rowColorRootClass(ctrl) {
+    const config = rowColorOf(ctrl);
+    if (!config)
+        return null;
+    const target = config.target === 'bar' || config.target === 'row' ? config.target : 'header';
+    return `sv-fields-rowcolor sv-fields-rowcolor-${target}`;
+}
+/**
+ * Taller rows show more, as a table database does: from a 48px row height
+ * the root class names how many lines of text fit (2 to 6), and the fields
+ * styles wrap text and select pills to that and grow attachment thumbnails.
+ */
+export function tallRowClass(ctrl) {
+    const h = recordHeightOf(ctrl.props.rowHeight) || 0;
+    if (h < 48)
+        return null;
+    const lines = Math.max(2, Math.min(6, Math.floor((h - 12) / 20)));
+    return `sv-fields-tall sv-fields-lines-${lines}`;
+}

package/dist/fields/row-height.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Group rows taller than records. A grouped view's header holds the field's
+ * name over its value (a select pill, a linked record's chip), which a 40px
+ * record row has no room for. The grid takes `rowHeight` as a function of
+ * the row index, so while a view is grouped the base sets one that draws
+ * group rows at GROUP_ROW_HEIGHT and records at the height picked for them.
+ * Everything that reads the row height (the menu, a view saved, tall-row
+ * wrapping) reads the record height through `recordHeightOf`.
+ */
+export declare const GROUP_ROW_HEIGHT = 52;
+type RowLike = {
+    depth?: number;
+    getCanExpand?: () => boolean;
+    __treeRow?: boolean;
+};
+/** A record row's height, whether the option is a number or the grouped function. */
+export declare function recordHeightOf(value: unknown): number | undefined;
+/**
+ * Keep the row height in step with grouping: the function while grouped, the
+ * plain record height otherwise. Call it when grouping or the height changes.
+ */
+export declare function syncGroupRowHeight(ctrl: {
+    allRows?: RowLike[];
+} | undefined, api: {
+    getOption: (k: string) => unknown;
+    setOption: (k: string, v: unknown) => void;
+} | undefined, grouped: boolean): void;
+export {};

package/dist/fields/row-height.js

@@ -0,0 +1,50 @@
+/**
+ * Group rows taller than records. A grouped view's header holds the field's
+ * name over its value (a select pill, a linked record's chip), which a 40px
+ * record row has no room for. The grid takes `rowHeight` as a function of
+ * the row index, so while a view is grouped the base sets one that draws
+ * group rows at GROUP_ROW_HEIGHT and records at the height picked for them.
+ * Everything that reads the row height (the menu, a view saved, tall-row
+ * wrapping) reads the record height through `recordHeightOf`.
+ */
+export const GROUP_ROW_HEIGHT = 52;
+/** The grid's own record height when none is set (`rowHeight` unset). */
+const GRID_DEFAULT = 30;
+const MARK = Symbol('groupedRowHeight');
+const isGrouped = (v) => typeof v === 'function' && v[MARK] === true;
+/** A record row's height, whether the option is a number or the grouped function. */
+export function recordHeightOf(value) {
+    if (typeof value === 'number')
+        return value;
+    return isGrouped(value) ? value.recordHeight : undefined;
+}
+/** A group row of client grouping (not a tree row, which is a record). */
+function isGroupRow(row) {
+    return !!row && !row.__treeRow && typeof row.getCanExpand === 'function' && row.getCanExpand();
+}
+/**
+ * Keep the row height in step with grouping: the function while grouped, the
+ * plain record height otherwise. Call it when grouping or the height changes.
+ */
+export function syncGroupRowHeight(ctrl, api, grouped) {
+    if (!ctrl || !api)
+        return;
+    const now = api.getOption('rowHeight');
+    // Another function of the app's own: leave it be.
+    if (typeof now === 'function' && !isGrouped(now))
+        return;
+    const h = recordHeightOf(now);
+    if (!grouped) {
+        // Back to what it was; unset stays unset.
+        if (isGrouped(now))
+            api.setOption('rowHeight', h);
+        return;
+    }
+    if (isGrouped(now))
+        return;
+    const record = h ?? GRID_DEFAULT;
+    const fn = ((i) => (isGroupRow(ctrl.allRows?.[i]) ? Math.max(record, GROUP_ROW_HEIGHT) : record));
+    fn.recordHeight = h;
+    fn[MARK] = true;
+    api.setOption('rowHeight', fn);
+}

package/dist/fields/sources.svelte.d.ts

@@ -0,0 +1,80 @@
+/**
+ * What fields need from the app that no column holds: the people a user
+ * field can name, who is signed in (created by / last modified by), and the
+ * rows of other tables a link field can point at.
+ */
+export type FieldUser = {
+    id: string;
+    name: string;
+    email?: string;
+    avatarUrl?: string;
+};
+/** The people user fields can choose from. */
+export declare function setFieldUsers(list: ReadonlyArray<FieldUser>): void;
+export declare const getFieldUsers: () => ReadonlyArray<FieldUser>;
+export declare const findFieldUser: (id: unknown) => FieldUser | undefined;
+/** Who is signed in: what "created by" and "last modified by" write. */
+export declare function setCurrentUser(user: FieldUser | null): void;
+export declare const getCurrentUser: () => FieldUser | null;
+/** Another table a link field can point at. */
+export type LinkedTable = {
+    id: string;
+    name: string;
+    /** Its rows. A function is read each time, so the table can change. */
+    rows: ReadonlyArray<Record<string, unknown>> | (() => ReadonlyArray<Record<string, unknown>>);
+    /** A row's id. Default: its `id` property. */
+    getRowId?: (row: Record<string, unknown>) => string;
+    /** The field shown for a linked row (its name). */
+    primaryField: string;
+    /**
+     * The fields a lookup or rollup can read: `{ field, header }`, and the
+     * field's type when it has one (`fieldType`, `fieldProps`), so a lookup
+     * shows a date as a date, an amount with its symbol.
+     */
+    fields?: ReadonlyArray<{
+        field: string;
+        header: string;
+        fieldType?: string;
+        fieldProps?: Record<string, unknown>;
+    }>;
+    /**
+     * Add a record named `name` to this table (the link picker's "+ Create");
+     * return the new row, with its id. Without it the picker only links
+     * existing records.
+     */
+    create?: (name: string) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    /**
+     * Show a record of this table where it lives (another tab of a base): the
+     * linked record view then offers "Open in {name}".
+     */
+    open?: (rowId: string) => void;
+};
+/** A linked table's fields as filled columns (formatter, cell), for showing one of its records. */
+export type LinkedField = {
+    id: string;
+    header: string;
+    def: Record<string, any>;
+};
+/**
+ * Add or replace a table that link fields can point at. Registering again
+ * with the same id and owner replaces that registration. With the same id
+ * and another owner (two bases, or a base and the app), the newest one is
+ * shown until it is unregistered. Returns a function that unregisters this
+ * registration only.
+ */
+export declare function registerLinkedTable(table: LinkedTable, owner?: object): () => void;
+/** Forget a table: the app's registration of `id`, or `owner`'s. */
+export declare function unregisterLinkedTable(id: string, owner?: object): void;
+export declare const getLinkedTable: (id: unknown) => LinkedTable | undefined;
+export declare const listLinkedTables: () => LinkedTable[];
+export declare const rowsOf: (t: LinkedTable) => ReadonlyArray<Record<string, unknown>>;
+export declare const idOf: (t: LinkedTable, row: Record<string, unknown>) => string;
+/** The linked rows a link cell's value names, in its order; unknown ids are skipped. */
+export declare function linkedRows(table: LinkedTable | undefined, value: unknown): Record<string, unknown>[];
+/**
+ * The id of the record of `table` a pasted or typed part names: its id, else
+ * its name (the primary field), both ignoring case. Undefined when no record has it.
+ */
+export declare function resolveLinkId(table: LinkedTable, part: unknown): string | undefined;
+/** The records `parts` name (see resolveLinkId), in order, each once; a part no record has is dropped. */
+export declare function resolveLinkIds(table: LinkedTable, parts: ReadonlyArray<unknown>): string[];

package/dist/fields/sources.svelte.js

@@ -0,0 +1,131 @@
+/**
+ * What fields need from the app that no column holds: the people a user
+ * field can name, who is signed in (created by / last modified by), and the
+ * rows of other tables a link field can point at.
+ */
+let users = $state.raw([]);
+let currentUser = $state.raw(null);
+/** The people user fields can choose from. */
+export function setFieldUsers(list) {
+    users = [...list];
+}
+export const getFieldUsers = () => users;
+export const findFieldUser = (id) => id == null ? undefined : users.find((u) => u.id === String(id)) ?? (currentUser?.id === String(id) ? currentUser : undefined);
+/** Who is signed in: what "created by" and "last modified by" write. */
+export function setCurrentUser(user) {
+    currentUser = user;
+}
+export const getCurrentUser = () => currentUser;
+let tables = $state.raw({});
+const entries = new Map();
+function publish(id) {
+    const top = entries.get(id)?.at(-1)?.table;
+    if (top)
+        tables = { ...tables, [id]: top };
+    else if (id in tables) {
+        const { [id]: _gone, ...rest } = tables;
+        tables = rest;
+    }
+}
+/**
+ * Add or replace a table that link fields can point at. Registering again
+ * with the same id and owner replaces that registration. With the same id
+ * and another owner (two bases, or a base and the app), the newest one is
+ * shown until it is unregistered. Returns a function that unregisters this
+ * registration only.
+ */
+export function registerLinkedTable(table, owner) {
+    const list = (entries.get(table.id) ?? []).filter((e) => e.owner !== owner);
+    const entry = { table, owner };
+    list.push(entry);
+    entries.set(table.id, list);
+    publish(table.id);
+    return () => {
+        const now = entries.get(table.id);
+        if (!now?.includes(entry))
+            return;
+        entries.set(table.id, now.filter((e) => e !== entry));
+        publish(table.id);
+    };
+}
+/** Forget a table: the app's registration of `id`, or `owner`'s. */
+export function unregisterLinkedTable(id, owner) {
+    const list = entries.get(id);
+    if (!list?.some((e) => e.owner === owner))
+        return;
+    entries.set(id, list.filter((e) => e.owner !== owner));
+    publish(id);
+}
+export const getLinkedTable = (id) => (typeof id === 'string' ? tables[id] : undefined);
+export const listLinkedTables = () => Object.values(tables);
+export const rowsOf = (t) => (typeof t.rows === 'function' ? t.rows() : t.rows);
+export const idOf = (t, row) => (t.getRowId ? t.getRowId(row) : String(row.id ?? ''));
+/** The linked rows a link cell's value names, in its order; unknown ids are skipped. */
+export function linkedRows(table, value) {
+    if (!table)
+        return [];
+    const ids = Array.isArray(value) ? value.map(String) : value == null || value === '' ? [] : [String(value)];
+    if (!ids.length)
+        return [];
+    const byId = indexOf(table);
+    return ids.map((id) => byId.get(id)).filter((r) => !!r);
+}
+/**
+ * The id of the record of `table` a pasted or typed part names: its id, else
+ * its name (the primary field), both ignoring case. Undefined when no record has it.
+ */
+export function resolveLinkId(table, part) {
+    const q = String(part ?? '').trim().toLowerCase();
+    if (!q)
+        return undefined;
+    const { byId, byName } = lookupOf(table);
+    return byId.get(q) ?? byName.get(q);
+}
+/** The records `parts` name (see resolveLinkId), in order, each once; a part no record has is dropped. */
+export function resolveLinkIds(table, parts) {
+    const ids = [];
+    for (const p of parts) {
+        const id = resolveLinkId(table, p);
+        if (id != null && !ids.includes(id))
+            ids.push(id);
+    }
+    return ids;
+}
+let lookups = new WeakMap();
+let dropQueued = false;
+function lookupOf(table) {
+    const rows = rowsOf(table);
+    let l = lookups.get(rows);
+    if (!l) {
+        l = { byId: new Map(), byName: new Map() };
+        for (const r of rows) {
+            const id = idOf(table, r);
+            const lowId = id.toLowerCase();
+            const name = String(r[table.primaryField] ?? '').trim().toLowerCase();
+            if (!l.byId.has(lowId))
+                l.byId.set(lowId, id);
+            if (name && !l.byName.has(name))
+                l.byName.set(name, id);
+        }
+        lookups.set(rows, l);
+        if (!dropQueued) {
+            dropQueued = true;
+            queueMicrotask(() => {
+                lookups = new WeakMap();
+                dropQueued = false;
+            });
+        }
+    }
+    return l;
+}
+// id -> row per rows array: a cell asks for its linked rows on every draw.
+const indexes = new WeakMap();
+function indexOf(table) {
+    const rows = rowsOf(table);
+    let map = indexes.get(rows);
+    if (!map) {
+        map = new Map(rows.map((r) => [idOf(table, r), r]));
+        indexes.set(rows, map);
+    }
+    return map;
+}

package/dist/fields/summaries.d.ts

@@ -0,0 +1,18 @@
+export type SummaryKind = 'none' | 'empty' | 'filled' | 'unique' | 'percentEmpty' | 'percentFilled' | 'sum' | 'avg' | 'median' | 'min' | 'max' | 'range' | 'checked' | 'unchecked' | 'percentChecked' | 'earliest' | 'latest' | 'dateRange';
+type Def = Record<string, any>;
+type Choice = {
+    value: SummaryKind;
+    label: string;
+};
+/** The footer picker's choices for a field, `none` first. */
+export declare function summaryChoices(def: Def): Choice[];
+export declare const summaryLabel: (kind: SummaryKind) => string;
+/**
+ * The footer function for a field (the grid's column `summary`): it gets the
+ * rows and returns the text to show, the value formatted as the field
+ * formats it ("$4,320", "75%", "October 31, 2026").
+ */
+export declare function makeSummary(kind: SummaryKind, def: Def): ((values: number[], rows: unknown[]) => string) | false;
+/** The filled column with its footer summary: the app's own `summary` wins. */
+export declare function withSummary<T extends Def>(filled: T, props: Record<string, unknown>): T;
+export {};

package/dist/fields/summaries.js

@@ -0,0 +1,138 @@
+/**
+ * The summary a field shows in the grid's footer row (the `summary` prop):
+ * what the footer's picker offers for each kind of field, and the function
+ * that computes it. A field keeps its choice in `fieldProps.summary`; without
+ * one it shows nothing until someone picks.
+ */
+import { toDate } from './format.js';
+const COMMON = [
+    { value: 'empty', label: 'Empty' },
+    { value: 'filled', label: 'Filled' },
+    { value: 'unique', label: 'Unique' },
+    { value: 'percentEmpty', label: 'Percent empty' },
+    { value: 'percentFilled', label: 'Percent filled' },
+];
+const NUMERIC = [
+    { value: 'sum', label: 'Sum' },
+    { value: 'avg', label: 'Average' },
+    { value: 'median', label: 'Median' },
+    { value: 'min', label: 'Min' },
+    { value: 'max', label: 'Max' },
+    { value: 'range', label: 'Range' },
+];
+const CHECKBOX = [
+    { value: 'checked', label: 'Checked' },
+    { value: 'unchecked', label: 'Unchecked' },
+    { value: 'percentChecked', label: 'Percent checked' },
+];
+const DATES = [
+    { value: 'earliest', label: 'Earliest date' },
+    { value: 'latest', label: 'Latest date' },
+    { value: 'dateRange', label: 'Date range (days)' },
+];
+/** What a field's data is, for the summaries it can have. */
+function shapeOf(def) {
+    // A registered type that stores true / false says so with cellDataType.
+    if (def.fieldType === 'checkbox' || def.cellDataType === 'boolean')
+        return 'checkbox';
+    // A formula is what it computes.
+    const result = def.fieldType === 'formula' ? def.fieldProps?.result : undefined;
+    if (result === 'number' || result === 'currency' || result === 'percent')
+        return 'number';
+    if (result === 'date')
+        return 'date';
+    if (def.cellDataType === 'number' || def.fieldType === 'currency' || def.fieldType === 'percent')
+        return 'number';
+    if (def.cellDataType === 'date' || def.cellDataType === 'dateString' || ['createdTime', 'lastModifiedTime'].includes(def.fieldType))
+        return 'date';
+    return 'other';
+}
+/** The footer picker's choices for a field, `none` first. */
+export function summaryChoices(def) {
+    const shape = shapeOf(def);
+    return [
+        { value: 'none', label: 'None' },
+        ...(shape === 'number' ? NUMERIC : shape === 'checkbox' ? CHECKBOX : shape === 'date' ? DATES : []),
+        ...COMMON,
+    ];
+}
+export const summaryLabel = (kind) => [...NUMERIC, ...CHECKBOX, ...DATES, ...COMMON].find((c) => c.value === kind)?.label ?? '';
+const isEmpty = (v) => v == null || v === '' || (Array.isArray(v) && v.length === 0);
+const pct = (n, of) => (of ? `${Math.round((n / of) * 100)}%` : '0%');
+/**
+ * The footer function for a field (the grid's column `summary`): it gets the
+ * rows and returns the text to show, the value formatted as the field
+ * formats it ("$4,320", "75%", "October 31, 2026").
+ */
+export function makeSummary(kind, def) {
+    if (kind === 'none')
+        return false;
+    const read = (row) => typeof def.fieldFn === 'function' ? def.fieldFn(row) : def.field != null ? row?.[def.field] : undefined;
+    const format = (v) => {
+        const f = def.formatter;
+        return f ? String(f({ value: v }) ?? '') : String(v);
+    };
+    return (_values, rows) => {
+        const all = rows.map(read);
+        const total = all.length;
+        switch (kind) {
+            case 'empty':
+                return String(all.filter(isEmpty).length);
+            case 'filled':
+                return String(all.filter((v) => !isEmpty(v)).length);
+            case 'percentEmpty':
+                return pct(all.filter(isEmpty).length, total);
+            case 'percentFilled':
+                return pct(all.filter((v) => !isEmpty(v)).length, total);
+            case 'unique':
+                return String(new Set(all.filter((v) => !isEmpty(v)).map((v) => JSON.stringify(v))).size);
+            case 'checked':
+                return String(all.filter((v) => v === true).length);
+            case 'unchecked':
+                return String(all.filter((v) => v !== true).length);
+            case 'percentChecked':
+                return pct(all.filter((v) => v === true).length, total);
+            case 'earliest':
+            case 'latest':
+            case 'dateRange': {
+                const times = all.map((v) => toDate(v)?.getTime()).filter((t) => t != null && Number.isFinite(t));
+                if (!times.length)
+                    return '';
+                const lo = Math.min(...times);
+                const hi = Math.max(...times);
+                if (kind === 'dateRange')
+                    return `${Math.round((hi - lo) / 86400000)} days`;
+                // Back to the field's own value shape: a date-only field holds 'YYYY-MM-DD'.
+                const pick = all[all.findIndex((v) => toDate(v)?.getTime() === (kind === 'earliest' ? lo : hi))];
+                return format(pick);
+            }
+            default: {
+                const nums = all.map((v) => (typeof v === 'number' ? v : v === '' || v == null ? NaN : Number(v))).filter((n) => Number.isFinite(n));
+                if (!nums.length)
+                    return '';
+                const sum = nums.reduce((a, b) => a + b, 0);
+                if (kind === 'sum')
+                    return format(sum);
+                if (kind === 'avg')
+                    return format(sum / nums.length);
+                if (kind === 'min')
+                    return format(Math.min(...nums));
+                if (kind === 'max')
+                    return format(Math.max(...nums));
+                if (kind === 'range')
+                    return format(Math.max(...nums) - Math.min(...nums));
+                const sorted = [...nums].sort((a, b) => a - b);
+                const mid = sorted.length >> 1;
+                return format(sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2);
+            }
+        }
+    };
+}
+/** The filled column with its footer summary: the app's own `summary` wins. */
+export function withSummary(filled, props) {
+    if (filled.summary !== undefined)
+        return filled;
+    const kind = props.summary ?? 'none';
+    const known = summaryChoices(filled).some((c) => c.value === kind);
+    return { ...filled, summary: known ? makeSummary(kind, filled) : false };
+}

package/dist/fields/view-model.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Saved views: a name, a type (grid, Kanban, calendar, Gantt, gallery,
+ * form) and what the grid looked like the last time the view was left -
+ * sorts, groups, the filter, hidden fields and their order, widths, pinned
+ * columns, row height and row colors. Switching views saves the one being
+ * left and applies the other through the grid's own state and options.
+ */
+import type { RowColorConfig } from '@svgrid/grid';
+import { type FieldCondition, type LinkNames } from './filter-model.js';
+import { type FieldColumn } from './grid-access.js';
+import type { ChartSetting } from './chart-view.js';
+export type FieldViewType = 'grid' | 'kanban' | 'calendar' | 'gantt' | 'gallery' | 'chart' | 'form';
+/** How rows are colored: not, by a single select's option colors, or by conditions in order. */
+export type ColorSetting = {
+    mode: 'none';
+} | {
+    mode: 'field';
+    field: string;
+} | {
+    mode: 'conditions';
+    rules: Array<{
+        color: string;
+        condition: FieldCondition;
+    }>;
+};
+export type FieldView = {
+    id: string;
+    name: string;
+    type: FieldViewType;
+    /** The grid's state when the view was last left (`api.getState()`). */
+    state?: Record<string, unknown>;
+    rowHeight?: number;
+    color?: ColorSetting;
+    /** Kanban: the single select or user field the cards stack by. */
+    stackBy?: string;
+    /** Calendar and Gantt: the date field a record starts on, and the one it ends on. */
+    dateField?: string;
+    endField?: string;
+    /** Gantt: a percent field drawn as each bar's fill, and dragged with its grip. */
+    progressField?: string;
+    /** Gantt: a link field to the same table naming the records each one depends on. */
+    dependencyField?: string;
+    /** Gantt: the zoom it was left at. */
+    zoom?: string;
+    /** Gallery: the attachment field whose first image is the card's cover. */
+    coverField?: string;
+    /** Chart: its kind, the field it groups by and what it counts or adds up. */
+    chart?: ChartSetting;
+    /** Form: the fields it asks for, in order (default: every editable field). */
+    formFields?: string[];
+    /** Form: its title and the line under it. */
+    formTitle?: string;
+    formDescription?: string;
+    /** Form: the fields that must be filled in before it sends. */
+    formRequired?: string[];
+    /** Form: the submit button's text (default 'Submit'). */
+    formSubmitLabel?: string;
+};
+export declare const VIEW_TYPES: ReadonlyArray<{
+    type: FieldViewType;
+    label: string;
+    icon: string;
+}>;
+export declare const viewTypeInfo: (t: FieldViewType) => {
+    type: FieldViewType;
+    label: string;
+    icon: string;
+};
+export declare const newViewId: () => string;
+/** Sort direction labels that fit the field ("1 → 9" for a number, "A → Z" for text). */
+export declare function sortLabels(def: Record<string, any> | undefined): [string, string];
+/** The rows-colored setting as the grid now has it. */
+export declare function colorSettingOf(ctrl: any, saved?: ColorSetting): ColorSetting;
+/**
+ * The grid's `rowColor` for a setting, painted where the `rowColor` prop says
+ * (`target`). Conditions are tested as the filter tests them: on the value the
+ * cell shows (computed for a formula, lookup, rollup or count), and one still
+ * missing its value is left out.
+ */
+export declare function rowColorFor(ctrl: any, setting: ColorSetting, linkNames?: LinkNames): RowColorConfig | null;
+export declare function applyColor(ctrl: any, setting: ColorSetting, linkNames?: LinkNames): void;
+/** Lanes for a Kanban stacked by a field: an "Uncategorized" lane, then one per option or person. */
+export declare function lanesFor(column: FieldColumn): Array<{
+    id: string;
+    title: string;
+    color?: string;
+    hideWhenEmpty?: boolean;
+}>;
+/** Fields a Kanban can stack by. */
+export declare const stackableColumns: (ctrl: any) => FieldColumn[];
+/** Fields a calendar or Gantt can place records by. */
+export declare const dateColumns: (ctrl: any) => FieldColumn[];
+/** Fields a Gantt can draw as progress: a number shown as a percent. */
+export declare const progressColumns: (ctrl: any) => FieldColumn[];
+/** Link fields to the same table: what a record depends on, for a Gantt's arrows. */
+export declare const dependencyColumns: (ctrl: any) => FieldColumn[];
+/**
+ * Re-apply a calendar or Gantt view after its settings changed (its fields,
+ * progress, links or colors), keeping the grid's state.
+ */
+export declare function applyGanttSettings(ctrl: any, api: any, view: FieldView, primaryField?: string): void;
+/** Fields a gallery can take a cover from. */
+export declare const coverColumns: (ctrl: any) => FieldColumn[];
+export declare function boardConfig(ctrl: any, api: any, view: FieldView): Record<string, unknown> | undefined;
+/**
+ * The grid's `gallery` for a gallery view: the cover field, the primary field
+ * as the title, then the fields the grid shows, in its order. A card opens
+ * its record. Built again when fields are hidden or moved.
+ */
+export declare function galleryConfig(ctrl: any, api: any, view: FieldView): Record<string, unknown>;
+/**
+ * The grid as a field cell on a card sees it: every method and prop of the
+ * grid, with the card's width as the column's. A custom field type's cell
+ * can open its record or read the grid's props from a card as from a row,
+ * and a button runs its automation. A card is read, not edited (the record
+ * it opens is), so the grid says editing is off: no stars to click, no drop.
+ */
+export declare function cardGrid(ctrl: any): (width: number) => unknown;
+/** Remove a record a view handed over (a copy, perhaps), and report it as the grid's delete does. */
+export declare function deleteRecord(ctrl: any, api: any, row: unknown): void;
+/** A new view: no filter, sorts, groups or hidden fields. */
+export declare const PLAIN_STATE: Record<string, unknown>;
+/** The view as the grid now shows it, to keep when the view is left. */
+export declare function captureView(ctrl: any, api: any, view: FieldView): FieldView;
+/** Show a view: its grid state, row height, colors, and the grid's mode for its type. */
+export declare function applyView(ctrl: any, api: any, view: FieldView, opts?: {
+    primaryField?: string;
+    linkNames?: LinkNames;
+}): void;