@svgrid/enterprise 3.0.0 → 3.0.2

package/dist/sheet/workbook.js

@@ -0,0 +1,409 @@
+/**
+ * The workbook: several named sheets that can read each other.
+ *
+ * The engine already parsed `Orders!A1` and `'Price list'!A1:C9` from the day
+ * it was promoted, because demo 119 had them. What was missing is the thing
+ * those references point AT. This is that model, plus the recalculation that
+ * has to span sheets once they can.
+ *
+ * Cells hold raw text and nothing else. Everything derived - the computed
+ * value, the dependency edges, the display string - is recomputed from it, so
+ * there is exactly one copy of the truth and no way for a cached value to
+ * disagree with the formula above it.
+ */
+import { parseFormula } from './parse.js';
+import { evaluate, rangeValues } from './evaluate.js';
+import { withCustomFunctions } from './functions.js';
+import { isError } from './ast.js';
+import { createDependencyGraph, precedentsOf, cellKey } from './deps.js';
+import { createNames } from './names.js';
+import { fixupReferences, renameSheetReferences } from './refs.js';
+/** A name Excel would accept for a sheet. */
+export function isValidSheetName(name) {
+    if (name.trim() === '' || name.length > 31)
+        return false;
+    // Excel forbids these because they are the reference grammar.
+    return !/[:\\/?*[\]]/.test(name);
+}
+/** `Sheet1`, `Sheet2`, ... skipping any that already exist. */
+function nextSheetName(taken) {
+    const used = new Set(taken.map((n) => n.toLowerCase()));
+    for (let i = 1;; i += 1) {
+        const candidate = `Sheet${i}`;
+        if (!used.has(candidate.toLowerCase()))
+            return candidate;
+    }
+}
+export function createWorkbook(initial = [{ name: 'Sheet1', cells: [] }], options = {}) {
+    const order = [];
+    const byName = new Map();
+    const graph = createDependencyGraph();
+    const functions = withCustomFunctions(options.functions);
+    /** Computed values, keyed the same way the graph is. Rebuilt lazily and
+     *  invalidated by every write, so it can never hold a value whose formula
+     *  has since changed. */
+    const values = new Map();
+    /** Cells currently being resolved, for cycle detection. */
+    const visiting = new Set();
+    /** Parsed formulas, keyed by their TEXT rather than their position: a
+     *  column of =A1*2 filled down is one parse, not one per row. */
+    const astCache = new Map();
+    // Changing what a name refers to changes every formula that uses it, and
+    // the dependency graph only knows the CELLS a name pointed at when the
+    // formula was last evaluated. Dropping the cache is the honest answer:
+    // names change rarely, and a full recompute costs less than one stale total.
+    const names = (() => {
+        const inner = createNames();
+        const drop = () => { values.clear(); graph.clear(); };
+        return {
+            ...inner,
+            define: (name, refersTo) => { inner.define(name, refersTo); drop(); },
+            remove: (name) => { inner.remove(name); drop(); },
+            hydrate: (entries) => { inner.hydrate(entries); drop(); },
+            clear: () => { inner.clear(); drop(); },
+        };
+    })();
+    let active = '';
+    function sheetCells(name) {
+        return byName.get(name.toLowerCase());
+    }
+    /** Resolve a sheet reference. A null sheet means the one being evaluated,
+     *  which the resolver tracks as it descends. */
+    function resolveSheetName(sheet, self) {
+        return sheet ?? self;
+    }
+    function parseCached(text) {
+        if (astCache.has(text))
+            return astCache.get(text) ?? null;
+        let ast;
+        try {
+            ast = parseFormula(text);
+        }
+        catch {
+            ast = null;
+        }
+        astCache.set(text, ast);
+        return ast;
+    }
+    function contextFor(self, override) {
+        return {
+            resolve: (sheet, row, col) => {
+                const name = resolveSheetName(sheet, self);
+                // A validation rule reads the cell it is checking as the text being
+                // entered, which is not in the sheet yet; nothing else is overridden.
+                if (override && name === self && row === override.row && col === override.col)
+                    return literal(override.text);
+                return compute(name, row, col);
+            },
+            lastRow: (sheet) => Math.max(rowCount(resolveSheetName(sheet, self)) - 1, 0),
+            resolveNameNode: (name) => names.resolve(name),
+            functions,
+        };
+    }
+    function compute(sheet, row, col) {
+        const cells = sheetCells(sheet);
+        if (!cells)
+            return { error: '#REF!' };
+        if (row < 0 || col < 0)
+            return { error: '#REF!' };
+        // Anything past the written area is BLANK. A sheet has no size in this
+        // model beyond what has been typed into it, so there is no edge to fall
+        // off: =SUM(A1:A100) over a twelve-row sheet is an ordinary thing to
+        // write, and returning #REF! for the empty rows would poison the total.
+        //
+        // #REF! is reserved for the two cases that really are broken: a sheet
+        // that does not exist, and a negative index, which is what a reference
+        // shifted off the top by a delete becomes.
+        if (row >= cells.length || col >= (cells[row]?.length ?? 0))
+            return '';
+        const key = cellKey(sheet, row, col);
+        const cached = values.get(key);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(key))
+            return { error: '#CYCLE!' };
+        visiting.add(key);
+        const text = (cells[row]?.[col] ?? '').trim();
+        let value;
+        if (text === '') {
+            value = '';
+        }
+        else if (text.startsWith('=')) {
+            const ast = parseCached(text);
+            if (!ast)
+                value = { error: '#PARSE!' };
+            else {
+                value = evaluate(ast, contextFor(sheet));
+                graph.setPrecedents(key, precedentsOf(ast, { sheet }, (s) => Math.max(rowCount(s ?? sheet) - 1, 0), (name) => names.resolve(name)));
+            }
+        }
+        else {
+            const n = Number(text);
+            const upper = text.toUpperCase();
+            value = text !== '' && Number.isFinite(n) ? n
+                : upper === 'TRUE' ? true
+                    : upper === 'FALSE' ? false
+                        : text;
+        }
+        visiting.delete(key);
+        values.set(key, value);
+        return value;
+    }
+    /** What typed text is worth when it is not a formula: a number, a boolean or itself. */
+    function literal(text) {
+        const t = text.trim();
+        if (t === '')
+            return '';
+        if (t.startsWith('='))
+            return t;
+        const n = Number(t);
+        const upper = t.toUpperCase();
+        return Number.isFinite(n) ? n : upper === 'TRUE' ? true : upper === 'FALSE' ? false : t;
+    }
+    function rowCount(sheet) {
+        return sheetCells(sheet)?.length ?? 0;
+    }
+    function colCount(sheet) {
+        const cells = sheetCells(sheet);
+        if (!cells)
+            return 0;
+        return cells.reduce((max, row) => Math.max(max, row.length), 0);
+    }
+    /** Drop cached values for a cell and everything downstream of it. */
+    function invalidate(keys) {
+        const touched = [...keys];
+        for (const key of keys)
+            values.delete(key);
+        for (const key of graph.dirtyFrom(keys)) {
+            values.delete(key);
+            touched.push(key);
+        }
+        return touched;
+    }
+    function reportRecalc(keys) {
+        const cb = options.onRecalc;
+        if (!cb || keys.length === 0)
+            return;
+        cb(keys.map((key) => {
+            const gap = key.indexOf(' ');
+            const gap2 = key.indexOf(' ', gap + 1);
+            const row = Number(key.slice(0, gap));
+            const col = Number(key.slice(gap + 1, gap2));
+            const sheet = key.slice(gap2 + 1);
+            return { sheet, row, col, value: compute(sheet, row, col) };
+        }));
+    }
+    const workbook = {
+        get sheets() { return [...order]; },
+        get active() { return active; },
+        get names() { return names; },
+        setActive(name) {
+            if (sheetCells(name))
+                active = order.find((n) => n.toLowerCase() === name.toLowerCase()) ?? active;
+        },
+        addSheet(name, at) {
+            const chosen = name ?? nextSheetName(order);
+            if (!isValidSheetName(chosen)) {
+                throw new Error(`"${chosen}" is not a valid sheet name: it must be 1 to 31 characters and must not contain : \\ / ? * [ ]`);
+            }
+            if (sheetCells(chosen))
+                throw new Error(`a sheet named "${chosen}" already exists`);
+            byName.set(chosen.toLowerCase(), []);
+            const index = at === undefined ? order.length : Math.max(0, Math.min(at, order.length));
+            order.splice(index, 0, chosen);
+            active = chosen;
+            return chosen;
+        },
+        removeSheet(name) {
+            const index = order.findIndex((n) => n.toLowerCase() === name.toLowerCase());
+            // A workbook with no sheets has nowhere to put the cursor, and Excel
+            // refuses the same way.
+            if (index < 0 || order.length <= 1)
+                return false;
+            const [removed] = order.splice(index, 1);
+            byName.delete(removed.toLowerCase());
+            // Every cached value may have read the sheet that just went.
+            values.clear();
+            graph.clear();
+            if (active.toLowerCase() === removed.toLowerCase()) {
+                active = order[Math.min(index, order.length - 1)] ?? order[0];
+            }
+            return true;
+        },
+        renameSheet(from, to) {
+            const index = order.findIndex((n) => n.toLowerCase() === from.toLowerCase());
+            if (index < 0 || !isValidSheetName(to))
+                return false;
+            if (from.toLowerCase() !== to.toLowerCase() && sheetCells(to))
+                return false;
+            const cells = sheetCells(from);
+            byName.delete(from.toLowerCase());
+            byName.set(to.toLowerCase(), cells);
+            order[index] = to;
+            if (active.toLowerCase() === from.toLowerCase())
+                active = to;
+            // Every formula and name that pointed at the old name points at the
+            // new one, as in Excel; otherwise =Orders!B2 on Summary read #REF!
+            // the moment Orders became Sales. The rewrite goes through the parser,
+            // so a string literal holding the old name is not touched.
+            for (const [, sheet] of byName) {
+                for (const line of sheet) {
+                    for (let c = 0; c < line.length; c += 1) {
+                        const next = renameSheetReferences(line[c], from, to);
+                        if (typeof next === 'string')
+                            line[c] = next;
+                    }
+                }
+            }
+            for (const entry of names.list()) {
+                const next = renameSheetReferences(entry.refersTo, from, to);
+                if (typeof next === 'string' && next !== entry.refersTo)
+                    names.define(entry.name, next);
+            }
+            values.clear();
+            graph.clear();
+            return true;
+        },
+        moveSheet(name, to) {
+            const index = order.findIndex((n) => n.toLowerCase() === name.toLowerCase());
+            if (index < 0)
+                return false;
+            const [moved] = order.splice(index, 1);
+            order.splice(Math.max(0, Math.min(to, order.length)), 0, moved);
+            return true;
+        },
+        getRaw(sheet, row, col) {
+            return sheetCells(sheet)?.[row]?.[col] ?? '';
+        },
+        setRaw(sheet, row, col, text) {
+            const cells = sheetCells(sheet);
+            if (!cells || row < 0 || col < 0)
+                return;
+            while (cells.length <= row)
+                cells.push([]);
+            const line = cells[row];
+            while (line.length <= col)
+                line.push('');
+            if (line[col] === text)
+                return;
+            line[col] = text;
+            const key = cellKey(sheet, row, col);
+            // A cell that is no longer a formula reads nothing.
+            if (!text.trim().startsWith('='))
+                graph.setPrecedents(key, null);
+            reportRecalc(invalidate([key]));
+        },
+        getValue(sheet, row, col) {
+            return compute(sheet, row, col);
+        },
+        evaluateText(sheet, text, override) {
+            const t = text.trim();
+            if (t === '')
+                return '';
+            if (t.startsWith('=')) {
+                if (!sheetCells(sheet))
+                    return { error: '#REF!' };
+                const ast = parseCached(t);
+                return ast ? evaluate(ast, contextFor(sheet, override)) : { error: '#PARSE!' };
+            }
+            return literal(t);
+        },
+        evaluateRange(sheet, text) {
+            const t = text.trim();
+            if (!t.startsWith('=') || !sheetCells(sheet))
+                return null;
+            const ast = parseCached(t);
+            return ast ? rangeValues(ast, contextFor(sheet)) : null;
+        },
+        snapshot(sheet) {
+            const rows = rowCount(sheet);
+            const cols = colCount(sheet);
+            const out = [];
+            for (let r = 0; r < rows; r += 1) {
+                const line = [];
+                for (let c = 0; c < cols; c += 1)
+                    line.push(compute(sheet, r, c));
+                out.push(line);
+            }
+            return out;
+        },
+        applyStructuralEdit(sheet, edit) {
+            const target = sheetCells(sheet);
+            if (!target || edit.count <= 0)
+                return;
+            // Rewrite every formula in the WORKBOOK, not just this sheet: another
+            // sheet may hold =Orders!A5, and inserting a row in Orders has to move
+            // it exactly as if it were local.
+            for (const other of order) {
+                const cells = sheetCells(other);
+                for (let r = 0; r < cells.length; r += 1) {
+                    const line = cells[r];
+                    for (let c = 0; c < line.length; c += 1) {
+                        const text = line[c] ?? '';
+                        if (!text.startsWith('='))
+                            continue;
+                        // Only references INTO this sheet move: an unqualified one on
+                        // another sheet belongs to that sheet's geometry, which did not
+                        // change, and a reference on THIS sheet that names another sheet
+                        // belongs to that one. The scope tells the rewriter both.
+                        if (other !== sheet && !text.includes(`${sheet}!`) && !text.includes(`'${sheet}'!`))
+                            continue;
+                        const next = fixupReferences(text, edit, { sheet, self: other });
+                        if (typeof next === 'string')
+                            line[c] = next;
+                    }
+                }
+            }
+            // A name has no home sheet, so only one that names this sheet moves.
+            // NetSales = Orders!$I$2:$I$25 must not shift because a column went
+            // into Summary.
+            for (const entry of names.list()) {
+                const next = fixupReferences(entry.refersTo, edit, { sheet, self: null });
+                if (typeof next === 'string' && next !== entry.refersTo)
+                    names.define(entry.name, next);
+            }
+            const blankRow = () => [];
+            if (edit.kind === 'insertRows') {
+                target.splice(edit.at, 0, ...Array.from({ length: edit.count }, blankRow));
+            }
+            else if (edit.kind === 'deleteRows') {
+                target.splice(edit.at, edit.count);
+            }
+            else if (edit.kind === 'insertCols') {
+                for (const line of target) {
+                    if (line.length >= edit.at)
+                        line.splice(edit.at, 0, ...Array(edit.count).fill(''));
+                }
+            }
+            else {
+                for (const line of target) {
+                    if (line.length > edit.at)
+                        line.splice(edit.at, edit.count);
+                }
+            }
+            values.clear();
+            graph.clear();
+            astCache.clear();
+        },
+        recalculate() {
+            values.clear();
+            graph.clear();
+        },
+        rowCount,
+        colCount,
+        serialize() {
+            return {
+                sheets: order.map((name) => ({ name, cells: sheetCells(name).map((r) => [...r]) })),
+                active,
+                names: names.serialize(),
+            };
+        },
+    };
+    for (const sheet of initial.length > 0 ? initial : [{ name: 'Sheet1', cells: [] }]) {
+        byName.set(sheet.name.toLowerCase(), sheet.cells.map((r) => [...r]));
+        order.push(sheet.name);
+    }
+    active = order[0] ?? '';
+    return workbook;
+}
+export { isError };

