@svgrid/enterprise 3.1.7 → 3.1.9

package/dist/fields/field-ops.d.ts

@@ -0,0 +1,72 @@
+type Def = Record<string, unknown> & {
+    id?: string;
+    field?: string;
+    header?: unknown;
+    fieldType?: string;
+    fieldProps?: Record<string, unknown>;
+};
+type Ctrl = {
+    props: Record<string, any>;
+    internalColumns: Def[];
+    internalData: Record<string, unknown>[];
+    buildApi?: () => {
+        setColumnVisible?: (id: string, visible: boolean) => void;
+    };
+    scrollContainer?: HTMLElement | null;
+};
+export type FieldDraft = {
+    name: string;
+    fieldType: string;
+    fieldProps: Record<string, unknown>;
+    description?: string;
+};
+export declare const defId: (d: Def) => string;
+/** The column as the app declared it, without what its type filled in. */
+export declare function plainDef(d: Def): Def;
+/** The declared columns after a change: what every field event hands the app. */
+export declare const plainColumns: (ctrl: Ctrl) => Def[];
+/** A new column id from a name: lower-case words, unique among the grid's columns. */
+export declare function uniqueId(name: string, taken: Iterable<string>): string;
+/** Whether `name` is free: no other column has that header (case-insensitive). */
+export declare function nameTaken(ctrl: Ctrl, name: string, exceptId?: string): boolean;
+/** Add a field from the editor. Returns the plain column. */
+export declare function addField(ctrl: Ctrl, draft: FieldDraft, index?: number | 'end'): Def;
+/** A new record id: "rec" and nine letters and digits, unique in this page. */
+export declare function newRecordId(): string;
+/**
+ * The values a new row gets from its field columns: each type's newRowValue
+ * (the next autonumber, the created time, today), else the field's default.
+ * `base` (the row adder's own defaults) wins over both.
+ */
+export declare function newRowValues(ctrl: Ctrl, base?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * The values a duplicate of `row` starts with: its stored fields, lists
+ * copied, without its id or what is stamped on a new record (a type with
+ * `copy: false`). Give them to `newRowValues` for the rest.
+ */
+export declare function recordCopyValues(ctrl: Ctrl, row: Record<string, unknown>): Record<string, unknown>;
+/** What changing `columnId` to `draft` would clear: cells not empty now, empty after. */
+export declare function previewChange(ctrl: Ctrl, columnId: string, draft: FieldDraft): number;
+/** Apply the editor's draft to an existing field; converts values when the type changes. */
+export declare function updateField(ctrl: Ctrl, columnId: string, draft: FieldDraft): Def | null;
+/**
+ * Add choices to a select field, as typing a new value into its cell does.
+ * Options already there (same value) are skipped; fires onColumnChange.
+ */
+export declare function addSelectOptions(ctrl: Ctrl, columnId: string, added: ReadonlyArray<{
+    value: string;
+    color?: string;
+}>): Def | null;
+/**
+ * The summary a field shows in the footer row (`fieldProps.summary`, from
+ * the footer's picker; 'none' clears it). Fires onColumnChange.
+ */
+export declare function setFieldSummary(ctrl: Ctrl, columnId: string, kind: string): Def | null;
+/** A copy of a field, values included, right after it. */
+export declare function duplicateField(ctrl: Ctrl, columnId: string): Def | null;
+/** Remove a field's column (its values stay in the rows). */
+export declare function removeField(ctrl: Ctrl, columnId: string): void;
+export declare function hideField(ctrl: Ctrl, columnId: string): void;
+/** The index a field inserted next to `columnId` goes to. */
+export declare function indexBeside(ctrl: Ctrl, columnId: string, side: 'left' | 'right'): number;
+export {};

package/dist/fields/field-ops.js

@@ -0,0 +1,334 @@
+/**
+ * What the field editor and the column menu do to a grid: add, edit, insert,
+ * duplicate and delete a field. They work on the grid's own columns and rows
+ * and report each change (onColumnAdd / onColumnChange / onColumnRemove) so
+ * the app can store its schema; the grid keeps none.
+ *
+ * A column the app hands over keeps its plain shape here: `id`, `field`,
+ * `header`, `width`, `fieldType`, `fieldProps`, `description`. What a type fills
+ * in (editor, format, alignment...) is recomputed from that on every change.
+ */
+import { convertValue, countCleared, keepsStoredValues, optionsFromValues } from './convert.js';
+import { renameFormulaRefs } from './formula.js';
+import { fieldPropsOf, fillFieldColumn, getFieldType, originalColumn } from './registry.svelte.js';
+import { getLinkedTable, linkedRows } from './sources.svelte.js';
+/** Keys a field type fills in. A type change drops them from the declared column too, so the new type's take. */
+const FILLED = ['editorType', 'cellDataType', 'format', 'align', 'editorOptions', 'editorMultiple', 'formatter', 'valueParser'];
+export const defId = (d) => String(d.id ?? d.field ?? '');
+/** The column as the app declared it, without what its type filled in. */
+export function plainDef(d) {
+    return { ...originalColumn(d) };
+}
+/** The declared columns after a change: what every field event hands the app. */
+export const plainColumns = (ctrl) => ctrl.internalColumns.map((d) => plainDef(d));
+/** A new column id from a name: lower-case words, unique among the grid's columns. */
+export function uniqueId(name, taken) {
+    const used = new Set(taken);
+    const base = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'field';
+    let id = base;
+    for (let i = 2; used.has(id); i++)
+        id = `${base}_${i}`;
+    return id;
+}
+/** Whether `name` is free: no other column has that header (case-insensitive). */
+export function nameTaken(ctrl, name, exceptId) {
+    const n = name.trim().toLowerCase();
+    return ctrl.internalColumns.some((d) => defId(d) !== exceptId && String(d.header ?? '').trim().toLowerCase() === n);
+}
+function cleanProps(p) {
+    const out = {};
+    for (const [k, v] of Object.entries(p))
+        if (v !== undefined && v !== '' && !(Array.isArray(v) && v.length === 0 && k !== 'options'))
+            out[k] = v;
+    return out;
+}
+/**
+ * Fill every field column again against `cols`: a formula, lookup or button
+ * that names another field must see a renamed, added or removed one.
+ */
+function refill(cols) {
+    return cols.map((c) => (originalColumn(c).fieldType ? fillFieldColumn(originalColumn(c), cols) : c));
+}
+/**
+ * Scroll the grid sideways, and only the grid, until a column just added is
+ * in view: one added past the right edge would otherwise go unseen.
+ */
+function revealColumn(ctrl, id) {
+    if (typeof requestAnimationFrame !== 'function')
+        return;
+    requestAnimationFrame(() => {
+        const sc = ctrl.scrollContainer;
+        // `id` comes from uniqueId: [a-z0-9_] only, safe in a selector as is.
+        const th = sc?.querySelector(`[data-svgrid-header-col="${id}"]`);
+        if (!sc || !th)
+            return;
+        const box = sc.getBoundingClientRect();
+        const r = th.getBoundingClientRect();
+        const right = box.left + sc.clientWidth;
+        if (r.right > right)
+            sc.scrollLeft += Math.min(r.right - right, r.left - box.left);
+        else if (r.left < box.left)
+            sc.scrollLeft -= box.left - r.left;
+    });
+}
+function insertAt(cols, def, index) {
+    const next = cols.slice();
+    next.splice(index === 'end' ? next.length : Math.max(0, Math.min(index, next.length)), 0, def);
+    return next;
+}
+/** Add a field from the editor. Returns the plain column. */
+export function addField(ctrl, draft, index = 'end') {
+    const id = uniqueId(draft.name, ctrl.internalColumns.map(defId));
+    const type = getFieldType(draft.fieldType);
+    const def = {
+        id,
+        field: id,
+        header: draft.name.trim(),
+        width: type?.width ?? 150,
+        fieldType: draft.fieldType,
+        fieldProps: cleanProps(draft.fieldProps),
+        ...(draft.description?.trim() ? { description: draft.description.trim() } : {}),
+    };
+    // Autonumber and created time give every existing row its value now.
+    let data;
+    const values = type?.onCreate?.({ props: fieldPropsOf(def), field: id, rows: ctrl.internalData });
+    if (values) {
+        data = ctrl.internalData.map((r, i) => (r == null ? r : { ...r, [id]: values[i] }));
+        ctrl.internalData = data;
+    }
+    ctrl.internalColumns = refill(insertAt(ctrl.internalColumns, def, index));
+    ctrl.props.onColumnAdd?.({ column: def, columns: plainColumns(ctrl), ...(data ? { data } : {}) });
+    revealColumn(ctrl, id);
+    return def;
+}
+let seq = 0;
+/** A new record id: "rec" and nine letters and digits, unique in this page. */
+export function newRecordId() {
+    seq = (seq + 1) % 1296;
+    return `rec${Date.now().toString(36).slice(-5)}${Math.random().toString(36).slice(2, 4)}${seq.toString(36).padStart(2, '0')}`;
+}
+/**
+ * The values a new row gets from its field columns: each type's newRowValue
+ * (the next autonumber, the created time, today), else the field's default.
+ * `base` (the row adder's own defaults) wins over both.
+ */
+export function newRowValues(ctrl, base = {}) {
+    const row = {};
+    for (const c of ctrl.internalColumns) {
+        const plain = originalColumn(c);
+        if (!plain.fieldType || !c.field)
+            continue;
+        const field = String(c.field);
+        const props = fieldPropsOf(plain);
+        const fromType = getFieldType(plain.fieldType)?.newRowValue?.({ props, field, rows: ctrl.internalData });
+        const value = fromType !== undefined ? fromType : props.default;
+        if (value !== undefined)
+            row[field] = Array.isArray(value) ? value.slice() : value;
+    }
+    // A table whose records carry an id (a base, or rows keyed with getRowId on
+    // `id`) needs one on the new record too, or two new records share a key.
+    if (!('id' in base) && (ctrl.internalData ?? []).some((r) => r && typeof r === 'object' && 'id' in r))
+        row.id = newRecordId();
+    return { ...row, ...base };
+}
+/** Built-in fields a copy of a record gets fresh, never copied: its number, when and by whom it was made. */
+const STAMPED = new Set(['autoNumber', 'createdTime', 'createdBy', 'lastModifiedTime', 'lastModifiedBy']);
+/** Whether a duplicate gets this field fresh: a built-in stamp, or a type registered with `copy: false`. */
+const freshOnCopy = (fieldType) => STAMPED.has(String(fieldType)) || getFieldType(fieldType)?.copy === false;
+/**
+ * The values a duplicate of `row` starts with: its stored fields, lists
+ * copied, without its id or what is stamped on a new record (a type with
+ * `copy: false`). Give them to `newRowValues` for the rest.
+ */
+export function recordCopyValues(ctrl, row) {
+    const out = {};
+    for (const c of ctrl.internalColumns) {
+        const plain = originalColumn(c);
+        if (!c.field || c.fieldFn || plain.fieldFn || freshOnCopy(plain.fieldType))
+            continue;
+        const v = row[String(c.field)];
+        if (v !== undefined)
+            out[String(c.field)] = Array.isArray(v) ? v.slice() : v;
+    }
+    return out;
+}
+/**
+ * A field's values as a type change converts them: what a formula, lookup,
+ * rollup or count works out (its records store nothing), a link's records by
+ * their primary field (names, not record ids), else what the records store.
+ */
+function valuesToConvert(ctrl, filled, to) {
+    const field = String(filled.field);
+    const stored = ctrl.internalData.map((r) => r?.[field]);
+    if (keepsStoredValues(to))
+        return stored;
+    const plain = originalColumn(filled);
+    // Filled again against today's fields, so the values are the ones shown now.
+    const fn = (plain.fieldType ? fillFieldColumn(plain, ctrl.internalColumns) : filled).fieldFn;
+    if (typeof fn === 'function') {
+        // A formula that does not compile has nothing to keep.
+        return ctrl.internalData.map((r) => {
+            if (r == null)
+                return undefined;
+            const v = fn(r);
+            return v === '#ERROR' ? null : v;
+        });
+    }
+    if (plain.fieldType === 'link' && to !== 'link') {
+        const table = getLinkedTable(fieldPropsOf(plain).table);
+        if (table)
+            return stored.map((v) => linkedRows(table, v).map((r) => r[table.primaryField]).filter((x) => x != null && x !== ''));
+    }
+    return stored;
+}
+/** What changing `columnId` to `draft` would clear: cells not empty now, empty after. */
+export function previewChange(ctrl, columnId, draft) {
+    const prev = ctrl.internalColumns.find((d) => defId(d) === columnId);
+    if (!prev || prev.fieldType === draft.fieldType || !prev.field)
+        return 0;
+    return countCleared(valuesToConvert(ctrl, prev, draft.fieldType), prev.fieldType, draft.fieldType, cleanProps(draft.fieldProps));
+}
+/**
+ * Other formulas of the table after a field's header changes from `from` to
+ * `to`: each `{from}` that named the field now reads `{to}`. A `{field key}`
+ * reference needs nothing, a rename leaves the key as it was.
+ */
+function renameInFormulas(cols, field, from, to) {
+    const old = from.trim().toLowerCase();
+    if (!old || old === to.trim().toLowerCase())
+        return cols;
+    return cols.map((c) => {
+        const plain = originalColumn(c);
+        if (plain.fieldType !== 'formula' || String(plain.field ?? plain.id) === field)
+            return c;
+        const src = String(plain.fieldProps?.formula ?? '');
+        const next = renameFormulaRefs(src, (name) => (name.trim().toLowerCase() === old ? to : null));
+        return next === src ? c : { ...plain, fieldProps: { ...plain.fieldProps, formula: next } };
+    });
+}
+/** Apply the editor's draft to an existing field; converts values when the type changes. */
+export function updateField(ctrl, columnId, draft) {
+    const index = ctrl.internalColumns.findIndex((d) => defId(d) === columnId);
+    if (index < 0)
+        return null;
+    const previous = plainDef(ctrl.internalColumns[index]);
+    const typeChanged = previous.fieldType !== draft.fieldType;
+    const fieldProps = cleanProps(draft.fieldProps);
+    let data;
+    if (typeChanged && previous.field) {
+        const field = String(previous.field);
+        const before = valuesToConvert(ctrl, ctrl.internalColumns[index], draft.fieldType);
+        data = ctrl.internalData.map((r, i) => r == null ? r : { ...r, [field]: convertValue(before[i], previous.fieldType, draft.fieldType, fieldProps) });
+        // A select made from other values starts with those values as its options.
+        if ((draft.fieldType === 'singleSelect' || draft.fieldType === 'multiSelect') && !fieldProps.options?.length) {
+            fieldProps.options = optionsFromValues(data.map((r) => r?.[field]));
+        }
+    }
+    const base = { ...previous };
+    if (typeChanged)
+        for (const k of FILLED)
+            delete base[k];
+    const next = { ...base, header: draft.name.trim(), fieldType: draft.fieldType, fieldProps };
+    if (draft.description?.trim())
+        next.description = draft.description.trim();
+    else
+        delete next.description;
+    let cols = ctrl.internalColumns.slice();
+    cols[index] = next;
+    // A rename carries over to the formulas that name the field by its header.
+    if (typeof previous.header === 'string' && previous.field)
+        cols = renameInFormulas(cols, String(previous.field), previous.header, String(next.header));
+    ctrl.internalColumns = refill(cols);
+    if (data)
+        ctrl.internalData = data;
+    ctrl.props.onColumnChange?.({ column: next, previous, columns: plainColumns(ctrl), ...(data ? { data } : {}) });
+    return next;
+}
+/**
+ * Add choices to a select field, as typing a new value into its cell does.
+ * Options already there (same value) are skipped; fires onColumnChange.
+ */
+export function addSelectOptions(ctrl, columnId, added) {
+    const index = ctrl.internalColumns.findIndex((d) => defId(d) === columnId);
+    if (index < 0 || !added.length)
+        return null;
+    const previous = plainDef(ctrl.internalColumns[index]);
+    const options = Array.isArray(previous.fieldProps?.options) ? previous.fieldProps.options.slice() : [];
+    const have = new Set(options.map((o) => String(o.value)));
+    for (const o of added) {
+        if (have.has(o.value))
+            continue;
+        have.add(o.value);
+        options.push({ ...o });
+    }
+    const next = { ...previous, fieldProps: { ...previous.fieldProps, options } };
+    const cols = ctrl.internalColumns.slice();
+    cols[index] = next;
+    ctrl.internalColumns = refill(cols);
+    ctrl.props.onColumnChange?.({ column: next, previous, columns: plainColumns(ctrl) });
+    return next;
+}
+/**
+ * The summary a field shows in the footer row (`fieldProps.summary`, from
+ * the footer's picker; 'none' clears it). Fires onColumnChange.
+ */
+export function setFieldSummary(ctrl, columnId, kind) {
+    const index = ctrl.internalColumns.findIndex((d) => defId(d) === columnId);
+    if (index < 0)
+        return null;
+    const previous = plainDef(ctrl.internalColumns[index]);
+    const fieldProps = { ...previous.fieldProps };
+    if (kind === 'none')
+        delete fieldProps.summary;
+    else
+        fieldProps.summary = kind;
+    const next = { ...previous, fieldProps };
+    const cols = ctrl.internalColumns.slice();
+    cols[index] = next;
+    ctrl.internalColumns = refill(cols);
+    ctrl.props.onColumnChange?.({ column: next, previous, columns: plainColumns(ctrl) });
+    return next;
+}
+/** A copy of a field, values included, right after it. */
+export function duplicateField(ctrl, columnId) {
+    const index = ctrl.internalColumns.findIndex((d) => defId(d) === columnId);
+    if (index < 0)
+        return null;
+    const source = plainDef(ctrl.internalColumns[index]);
+    const header = `${String(source.header ?? columnId)} copy`;
+    const id = uniqueId(header, ctrl.internalColumns.map(defId));
+    const def = { ...source, id, field: id, header };
+    let data;
+    if (source.field) {
+        const from = String(source.field);
+        data = ctrl.internalData.map((r) => (r == null ? r : { ...r, [id]: structuredCloneSafe(r[from]) }));
+        ctrl.internalData = data;
+    }
+    ctrl.internalColumns = refill(insertAt(ctrl.internalColumns, def, index + 1));
+    ctrl.props.onColumnAdd?.({ column: def, columns: plainColumns(ctrl), ...(data ? { data } : {}) });
+    revealColumn(ctrl, id);
+    return def;
+}
+/** Remove a field's column (its values stay in the rows). */
+export function removeField(ctrl, columnId) {
+    ctrl.internalColumns = refill(ctrl.internalColumns.filter((d) => defId(d) !== columnId));
+    ctrl.props.onColumnRemove?.({ columnId, columns: plainColumns(ctrl) });
+}
+export function hideField(ctrl, columnId) {
+    ctrl.buildApi?.()?.setColumnVisible?.(columnId, false);
+}
+/** The index a field inserted next to `columnId` goes to. */
+export function indexBeside(ctrl, columnId, side) {
+    const i = ctrl.internalColumns.findIndex((d) => defId(d) === columnId);
+    return i < 0 ? ctrl.internalColumns.length : side === 'left' ? i : i + 1;
+}
+function structuredCloneSafe(v) {
+    if (v == null || typeof v !== 'object')
+        return v;
+    try {
+        return structuredClone(v);
+    }
+    catch {
+        return Array.isArray(v) ? v.slice() : { ...v };
+    }
+}

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

@@ -0,0 +1,84 @@
+/**
+ * The view bar's filter: conditions on fields, each with the operators that
+ * fit its type ("has any of" for a multiple select, "is within the past
+ * week" for a date), joined by "and" or "or", one level of groups deep.
+ *
+ * It is the grid's advanced filter (`api.setAdvancedFilter`) with its own
+ * expression kind, `fieldFilter`, so it is saved and restored with the rest
+ * of the grid's state.
+ */
+/**
+ * A person condition's value meaning whoever is signed in (`setCurrentUser`)
+ * when the filter runs, so one "My tasks" view works for everyone. With
+ * nobody signed in it matches no one.
+ */
+export declare const ME = "@me";
+export declare function resolveMeWith(fn: () => string | undefined): void;
+/** What a condition compares, from the field's type. */
+export type FilterKind = 'text' | 'number' | 'select' | 'multi' | 'checkbox' | 'date' | 'files' | 'link';
+export type FilterOp = 'contains' | 'notContains' | 'is' | 'isNot' | 'isEmpty' | 'isNotEmpty' | 'eq' | 'neq' | 'lt' | 'gt' | 'lte' | 'gte' | 'isAnyOf' | 'isNoneOf' | 'hasAnyOf' | 'hasAllOf' | 'hasNoneOf' | 'isExactly' | 'isBefore' | 'isAfter' | 'isOnOrBefore' | 'isOnOrAfter' | 'isWithin';
+/** A day a date condition names, relative to today or exact. */
+export type DateTarget = {
+    mode: 'today' | 'tomorrow' | 'yesterday' | 'oneWeekAgo' | 'oneWeekFromNow' | 'oneMonthAgo' | 'oneMonthFromNow';
+} | {
+    mode: 'exactDate';
+    date: string;
+};
+/** The span "is within" names. */
+export type DateSpan = {
+    span: 'pastWeek' | 'pastMonth' | 'pastYear' | 'nextWeek' | 'nextMonth' | 'nextYear' | 'pastDays' | 'nextDays';
+    days?: number;
+};
+export type FieldCondition = {
+    /** The column id. */
+    column: string;
+    kind: FilterKind;
+    op: FilterOp;
+    value?: unknown;
+    /** A link field's table, to match its records by name. */
+    table?: string;
+};
+export type FieldConditionGroup = {
+    conjunction: 'and' | 'or';
+    conditions: FieldCondition[];
+};
+export type FieldFilter = {
+    kind: 'fieldFilter';
+    conjunction: 'and' | 'or';
+    conditions: Array<FieldCondition | FieldConditionGroup>;
+};
+export declare const isGroup: (c: FieldCondition | FieldConditionGroup) => c is FieldConditionGroup;
+/**
+ * The kind of comparison a column gets; null for one that cannot be filtered
+ * (a button). A built-in type decides it; a computed type (formula, lookup,
+ * rollup), a type the app registered, and a plain column follow the
+ * column's cellDataType, as the footer summaries do.
+ */
+export declare function filterKindOf(def: Record<string, any>): FilterKind | null;
+/** The operators a kind offers, in the order the menu shows them. */
+export declare function operatorsFor(kind: FilterKind): ReadonlyArray<{
+    op: FilterOp;
+    label: string;
+}>;
+/** The value a new condition starts with for an operator. */
+export declare function defaultValue(kind: FilterKind, op: FilterOp): unknown;
+/** A new condition on a column, with its first operator. */
+export declare function newCondition(column: string, def: Record<string, any>): FieldCondition | null;
+/** Whether a condition says enough to filter: an empty value is a condition still being written. */
+export declare function isComplete(c: FieldCondition): boolean;
+/** How many complete conditions a filter has (the view bar's count). */
+export declare function conditionCount(filter: FieldFilter | null | undefined): number;
+/** What turns a link value (record ids) into the linked records' names. */
+export type LinkNames = (table: string, value: unknown) => string[];
+/** A value's day as a count of local days, or null. */
+export declare function dayOf(v: unknown): number | null;
+/** One condition as a test of a cell value. */
+export declare function compileCondition(c: FieldCondition, linkNames?: LinkNames, now?: Date): (value: unknown) => boolean;
+/** A whole filter as a row test; incomplete conditions are left out. Null when nothing filters. */
+export declare function compileFieldFilter<TRow>(filter: FieldFilter, getValue: (row: TRow, columnId: string) => unknown, linkNames?: LinkNames, now?: Date): ((row: TRow) => boolean) | null;
+/** One condition as words: "Status is Done", "Due date is before today". */
+export declare function describeCondition(c: FieldCondition, name?: (columnId: string) => string): string;
+/** A filter as words, groups in parentheses; incomplete conditions are left out. */
+export declare function describeFieldFilter(filter: FieldFilter, name?: (columnId: string) => string): string;
+/** The columns a filter's complete conditions read, each once. */
+export declare function fieldFilterColumns(filter: FieldFilter): string[];