@svgrid/enterprise 3.0.1 → 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/studio/ui-components.generated.js

@@ -7021,11 +7021,34 @@ export const GENERATED_UI_SURFACE = {
                 "description": "Prepend a header row (the column labels) to copied cell ranges, so pasting into Excel / Sheets includes the headers. Applies per copied range.",
                 "group": "common"
             },
+            {
+                "key": "processCellForFill",
+                "label": "Process Cell For Fill",
+                "type": "json",
+                "description": "Decide what the fill handle writes into one cell, ahead of the grid's own pattern rules (series, weekdays, \"Item 1\"). Receives the source cell's value and how far the target sits from it; return the value to write, or `undefined` to let the pattern decide. A spreadsheet uses it to move a formula's references by the distance filled, which the pattern rules would otherwise mangle (\"=A1+B1\" reads as \"Item 1\").",
+                "code": true,
+                "group": "advanced"
+            },
             {
                 "key": "processCellForClipboard",
                 "label": "Process Cell For Clipboard",
                 "type": "json",
-                "description": "Transform each cell value on its way to the clipboard - e.g. strip currency symbols, expand codes to labels, or redact. Receives the display value plus the row/column context; return the string (or value) to copy.",
+                "code": true,
+                "group": "advanced"
+            },
+            {
+                "key": "clipboardHtml",
+                "label": "Clipboard Html",
+                "type": "json",
+                "description": "An HTML rendering of what Ctrl+C copies, written to the clipboard as `text/html` beside the TSV. Excel and Google Sheets read the HTML first, so a table with inline styles pastes into them with its formats, and the same markup can carry what the text cannot (a formula in a `data-` attribute) for a round trip back into a grid that reads it. Called after every cell has been through `processCellForClipboard`, with the rectangles copied and the text about to be written. Return nothing to write text alone. Runs synchronously inside the key press, which is what the clipboard needs.",
+                "code": true,
+                "group": "advanced"
+            },
+            {
+                "key": "processCellFromClipboard",
+                "label": "Process Cell From Clipboard",
+                "type": "json",
+                "description": "Transform each cell on its way IN from the clipboard, before the grid coerces it for the column's editor. Symmetric with `processCellForClipboard`: the pair is what lets a round trip survive. Receives the raw clipboard text for the cell plus where it is landing. Return the value to write, or `undefined` to leave the cell untouched. This is also the seam a feature pack uses to take over a paste entirely: `@svgrid/enterprise`'s paste-special reads the clipboard's `text/html` for formats and formulas and writes through here.",
                 "code": true,
                 "group": "advanced"
             },
@@ -7036,6 +7059,13 @@ export const GENERATED_UI_SURFACE = {
                 "description": "Inline cell editing: F2 or double-click opens an editor in the active cell, Enter commits, Esc cancels. Off by default. A column still needs an `editorType` to pick its editor (text, number, date, checkbox, list, ...); without one it gets a plain text editor. `editable` is the shortcut alias and wins over this.",
                 "group": "common"
             },