package/dist/sheet-enable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Register the Excel keymap. Idempotent - safe to call from every component
+ * that wants it, or once at app start. Also invoked by {@link installEnterprise}
+ * so wiring the Pro API turns the shortcuts on too.
+ */
+export declare function enableSheet(): void;

package/dist/sheet-enable.js

@@ -0,0 +1,46 @@
+/**
+ * Excel keyboard commands (Pro). `enableSheet()` registers the sheet keymap
+ * with the grid, so Ctrl+Arrow jumps to the edge of a data region, Ctrl+D and
+ * Ctrl+R fill, Ctrl+A selects the current region, and the rest of the Excel
+ * muscle memory works on any `<SvGrid>` with cell selection on.
+ *
+ * The grid ships the `registerGridShortcuts` seam for free and interprets a key
+ * itself only when nothing claims it; the commands are here. Soft-gated like
+ * the rest of Enterprise: it works without a license key but the grid shows the
+ * unlicensed watermark and a one-time console nudge.
+ *
+ * ```ts
+ * import { setLicenseKey, enableSheet } from '@svgrid/enterprise'
+ * setLicenseKey('YOUR-KEY')
+ * enableSheet()
+ * // then: <SvGrid {data} {columns} enableCellSelection />
+ * ```
+ */
+// The Svelte-free subpath: importing the barrel would drag SvGrid.svelte into
+// this module's chunk, and into any unit test that touches it.
+import { registerGridShortcuts } from '@svgrid/grid/shortcuts';
+import { isLicenseKeySet } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
+import { handleSheetKey } from './sheet/shortcuts.js';
+import { setFillTranslator } from './sheet/commands.js';
+import { translateFormula } from './sheet/refs.js';
+let enabled = false;
+/**
+ * Register the Excel keymap. Idempotent - safe to call from every component
+ * that wants it, or once at app start. Also invoked by {@link installEnterprise}
+ * so wiring the Pro API turns the shortcuts on too.
+ */
+export function enableSheet() {
+    if (enabled)
+        return;
+    enabled = true;
+    // Priority 100 so the sheet keymap sits above anything an app registers of
+    // its own without asking for a priority.
+    registerGridShortcuts(handleSheetKey, { id: 'svgrid-sheet', priority: 100 });
+    // Teach fill about formulas. Without this Ctrl+D copies '=A1*2' down as
+    // literal text into every row; with it the relative half of each reference
+    // shifts and the absolute half does not, the way Excel fills.
+    setFillTranslator((value, delta) => translateFormula(value, delta.rows, delta.cols));
+    if (!isLicenseKeySet())
+        emitUnlicensedNudge();
+}

