@svgrid/enterprise 3.1.8 → 3.1.9

package/dist/fields/button.d.ts

@@ -0,0 +1,2 @@
+/** The URL a button field opens: `{Field name}` tokens filled from the row, http(s) only. */
+export declare function buttonUrl(template: string, row: Record<string, unknown> | null | undefined, names?: Record<string, string>): string | null;

package/dist/fields/button.js

@@ -0,0 +1,17 @@
+/** The URL a button field opens: `{Field name}` tokens filled from the row, http(s) only. */
+export function buttonUrl(template, row, names) {
+    if (!template.trim() || !row)
+        return null;
+    const filled = template.replace(/\{([^}]+)\}/g, (_m, name) => {
+        const key = names?.[name.trim().toLowerCase()] ?? name.trim();
+        const v = row[key];
+        return encodeURIComponent(v == null ? '' : Array.isArray(v) ? v.join(',') : String(v));
+    });
+    try {
+        const url = new URL(filled);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url.href : null;
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,35 @@
+/**
+ * The chart view: the records the view shows, grouped by one field and
+ * counted, summed or averaged, as a bar, line, pie or donut chart. A select
+ * keeps its options' order and colors, a person and a linked record show by
+ * name, a date groups by month.
+ */
+import type { ChartSpec } from '@svgrid/grid';
+import { type FieldColumn } from './grid-access.js';
+type Row = Record<string, unknown>;
+export type ChartKind = 'bar' | 'barH' | 'line' | 'pie' | 'donut';
+/** What a chart view draws: its kind, the field on the axis, and the value (a count without `y`). */
+export type ChartSetting = {
+    kind: ChartKind;
+    /** The field the records are grouped by. */
+    x: string;
+    /** A number field to add up; without it, each group counts its records. */
+    y?: string;
+    /** How `y` is combined: its sum (default) or its average. */
+    aggregation?: 'sum' | 'avg';
+};
+export declare const CHART_KINDS: ReadonlyArray<{
+    kind: ChartKind;
+    label: string;
+}>;
+/** Fields a chart can group by. */
+export declare const chartXColumns: (ctrl: any) => FieldColumn[];
+/** Fields a chart can add up. */
+export declare const chartYColumns: (ctrl: any) => FieldColumn[];
+/** A first setting for a new chart view: the first select (or any field it can group by), counted. */
+export declare function defaultChart(ctrl: any): ChartSetting | null;
+/** The chart for `rows` (the records the view shows), or null when its fields are gone. */
+export declare function chartSpec(ctrl: any, setting: ChartSetting, rows: ReadonlyArray<Row>): ChartSpec | null;
+/** How a value shows on the axis and in tooltips: as the summed field shows it ($48,000), a count as a whole number. */
+export declare function chartFormatter(ctrl: any, setting: ChartSetting): ((value: number) => string) | undefined;
+export {};

package/dist/fields/chart-view.js

@@ -0,0 +1,154 @@
+import { fieldColumns } from './grid-access.js';
+import { fieldPropsOf, originalColumn } from './registry.svelte.js';
+import { findFieldUser, getLinkedTable, linkedRows } from './sources.svelte.js';
+export const CHART_KINDS = [
+    { kind: 'bar', label: 'Bar' },
+    { kind: 'barH', label: 'Horizontal bar' },
+    { kind: 'line', label: 'Line' },
+    { kind: 'pie', label: 'Pie' },
+    { kind: 'donut', label: 'Donut' },
+];
+// A formula and a lookup group by the value they compute (Status: Low, OK, Out).
+const X_TYPES = new Set(['singleSelect', 'multiSelect', 'user', 'date', 'checkbox', 'link', 'text', 'rating', 'createdTime', 'createdBy', 'formula', 'lookup']);
+const NUMBER_TYPES = new Set(['number', 'currency', 'percent', 'rating', 'duration', 'count', 'rollup']);
+const NUMERIC_RESULTS = new Set(['number', 'currency', 'percent']);
+/** Fields a chart can group by. */
+export const chartXColumns = (ctrl) => fieldColumns(ctrl).filter((c) => X_TYPES.has(c.fieldType ?? '') || c.def.cellDataType === 'date' || c.def.cellDataType === 'dateString');
+/** Fields a chart can add up. */
+export const chartYColumns = (ctrl) => fieldColumns(ctrl).filter((c) => NUMBER_TYPES.has(c.fieldType ?? '') || (c.fieldType === 'formula' && NUMERIC_RESULTS.has(String(fieldPropsOf(originalColumn(c.def)).result))) || (!c.fieldType && c.def.cellDataType === 'number'));
+/** A first setting for a new chart view: the first select (or any field it can group by), counted. */
+export function defaultChart(ctrl) {
+    const xs = chartXColumns(ctrl);
+    const x = xs.find((c) => c.fieldType === 'singleSelect') ?? xs[0];
+    return x ? { kind: 'bar', x: x.id } : null;
+}
+const EMPTY = 'Empty';
+const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+/** The value a column shows for a row: computed for a formula, rollup or count. */
+function valueOf(c, row) {
+    const fn = c.def.fieldFn;
+    return fn ? fn(row) : row?.[c.field];
+}
+/** The group keys a row falls in for column `c` (a multiple select or a link is in several). */
+function keysOf(c, row) {
+    const v = valueOf(c, row);
+    const list = Array.isArray(v) ? v : v == null || v === '' ? [] : [v];
+    if (c.fieldType === 'checkbox')
+        return [v === true ? 'Checked' : 'Unchecked'];
+    if (!list.length)
+        return [EMPTY];
+    if (c.fieldType === 'user' || c.fieldType === 'createdBy')
+        return list.map((id) => findFieldUser(id)?.name ?? String(id));
+    if (c.fieldType === 'link') {
+        const t = getLinkedTable(fieldPropsOf(originalColumn(c.def)).table);
+        const names = t ? linkedRows(t, v).map((r) => String(r[t.primaryField] ?? '')) : [];
+        return names.length ? names : [EMPTY];
+    }
+    if (c.fieldType === 'lookup') {
+        // Each linked value as the lookup shows it (a linked date or amount in its own format).
+        const fmt = c.def.formatter;
+        const names = list.map((x) => (fmt ? String(fmt({ value: x }) ?? '') : String(x))).filter((s) => s !== '');
+        return names.length ? [...new Set(names)] : [EMPTY];
+    }
+    if (c.fieldType === 'formula') {
+        const dated = fieldPropsOf(originalColumn(c.def)).result === 'date' || c.def.cellDataType === 'date' || c.def.cellDataType === 'dateString';
+        const keys = list.map((x) => {
+            // A date value groups by its local month, as a stored date does.
+            if (x instanceof Date)
+                return Number.isNaN(x.getTime()) ? EMPTY : `${x.getFullYear()}-${String(x.getMonth() + 1).padStart(2, '0')}`;
+            if (typeof x === 'number')
+                return String(Math.round(x * 1e10) / 1e10);
+            if (dated && typeof x === 'string' && /^\d{4}-\d{2}-\d{2}/.test(x))
+                return x.slice(0, 7);
+            return String(x);
+        });
+        return [...new Set(keys)];
+    }
+    if (c.fieldType === 'date' || c.fieldType === 'createdTime' || c.def.cellDataType === 'date' || c.def.cellDataType === 'dateString') {
+        const s = String(list[0]);
+        const m = /^(\d{4})-(\d{2})/.exec(s);
+        return [m ? `${m[1]}-${m[2]}` : s];
+    }
+    return list.map((x) => String(x));
+}
+/** The category labels in their order: a select's options first, months by date, else as met (numbers ascending). */
+function orderOf(c, keys) {
+    const colors = {};
+    const empty = keys.includes(EMPTY) ? [EMPTY] : [];
+    const rest = keys.filter((k) => k !== EMPTY);
+    if (c.fieldType === 'singleSelect' || c.fieldType === 'multiSelect') {
+        const options = fieldPropsOf(originalColumn(c.def)).options ?? [];
+        const rank = new Map(options.map((o, i) => [String(o.value), i]));
+        for (const o of options)
+            if (o.color)
+                colors[String(o.value)] = o.color;
+        rest.sort((a, b) => (rank.get(a) ?? 1e9) - (rank.get(b) ?? 1e9));
+        return { keys: [...rest, ...empty], label: (k) => k, colors };
+    }
+    const isMonth = rest.length > 0 && rest.every((k) => /^\d{4}-\d{2}$/.test(k));
+    if (isMonth) {
+        rest.sort();
+        return { keys: [...rest, ...empty], label: (k) => (k === EMPTY ? k : `${MONTHS[Number(k.slice(5)) - 1]} ${k.slice(0, 4)}`), colors };
+    }
+    if (rest.length && rest.every((k) => k !== '' && !Number.isNaN(Number(k))))
+        rest.sort((a, b) => Number(a) - Number(b));
+    return { keys: [...rest, ...empty], label: (k) => k, colors };
+}
+/** The chart for `rows` (the records the view shows), or null when its fields are gone. */
+export function chartSpec(ctrl, setting, rows) {
+    const cols = fieldColumns(ctrl);
+    const x = cols.find((c) => c.id === setting.x);
+    if (!x)
+        return null;
+    const y = setting.y ? cols.find((c) => c.id === setting.y) : undefined;
+    const sums = new Map();
+    for (const row of rows) {
+        if (row == null)
+            continue;
+        const raw = y ? Number(valueOf(y, row)) : 1;
+        for (const k of keysOf(x, row)) {
+            const s = sums.get(k) ?? { total: 0, n: 0 };
+            if (!y || Number.isFinite(raw)) {
+                s.total += Number.isFinite(raw) ? raw : 0;
+                s.n += 1;
+            }
+            sums.set(k, s);
+        }
+    }
+    const { keys, label, colors } = orderOf(x, [...sums.keys()]);
+    const avg = !!y && setting.aggregation === 'avg';
+    const values = keys.map((k) => {
+        const s = sums.get(k);
+        return avg ? (s.n ? s.total / s.n : 0) : s.total;
+    });
+    const categories = keys.map(label);
+    const categoryColors = {};
+    keys.forEach((k, i) => {
+        if (colors[k])
+            categoryColors[categories[i]] = colors[k];
+    });
+    const kind = setting.kind;
+    return {
+        type: kind === 'barH' ? 'bar' : kind === 'donut' ? 'pie' : kind,
+        categories,
+        series: [
+            {
+                label: y ? `${avg ? 'Average' : 'Sum'} of ${y.header}` : 'Records',
+                values,
+                // Each bar in its option's color (a pie takes them from categoryColors).
+                ...(Object.keys(categoryColors).length && (kind === 'bar' || kind === 'barH') ? { colors: keys.map((k) => colors[k] ?? null) } : {}),
+            },
+        ],
+        ...(Object.keys(categoryColors).length ? { categoryColors } : {}),
+        ...(kind === 'barH' ? { orientation: 'horizontal' } : {}),
+        ...(kind === 'donut' ? { innerRadius: 0.58 } : {}),
+    };
+}
+/** How a value shows on the axis and in tooltips: as the summed field shows it ($48,000), a count as a whole number. */
+export function chartFormatter(ctrl, setting) {
+    const y = setting.y ? fieldColumns(ctrl).find((c) => c.id === setting.y) : undefined;
+    if (!y)
+        return (v) => String(Math.round(v));
+    const fmt = y.def.formatter;
+    return fmt ? (v) => String(fmt({ value: v }) ?? v) : undefined;
+}

package/dist/fields/column-order.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The full column order with the shown columns in `visual` order and every
+ * other column (hidden ones) left in its slot, so reordering what is shown
+ * does not move what is hidden. (The grid's pin splitter keeps the same rule.)
+ */
+export declare function orderKeepingScreen(base: ReadonlyArray<string>, visual: ReadonlyArray<string>): string[];

package/dist/fields/column-order.js

@@ -0,0 +1,12 @@
+/**
+ * The full column order with the shown columns in `visual` order and every
+ * other column (hidden ones) left in its slot, so reordering what is shown
+ * does not move what is hidden. (The grid's pin splitter keeps the same rule.)
+ */
+export function orderKeepingScreen(base, visual) {
+    const inBase = new Set(base);
+    const shown = visual.filter((id) => inBase.has(id));
+    const shownSet = new Set(shown);
+    let i = 0;
+    return base.map((id) => (shownSet.has(id) ? (shown[i++] ?? id) : id));
+}

package/dist/fields/convert.d.ts

@@ -0,0 +1,16 @@
+/** Whether switching a field to `to` keeps its stored values as they are. */
+export declare const keepsStoredValues: (to: string) => boolean;
+export declare const isEmptyValue: (v: unknown) => boolean;
+/** A value as plain text, whatever its type. */
+export declare function asText(v: unknown, fromType?: string): string;
+/** `value` of a field of type `from`, as a value of type `to` (with `toProps`, the new field's properties). */
+export declare function convertValue(value: unknown, from: string | undefined, to: string, toProps?: Record<string, unknown>): unknown;
+/**
+ * How many of `values` are not empty now and would lose their value after
+ * converting: cleared, or cut to part of it (several names to a single select).
+ */
+export declare function countCleared(values: ReadonlyArray<unknown>, from: string | undefined, to: string, toProps?: Record<string, unknown>): number;
+/** Select options for converted values: every distinct value, in first-seen order. */
+export declare function optionsFromValues(values: ReadonlyArray<unknown>): Array<{
+    value: string;
+}>;

package/dist/fields/convert.js

@@ -0,0 +1,176 @@
+/**
+ * Changing a field's type converts its values where they can be: a number
+ * typed as text stays a number, a comma list becomes multiple-select values,
+ * URLs in text become attachments. What cannot convert becomes empty, and the
+ * field editor says how many cells that is before it applies the change.
+ */
+import { attachmentsFromText, attachmentsText, toAttachments } from './attachments.js';
+import { parseDuration } from './format.js';
+import { fillFieldColumn, getFieldType } from './registry.svelte.js';
+import { splitNames } from './name-list.js';
+import { getLinkedTable, resolveLinkId, resolveLinkIds } from './sources.svelte.js';
+const TEXT_TYPES = new Set(['text', 'longText', 'url', 'email', 'phone', 'barcode']);
+/** Types whose cells the module computes or writes itself: switching to one keeps the stored values and clears nothing. */
+const COMPUTED_TYPES = new Set(['formula', 'lookup', 'rollup', 'count', 'createdTime', 'lastModifiedTime', 'createdBy', 'lastModifiedBy', 'autoNumber', 'button']);
+const NUMBER_TYPES = new Set(['number', 'currency', 'percent', 'rating']);
+/** Whether switching a field to `to` keeps its stored values as they are. */
+export const keepsStoredValues = (to) => COMPUTED_TYPES.has(to);
+export const isEmptyValue = (v) => v == null || v === '' || (Array.isArray(v) && v.length === 0) || (typeof v === 'number' && Number.isNaN(v));
+/** A value as plain text, whatever its type. */
+export function asText(v, fromType) {
+    if (v == null)
+        return '';
+    if (fromType === 'attachment')
+        return attachmentsText(v);
+    if (Array.isArray(v))
+        return v.map((x) => asText(x)).filter(Boolean).join(', ');
+    if (v instanceof Date)
+        return localDay(v);
+    return String(v);
+}
+/** A date's local calendar day as YYYY-MM-DD: a formula's TODAY() is local midnight. */
+const localDay = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+/** `value` of a field of type `from`, as a value of type `to` (with `toProps`, the new field's properties). */
+export function convertValue(value, from, to, toProps) {
+    if (COMPUTED_TYPES.has(to))
+        return value;
+    if (isEmptyValue(value))
+        return to === 'checkbox' ? false : to === 'multiSelect' || to === 'attachment' ? [] : null;
+    if (from === to)
+        return value;
+    if (TEXT_TYPES.has(to))
+        return asText(value, from);
+    if (to === 'duration')
+        return typeof value === 'number' ? value : parseDuration(asText(value, from));
+    if (to === 'user')
+        return Array.isArray(value) ? value.map((x) => asText(x)) : asText(value, from) || null;
+    if (to === 'link') {
+        // Names (a multiple select, a lookup, "Acme, Northwind" in text) become
+        // the ids of the linked table's records; a name no record has is dropped.
+        const table = getLinkedTable(toProps?.table);
+        const ids = table ? resolveLinkIds(table, linkParts(value, from)) : [];
+        return toProps?.multiple === false ? ids.slice(0, 1) : ids;
+    }
+    if (NUMBER_TYPES.has(to)) {
+        if (typeof value === 'boolean')
+            return value ? 1 : 0;
+        if (typeof value === 'number')
+            return to === 'rating' ? Math.max(0, Math.min(10, Math.round(value))) : value;
+        // A list (a lookup, a multiple select) is a number only when it holds one value: [1, 2] is not 12.
+        if (Array.isArray(value))
+            return value.length === 1 ? convertValue(value[0], undefined, to) : null;
+        // Keep digits, the decimal point, a sign and an exponent: "$1,200" -> 1200.
+        const kept = asText(value, from).replace(/[^0-9.eE+-]/g, '');
+        // No digit at all ("n/a") is not zero; Number('') would say it is.
+        const n = /\d/.test(kept) ? Number(kept) : NaN;
+        if (!Number.isFinite(n))
+            return null;
+        return to === 'rating' ? Math.max(0, Math.min(10, Math.round(n))) : n;
+    }
+    if (to === 'checkbox') {
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'number')
+            return value !== 0;
+        return /^(true|yes|y|1|x|on|done|checked)$/i.test(asText(value, from).trim());
+    }
+    if (to === 'date') {
+        if (value instanceof Date)
+            return Number.isNaN(value.getTime()) ? null : localDay(value);
+        const t = new Date(asText(value, from));
+        return Number.isNaN(t.getTime()) ? null : t.toISOString().slice(0, 10);
+    }
+    if (to === 'singleSelect') {
+        const text = Array.isArray(value) ? asText(value[0]) : asText(value, from);
+        return text.trim() || null;
+    }
+    if (to === 'multiSelect') {
+        const parts = Array.isArray(value) ? value.map((x) => asText(x)) : asText(value, from).split(',');
+        return [...new Set(parts.map((s) => s.trim()).filter(Boolean))];
+    }
+    if (to === 'attachment') {
+        return from === 'attachment' ? toAttachments(value) : attachmentsFromText(asText(value, from));
+    }
+    // An app-registered type: the value as text, read by the type's valueParser
+    // as a paste would be. Without a parser, a list or an object becomes its
+    // text and a plain value stays as it is.
+    const parse = parserFor(to, toProps);
+    const text = asText(value, from);
+    if (!parse)
+        return value !== null && typeof value === 'object' ? text || null : value;
+    const out = parse(text);
+    return out === undefined ? null : out;
+}
+// Per registered type, per its properties (as JSON): the parser its fill gives a column.
+const parsers = new WeakMap();
+function parserFor(to, props) {
+    const type = getFieldType(to);
+    if (!type)
+        return null;
+    let byProps = parsers.get(type);
+    if (!byProps)
+        parsers.set(type, (byProps = new Map()));
+    const key = JSON.stringify(props ?? {});
+    if (!byProps.has(key)) {
+        const fn = fillFieldColumn({ field: '__convert', fieldType: to, fieldProps: props ?? {} }).valueParser;
+        byProps.set(key, typeof fn === 'function'
+            ? (text) => {
+                try {
+                    return fn({ newValue: text, oldValue: null, rawInput: text });
+                }
+                catch {
+                    return null;
+                }
+            }
+            : null);
+    }
+    return byProps.get(key);
+}
+/** The names a value gives a link: a list's items, or text split at commas outside quotes. */
+function linkParts(value, from) {
+    return Array.isArray(value) ? value.map((x) => asText(x).trim()).filter(Boolean) : splitNames(asText(value, from));
+}
+/**
+ * Whether converting `value` keeps only part of it: several names to a single
+ * select (the first one stays), or names a link cannot find or cannot hold.
+ */
+function losesPart(value, from, to, toProps) {
+    if (to === 'singleSelect')
+        return Array.isArray(value) && new Set(value.map((x) => asText(x).trim()).filter(Boolean)).size > 1;
+    if (to === 'link') {
+        const table = getLinkedTable(toProps?.table);
+        if (!table)
+            return false;
+        const ids = linkParts(value, from).map((part) => resolveLinkId(table, part));
+        return ids.some((id) => id == null) || (toProps?.multiple === false && new Set(ids).size > 1);
+    }
+    return false;
+}
+/**
+ * How many of `values` are not empty now and would lose their value after
+ * converting: cleared, or cut to part of it (several names to a single select).
+ */
+export function countCleared(values, from, to, toProps) {
+    if (COMPUTED_TYPES.has(to) || from === to)
+        return 0;
+    let n = 0;
+    for (const v of values) {
+        if (isEmptyValue(v))
+            continue;
+        if (isEmptyValue(convertValue(v, from, to, toProps)) || losesPart(v, from, to, toProps))
+            n += 1;
+    }
+    return n;
+}
+/** Select options for converted values: every distinct value, in first-seen order. */
+export function optionsFromValues(values) {
+    const seen = new Set();
+    for (const v of values) {
+        for (const s of Array.isArray(v) ? v : [v]) {
+            const t = s == null ? '' : String(s).trim();
+            if (t)
+                seen.add(t);
+        }
+    }
+    return [...seen].slice(0, 200).map((value) => ({ value }));
+}

package/dist/fields/copy-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What a copy (Ctrl+C) writes for a field of a base: names for people and
+ * links (their paste reads names back), the URLs of attachments (a paste of
+ * URLs attaches them), a barcode's text. Every other value is copied as
+ * stored, so numbers and dates paste back exactly. Names of linked records
+ * and of several people are quoted when they hold a comma ("Acme, Inc."),
+ * so the paste splits them back the same way.
+ */
+export declare function fieldCopyText(p: {
+    value: unknown;
+    column: unknown;
+    row: unknown;
+}): unknown;

package/dist/fields/copy-text.js

@@ -0,0 +1,45 @@
+import { toAttachments } from './attachments.js';
+import { joinNames } from './name-list.js';
+import { findFieldUser, getLinkedTable, linkedRows } from './sources.svelte.js';
+// Types that store ids or objects: a copy writes what their cell shows.
+const AS_SHOWN = new Set(['user', 'createdBy', 'lastModifiedBy', 'link', 'lookup', 'barcode']);
+/**
+ * A stored URL as an absolute one: a paste attaches only http(s) URLs, so a
+ * relative one ('/api/files/123') is resolved against the page.
+ */
+function absoluteUrl(url) {
+    if (typeof location === 'undefined')
+        return url;
+    try {
+        return new URL(url, location.href).href;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * What a copy (Ctrl+C) writes for a field of a base: names for people and
+ * links (their paste reads names back), the URLs of attachments (a paste of
+ * URLs attaches them), a barcode's text. Every other value is copied as
+ * stored, so numbers and dates paste back exactly. Names of linked records
+ * and of several people are quoted when they hold a comma ("Acme, Inc."),
+ * so the paste splits them back the same way.
+ */
+export function fieldCopyText(p) {
+    const def = p.column?.columnDef;
+    const type = def?.fieldType;
+    if (type === 'attachment')
+        return toAttachments(p.value).map((a) => a.url).filter(Boolean).map(absoluteUrl).join(' ');
+    if (type === 'link') {
+        const table = getLinkedTable(def?.fieldProps?.table);
+        if (table)
+            return joinNames(linkedRows(table, p.value).map((r) => String(r[table.primaryField] ?? '')));
+    }
+    if (type === 'user' && def?.fieldProps?.multiple) {
+        const ids = Array.isArray(p.value) ? p.value : p.value == null || p.value === '' ? [] : [p.value];
+        return joinNames(ids.map((x) => findFieldUser(x)?.name ?? String(x)));
+    }
+    if (!AS_SHOWN.has(type) || typeof def?.formatter !== 'function')
+        return p.value;
+    return def.formatter({ value: p.value, row: p.row, column: p.column });
+}

package/dist/fields/editor-request.svelte.d.ts

@@ -0,0 +1,71 @@
+export type FieldEditorRequest = {
+    ctrl: unknown;
+    mode: 'add' | 'edit';
+    /** The field being edited (mode 'edit'). */
+    columnId?: string;
+    /** Where a new field goes (mode 'add'). */
+    index?: number | 'end';
+};
+export declare const getFieldEditorRequest: () => FieldEditorRequest | null;
+export declare function openFieldEditor(r: FieldEditorRequest): void;
+export declare function closeFieldEditor(): void;
+/**
+ * Which grid's record view is open, and on which row. The row header's expand
+ * button sets it; FieldsHeaderEnd shows the view when it names its own grid.
+ */
+/**
+ * `editPrimary`: a record just made, so its name is the first thing to type.
+ * `focus: 'comment'`: the record opens with its comment box focused.
+ */
+export type RecordRequest = {
+    ctrl: unknown;
+    rowId: string;
+    editPrimary?: boolean;
+    focus?: 'comment';
+};
+/**
+ * What `openRecord` takes: the grid as `ctrl`, or as `api`, the object
+ * `onApiReady` hands the app (an api passed as `ctrl` works too).
+ */
+export type OpenRecordRequest = {
+    ctrl?: unknown;
+    api?: unknown;
+    rowId: string;
+    editPrimary?: boolean;
+    focus?: 'comment';
+};
+export declare const getRecordRequest: () => RecordRequest | null;
+export declare function openRecord(r: OpenRecordRequest): void;
+/** Close the open record; given a grid (controller or api), only when it is open on that grid. */
+export declare function closeRecord(grid?: unknown): void;
+/**
+ * Records of a linked table opened from a link chip, newest last (a linked
+ * record can open another over it), and the chip the pointer rests on. The
+ * grid the chip is in shows them (FieldsHeaderEnd).
+ */
+export type LinkedRecordRequest = {
+    ctrl: unknown;
+    table: string;
+    rowId: string;
+};
+export declare const getLinkedRecords: () => LinkedRecordRequest[];
+export declare function openLinkedRecord(r: LinkedRecordRequest): void;
+export declare function closeLinkedRecord(): void;
+/**
+ * A field to delete once the user confirms: a link with a field that links
+ * back or fields that read it, or any field that formulas read.
+ */
+export type DeleteFieldRequest = {
+    ctrl: unknown;
+    columnId: string;
+};
+export declare const getDeleteFieldRequest: () => DeleteFieldRequest | null;
+export declare function askDeleteField(r: DeleteFieldRequest | null): void;
+/** Close every linked record (one was opened where it lives). */
+export declare function closeAllLinkedRecords(): void;
+export type LinkPreviewRequest = LinkedRecordRequest & {
+    x: number;
+    y: number;
+};
+export declare const getLinkPreview: () => LinkPreviewRequest | null;
+export declare function showLinkPreview(r: LinkPreviewRequest | null): void;

package/dist/fields/editor-request.svelte.js

@@ -0,0 +1,52 @@
+/**
+ * Which grid's field editor is open, and for what. The column-menu actions
+ * (run outside any component) set it; FieldsHeaderEnd, mounted in each grid's
+ * header row, shows the editor when the request names its own grid.
+ */
+import { gridOf } from './grid-access.js';
+let request = $state.raw(null);
+export const getFieldEditorRequest = () => request;
+export function openFieldEditor(r) {
+    request = r;
+}
+export function closeFieldEditor() {
+    request = null;
+}
+let record = $state.raw(null);
+/** The grid behind a controller or an api. */
+const ctrlOf = (grid) => gridOf(grid) ?? grid;
+export const getRecordRequest = () => record;
+export function openRecord(r) {
+    const { api, ...rest } = r;
+    record = { ...rest, ctrl: ctrlOf(r.ctrl ?? api) };
+}
+/** Close the open record; given a grid (controller or api), only when it is open on that grid. */
+export function closeRecord(grid) {
+    if (grid !== undefined && record && record.ctrl !== ctrlOf(grid))
+        return;
+    record = null;
+}
+let linked = $state.raw([]);
+export const getLinkedRecords = () => linked;
+export function openLinkedRecord(r) {
+    linked = [...linked, r];
+    linkPreview = null;
+}
+export function closeLinkedRecord() {
+    linked = linked.slice(0, -1);
+}
+let deleting = $state.raw(null);
+export const getDeleteFieldRequest = () => deleting;
+export function askDeleteField(r) {
+    deleting = r;
+}
+/** Close every linked record (one was opened where it lives). */
+export function closeAllLinkedRecords() {
+    linked = [];
+    linkPreview = null;
+}
+let linkPreview = $state.raw(null);
+export const getLinkPreview = () => linkPreview;
+export function showLinkPreview(r) {
+    linkPreview = r;
+}