+            {
+                "key": "editOnSecondClick",
+                "label": "Edit On Second Click",
+                "type": "boolean",
+                "description": "A click on the cell that is already active opens its editor, the way a second click on a selected file name starts renaming it. On by default. A spreadsheet turns it off: Excel edits on double-click or F2 only, and a user clicking the cell they are on to get back to it after a dialog would otherwise find the next shortcut typed into an editor.",
+                "group": "common"
+            },
             {
                 "key": "fullRowEditing",
                 "label": "Full Row Editing",
@@ -7244,6 +7274,20 @@ export const GENERATED_UI_SURFACE = {
                 "description": "Rows to pin to the TOP of the grid - rendered above the regular rows and sticky-positioned so they stay visible while the user scrolls. Typical use: a \"totals\" or \"headline\" row that should always be in view. Rows are read-only (no inline editing, no row-selection checkbox). They share the column schema with the main grid; field/format/cell/cellClass all apply.",
                 "group": "common"
             },
+            {
+                "key": "frozenRows",
+                "label": "Frozen Rows",
+                "type": "number",
+                "description": "Freeze the first N rows: they stay under the header while the body scrolls, and unlike `pinnedTopRows` they are the grid's own rows, still editable, selectable and numbered as rows 1..N. Excel's Freeze Panes, for the row half; the column half is `columnPinning`. Under `virtualization` the frozen rows are always rendered and the window skips them.",
+                "group": "common"
+            },
+            {
+                "key": "mergedCells",
+                "label": "Merged Cells",
+                "type": "json",
+                "description": "Merged cells: rectangles drawn as one cell, a spreadsheet's Merge & Center. Each entry is the top-left cell (display indices) and how many rows and columns it covers. The origin's td takes the span and shows the origin's value; the covered cells are not drawn, a selection grows to whole merges, the active cell inside a merge is its origin, and the arrow keys step over a merge as one cell. A merge that crosses the frozen boundary or the rendered window is drawn in parts, one per band. The grid does not write into covered cells on its own; a consumer that merges cells keeps them empty or marks them read-only through the column's `editable`.",
+                "group": "common"
+            },
             {
                 "key": "pinnedBottomRows",
                 "label": "Pinned Bottom Rows",
@@ -7320,6 +7364,24 @@ export const GENERATED_UI_SURFACE = {
                 "prop": "onPaginationChange",
                 "description": "Fires when the user changes page or page size while `externalPagination` is on. Fetch that page and update `data` / `rowCount` / `pageIndex`."
             },
+            {
+                "key": "columnResize",
+                "label": "Column Resize",
+                "prop": "onColumnResize",
+                "description": "The user dragged a column's edge (or double-clicked it to autosize). Programmatic `api.setColumnWidth` does not fire it."
+            },
+            {
+                "key": "rowResize",
+                "label": "Row Resize",
+                "prop": "onRowResize",
+                "description": "The user dragged a row's edge, or double-clicked it: `height` is then `null`, the row back at its declared height. Programmatic `api.setRowHeight` does not fire it."
+            },
+            {
+                "key": "pasteClipboard",
+                "label": "Paste Clipboard",
+                "prop": "onPasteClipboard",
+                "description": "Take over a paste. Receives the clipboard's `text/plain` and, when the source put one there, its `text/html` (Excel's carries formats and formulas; a grid's own `clipboardHtml` carries whatever it chose to). Return `true` to say the paste was applied; anything else lets the grid paste the text as it always has. Runs inside one history group, so every `setCellValue` and `recordUndo` the handler makes is one Ctrl+Z. With this set, Ctrl+V lets the browser's own `paste` event through (that is where the unsanitised HTML is), and the async Clipboard API is the fallback for a browser that does not deliver it. `source` says which path the payload came by."
+            },
             {
                 "key": "apiReady",
                 "label": "Api Ready",

package/dist/version.d.ts

@@ -10,4 +10,4 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export declare const SVGRID_VERSION = "3.0.0";
+export declare const SVGRID_VERSION = "3.0.2";

package/dist/version.js

@@ -10,4 +10,4 @@
  *
  * `version.test.ts` asserts this matches `package.json`, so the two cannot drift.
  */
-export const SVGRID_VERSION = '3.0.0';
+export const SVGRID_VERSION = '3.0.2';

package/package.json

@@ -4,7 +4,7 @@
     "type": "commercial",
     "url": "https://svgrid.com/pricing"
   },
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "Enterprise feature pack for SvGrid: Excel (xlsx) and PDF export, Excel/CSV/JSON import, pivot tables with a drag-and-drop designer, paginated print, Kanban board and scheduler renderers, no-code alerts and batch editing. CSV, TSV and JSON export are already free in @svgrid/grid. Requires a paid license key.",
   "license": "SEE LICENSE IN LICENSE",
   "author": "jQWidgets <sales@jqwidgets.com>",
@@ -42,6 +42,11 @@
       "svelte": "./dist/pivot.js",
       "import": "./dist/pivot.js"
     },
+    "./sheet": {
+      "types": "./dist/sheet/index.d.ts",
+      "svelte": "./dist/sheet/index.js",
+      "import": "./dist/sheet/index.js"
+    },
     "./license": {
       "types": "./dist/license.d.ts",
       "svelte": "./dist/license.js",
@@ -73,7 +78,7 @@
     "jszip": "^3.10.0",
     "pdfmake": "^0.2.0",
     "svelte": "^5.0.0",
-    "@svgrid/grid": "^3.0.3"
+    "@svgrid/grid": "^3.0.4"
   },
   "peerDependenciesMeta": {
     "jszip": {
@@ -91,7 +96,7 @@
     "svelte": "^5.55.5",
     "typescript": "6.0.3",
     "vite": "^8.2.1",
-    "@svgrid/grid": "^3.0.3"
+    "@svgrid/grid": "^3.0.4"
   },
   "repository": {
     "type": "git",
@@ -122,7 +127,7 @@
     "test": "vitest run",
     "test:types": "tsc -p tsconfig.json --noEmit",
     "build": "svelte-package --input ./src --output ./dist && node ../../tools/strip-dist-tests.mjs ./dist && node ../../tools/add-dist-extensions.mjs ./dist && node ./scripts/build-cdn.mjs && node ./scripts/build-node.mjs && node ./scripts/build-designer.mjs",
-    "build:lib": "svelte-package --input ./src --output ./dist && node ../../tools/strip-dist-tests.mjs ./dist && node ../../tools/add-dist-extensions.mjs ./dist",
+    "build:lib": "svelte-package --input ./src --output ./dist && node ../../tools/strip-dist-tests.mjs ./dist && node ../../tools/add-dist-extensions.mjs ./dist && node ./scripts/build-node.mjs",
     "build:cdn": "node ./scripts/build-cdn.mjs",
     "build:node": "node ./scripts/build-node.mjs",
     "build:designer": "node ./scripts/build-designer.mjs",