package/dist/sources/aggregate.d.ts

@@ -6,7 +6,7 @@
  * consumes either.
  */
 import type { RowData, ServerFilterModel } from '@svgrid/grid';
-import type { EntitySchema } from '../schema';
+import type { EntitySchema } from '../schema.js';
 export type AggregateReduce = 'sum' | 'avg' | 'count' | 'min' | 'max';
 export type AggregateRequest = {
     /**

package/dist/sources/auth-supabase.js

@@ -9,7 +9,7 @@
  *     await auth.signIn(email, password)
  *     // ... auth.signOut(); auth.dispose() on unmount
  */
-import { nudgeEnterprise } from '../license';
+import { nudgeEnterprise } from '../license.js';
 const userOf = (session) => session?.user ? { id: session.user.id, email: session.user.email } : null;
 export function createSupabaseAuth(config) {
     nudgeEnterprise('Studio'); // soft-gate; never blocks

package/dist/sources/dashboard.d.ts

@@ -7,8 +7,8 @@
  * / `getAggregate` seam), so nothing here re-implements aggregation.
  */
 import type { RowData } from '@svgrid/grid';
-import type { EntitySchema } from '../schema';
-import { type AggregateReduce } from './aggregate';
+import type { EntitySchema } from '../schema.js';
+import { type AggregateReduce } from './aggregate.js';
 import type { ChartType } from '@svgrid/grid';
 /** A single-number tile: reduce `measure` over the rows (count ignores measure). */
 export type KpiWidget = {

package/dist/sources/dashboard.js

@@ -1,4 +1,4 @@
-import { chartFieldsFromSchema } from './aggregate';
+import { chartFieldsFromSchema } from './aggregate.js';
 const num = (v) => {
     const n = Number(v);
     return Number.isFinite(n) ? n : 0;

package/dist/sources/index.d.ts

@@ -3,16 +3,16 @@
  * `ServerDataSource` over a specific backend, so the grid, edit form, sorting,
  * filtering, and paging work identically regardless of where the data lives.
  */
-export { normalizeFilters, type NormalizedFilter, type NormalizedPredicate } from './filters';
-export { buildEntitySchema, pickLabelField, linkRelationLabels, type IntrospectedColumn, type ColumnReference, } from './schema-from-columns';
-export { createSupabaseDataSource, type SupabaseDataSourceConfig, type SupabaseClientLike } from './supabase';
-export { createRestDataSource, type RestDataSourceConfig } from './rest';
-export { offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, type RestAdapter, type OffsetLimitOptions, } from './rest-adapters';
-export { introspectSupabaseTable, listSupabaseTables, type IntrospectSupabaseOptions } from './introspect-supabase';
-export { createSupabaseRealtime, type SupabaseRealtimeConfig, type SupabaseRealtimeClientLike, type SupabaseRealtimeHandle, type RealtimeChannelLike, type RealtimeChange, } from './realtime-supabase';
-export { createRelationLookup, type RelationLookup, type RelationLookupConfig, type RelationOption, } from './relation-lookup';
-export { createSupabaseAuth, type SupabaseAuthConfig, type SupabaseAuthController, type SupabaseAuthClientLike, type AuthState, type AuthUser, } from './auth-supabase';
-export { aggregateRows, chartFieldsFromSchema, type AggregateReduce, type AggregateRequest, type AggregateBucket, type AggregateSource, } from './aggregate';
-export { withEntityRules } from './with-entity-rules';
-export { withRelationLabels, type RelationLabelConfig } from './with-relation-labels';
-export { reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, type DashboardSpec, type DashboardWidget, type KpiWidget, type ChartWidget, } from './dashboard';
+export { normalizeFilters, type NormalizedFilter, type NormalizedPredicate } from './filters.js';
+export { buildEntitySchema, pickLabelField, linkRelationLabels, type IntrospectedColumn, type ColumnReference, } from './schema-from-columns.js';
+export { createSupabaseDataSource, type SupabaseDataSourceConfig, type SupabaseClientLike } from './supabase.js';
+export { createRestDataSource, type RestDataSourceConfig } from './rest.js';
+export { offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, type RestAdapter, type OffsetLimitOptions, } from './rest-adapters.js';
+export { introspectSupabaseTable, listSupabaseTables, type IntrospectSupabaseOptions } from './introspect-supabase.js';
+export { createSupabaseRealtime, type SupabaseRealtimeConfig, type SupabaseRealtimeClientLike, type SupabaseRealtimeHandle, type RealtimeChannelLike, type RealtimeChange, } from './realtime-supabase.js';
+export { createRelationLookup, type RelationLookup, type RelationLookupConfig, type RelationOption, } from './relation-lookup.js';
+export { createSupabaseAuth, type SupabaseAuthConfig, type SupabaseAuthController, type SupabaseAuthClientLike, type AuthState, type AuthUser, } from './auth-supabase.js';
+export { aggregateRows, chartFieldsFromSchema, type AggregateReduce, type AggregateRequest, type AggregateBucket, type AggregateSource, } from './aggregate.js';
+export { withEntityRules } from './with-entity-rules.js';
+export { withRelationLabels, type RelationLabelConfig } from './with-relation-labels.js';
+export { reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, type DashboardSpec, type DashboardWidget, type KpiWidget, type ChartWidget, } from './dashboard.js';

package/dist/sources/index.js

@@ -3,16 +3,16 @@
  * `ServerDataSource` over a specific backend, so the grid, edit form, sorting,
  * filtering, and paging work identically regardless of where the data lives.
  */
-export { normalizeFilters } from './filters';
-export { buildEntitySchema, pickLabelField, linkRelationLabels, } from './schema-from-columns';
-export { createSupabaseDataSource } from './supabase';
-export { createRestDataSource } from './rest';
-export { offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, } from './rest-adapters';
-export { introspectSupabaseTable, listSupabaseTables } from './introspect-supabase';
-export { createSupabaseRealtime, } from './realtime-supabase';
-export { createRelationLookup, } from './relation-lookup';
-export { createSupabaseAuth, } from './auth-supabase';
-export { aggregateRows, chartFieldsFromSchema, } from './aggregate';
-export { withEntityRules } from './with-entity-rules';
-export { withRelationLabels } from './with-relation-labels';
-export { reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, } from './dashboard';
+export { normalizeFilters } from './filters.js';
+export { buildEntitySchema, pickLabelField, linkRelationLabels, } from './schema-from-columns.js';
+export { createSupabaseDataSource } from './supabase.js';
+export { createRestDataSource } from './rest.js';
+export { offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, } from './rest-adapters.js';
+export { introspectSupabaseTable, listSupabaseTables } from './introspect-supabase.js';
+export { createSupabaseRealtime, } from './realtime-supabase.js';
+export { createRelationLookup, } from './relation-lookup.js';
+export { createSupabaseAuth, } from './auth-supabase.js';
+export { aggregateRows, chartFieldsFromSchema, } from './aggregate.js';
+export { withEntityRules } from './with-entity-rules.js';
+export { withRelationLabels } from './with-relation-labels.js';
+export { reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, } from './dashboard.js';

package/dist/sources/realtime-supabase.js

@@ -17,7 +17,7 @@
  * coalesce bursts into a single refetch. For per-row effects (e.g. flashing a
  * changed row) read the normalized event passed to `onChange`.
  */
-import { nudgeEnterprise } from '../license';
+import { nudgeEnterprise } from '../license.js';
 export function createSupabaseRealtime(config) {
     nudgeEnterprise('Studio'); // soft-gate; never blocks
     const schema = config.schema ?? 'public';

package/dist/sources/relation-lookup.d.ts

@@ -17,7 +17,7 @@
  * `companyId` relation field renders a searchable picker instead of a raw input.
  */
 import type { RowData, ServerDataSource } from '@svgrid/grid';
-import { type EntitySchema } from '../schema';
+import { type EntitySchema } from '../schema.js';
 export type RelationOption = {
     value: string;
     label: string;

package/dist/sources/relation-lookup.js

@@ -1,4 +1,4 @@
-import { resolveIdField } from '../schema';
+import { resolveIdField } from '../schema.js';
 export function createRelationLookup(config) {
     const pageSize = config.pageSize ?? 20;
     const valueField = config.valueField ?? (config.schema ? resolveIdField(config.schema) : 'id');

package/dist/sources/rest-adapters.d.ts

@@ -12,7 +12,7 @@
  * `jsonServerAdapter` are ready-made presets for two very common shapes.
  */
 import type { RowData } from '@svgrid/grid';
-import type { RestDataSourceConfig } from './rest';
+import type { RestDataSourceConfig } from './rest.js';
 /** The parts of a REST config that describe a backend's wire format. */
 export type RestAdapter<TData extends RowData> = Required<Pick<RestDataSourceConfig<TData>, 'buildQuery' | 'parse'>>;
 export type OffsetLimitOptions = {

package/dist/sources/rest-adapters.js

@@ -1,4 +1,4 @@
-import { normalizeFilters } from './filters';
+import { normalizeFilters } from './filters.js';
 const pick = (body, keys) => {
     const b = (body ?? {});
     for (const k of keys)

package/dist/sources/rest.d.ts

@@ -15,8 +15,8 @@
  * where `sort` is a comma list with `-` for descending (e.g. `-createdAt,name`).
  */
 import type { RowData, ServerRequest, ServerResult } from '@svgrid/grid';
-import { type EntitySchema } from '../schema';
-import type { WritableDataSource } from '../sveltekit/types';
+import { type EntitySchema } from '../schema.js';
+import type { WritableDataSource } from '../sveltekit/types.js';
 export type RestDataSourceConfig<TData extends RowData> = {
     /** Collection endpoint, e.g. `/api/customers`. */
     url: string;

package/dist/sources/rest.js

@@ -1,6 +1,6 @@
-import { resolveIdField } from '../schema';
-import { nudgeEnterprise } from '../license';
-import { normalizeFilters } from './filters';
+import { resolveIdField } from '../schema.js';
+import { nudgeEnterprise } from '../license.js';
+import { normalizeFilters } from './filters.js';
 const encodePredicate = (p) => {
     if (p.op === 'in')
         return `in:${p.values.join(',')}`;

package/dist/sources/supabase.d.ts

@@ -13,8 +13,8 @@
  * stripped from inserts (it's database-generated).
  */
 import type { RowData } from '@svgrid/grid';
-import { type EntitySchema } from '../schema';
-import type { WritableDataSource } from '../sveltekit/types';
+import { type EntitySchema } from '../schema.js';
+import type { WritableDataSource } from '../sveltekit/types.js';
 /** The slice of a `supabase-js` client this adapter needs. */
 export type SupabaseClientLike = {
     from(table: string): any;

package/dist/sources/supabase.js

@@ -1,6 +1,6 @@
-import { resolveIdField } from '../schema';
-import { nudgeEnterprise } from '../license';
-import { normalizeFilters } from './filters';
+import { resolveIdField } from '../schema.js';
+import { nudgeEnterprise } from '../license.js';
+import { normalizeFilters } from './filters.js';
 const sanitize = (term) => term.replace(/[%,()]/g, '');
 export function createSupabaseDataSource(config) {
     nudgeEnterprise('Studio'); // soft-gate; never blocks