@svgrid/grid 1.1.0 → 1.1.1

package/dist/hyperformula-adapter.test.js

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { createHyperFormulaSheet, } from './hyperformula-adapter';
+/**
+ * A tiny in-memory fake that emulates just the slice of the HyperFormula
+ * API the adapter touches: setCellContents / getCellValue / destroy.
+ *
+ * It stores raw cell contents in a Map keyed by "sheet:row:col" and
+ * evaluates `=A1+B1` style formulas with a deliberately small expression
+ * engine so we can assert the adapter wires reads/writes correctly without
+ * needing the real ~1MB hyperformula package.
+ */
+function makeFakeEngine() {
+    const raw = new Map();
+    const key = (s, r, c) => `${s}:${r}:${c}`;
+    // Resolve an A1 reference (e.g. "A1", "B2") to a cell value.
+    const colLetterToIndex = (letters) => {
+        let n = 0;
+        for (const ch of letters)
+            n = n * 26 + (ch.charCodeAt(0) - 64);
+        return n - 1;
+    };
+    function evalCell(sheet, row, col) {
+        const stored = raw.get(key(sheet, row, col));
+        if (typeof stored !== 'string' || !stored.startsWith('='))
+            return stored;
+        const expr = stored.slice(1);
+        // Replace A1-style refs with their numeric values.
+        const substituted = expr.replace(/([A-Z]+)(\d+)/g, (_m, letters, digits) => {
+            const refCol = colLetterToIndex(letters);
+            const refRow = Number(digits) - 1;
+            const v = evalCell(sheet, refRow, refCol);
+            return String(typeof v === 'number' ? v : 0);
+        });
+        try {
+            // Only ever digits / operators after substitution: safe to eval here.
+            // eslint-disable-next-line no-new-func
+            return Function(`"use strict";return (${substituted})`)();
+        }
+        catch {
+            return '#ERROR!';
+        }
+    }
+    const engine = {
+        setCellContents: vi.fn((cell, contents) => {
+            raw.set(key(cell.sheet, cell.row, cell.col), contents);
+            return [
+                {
+                    address: { sheet: cell.sheet, row: cell.row, col: cell.col },
+                    newValue: evalCell(cell.sheet, cell.row, cell.col),
+                },
+            ];
+        }),
+        getCellValue: vi.fn((cell) => evalCell(cell.sheet, cell.row, cell.col)),
+        destroy: vi.fn(() => { }),
+        rebuildAndRecalculate: vi.fn(() => { }),
+        // test-only introspection
+        _raw: raw,
+    };
+    return engine;
+}
+describe('createHyperFormulaSheet', () => {
+    let hf;
+    beforeEach(() => {
+        hf = makeFakeEngine();
+    });
+    it('seeds the engine with one setCellContents per cell in field order', () => {
+        const rows = [
+            { a: 1, b: 2 },
+            { a: 10, b: 20 },
+        ];
+        createHyperFormulaSheet({ hyperformula: hf, rows, fields: ['a', 'b'] });
+        // 2 rows x 2 fields = 4 seeded cells.
+        expect(hf.setCellContents).toHaveBeenCalledTimes(4);
+        // Field 'a' is column 0, field 'b' is column 1 (order = column index).
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 0, row: 0, col: 0 }, 1);
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 0, row: 1, col: 1 }, 20);
+    });
+    it('computed snapshot pulls evaluated values out of the engine', () => {
+        const rows = [{ a: 2, b: 3, total: '=A1+B1' }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b', 'total'],
+        });
+        expect(sheet.computed[0]).toEqual({ a: 2, b: 3, total: 5 });
+        // getCellValue called once per cell in the snapshot (3 fields).
+        expect(hf.getCellValue).toHaveBeenCalledTimes(3);
+    });
+    it('raw snapshot keeps the original formula strings untouched', () => {
+        const rows = [{ a: 2, b: 3, total: '=A1+B1' }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b', 'total'],
+        });
+        expect(sheet.raw[0].total).toBe('=A1+B1');
+        // raw is a copy, not the same object reference as the input row.
+        expect(sheet.raw[0]).not.toBe(rows[0]);
+    });
+    it('preserves non-formula fields not listed in `fields`', () => {
+        const rows = [{ a: 1, b: 2, name: 'keep-me' }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b'],
+        });
+        // `name` was never registered as a column but survives in computed.
+        expect(sheet.computed[0].name).toBe('keep-me');
+        expect(sheet.raw[0].name).toBe('keep-me');
+    });
+    it('update() writes the edited cell back and re-evaluates dependents', () => {
+        const rows = [{ a: 2, b: 3, total: '=A1+B1' }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b', 'total'],
+        });
+        expect(sheet.computed[0].total).toBe(5);
+        hf.setCellContents.mockClear();
+        const next = sheet.update(0, 'a', 100);
+        // The edited cell was pushed into the engine at its column index (a => col 0).
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 0, row: 0, col: 0 }, 100);
+        // Dependent formula recomputed from the engine.
+        expect(next.computed[0]).toEqual({ a: 100, b: 3, total: 103 });
+        // raw reflects the new edited literal but keeps the formula string.
+        expect(next.raw[0]).toEqual({ a: 100, b: 3, total: '=A1+B1' });
+    });
+    it('update() with an unregistered field skips the engine write but updates rows', () => {
+        const rows = [{ a: 1, b: 2, note: 'x' }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b'],
+        });
+        hf.setCellContents.mockClear();
+        const next = sheet.update(0, 'note', 'edited');
+        // `note` is not a registered column => no setCellContents call.
+        expect(hf.setCellContents).not.toHaveBeenCalled();
+        // But the raw/computed row still carries the new value.
+        expect(next.raw[0].note).toBe('edited');
+        expect(next.computed[0].note).toBe('edited');
+    });
+    it('respects a custom sheetId for every read and write', () => {
+        const rows = [{ a: 1 }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a'],
+            sheetId: 7,
+        });
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 7, row: 0, col: 0 }, 1);
+        expect(hf.getCellValue).toHaveBeenCalledWith({ sheet: 7, row: 0, col: 0 });
+        hf.setCellContents.mockClear();
+        sheet.update(0, 'a', 9);
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 7, row: 0, col: 0 }, 9);
+    });
+    it('defaults sheetId to 0 when omitted', () => {
+        createHyperFormulaSheet({ hyperformula: hf, rows: [{ a: 1 }], fields: ['a'] });
+        expect(hf.setCellContents).toHaveBeenCalledWith({ sheet: 0, row: 0, col: 0 }, 1);
+    });
+    it('handles an empty rows array without touching the engine', () => {
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows: [],
+            fields: ['a', 'b'],
+        });
+        expect(hf.setCellContents).not.toHaveBeenCalled();
+        expect(sheet.computed).toEqual([]);
+        expect(sheet.raw).toEqual([]);
+    });
+    it('cross-row formula references resolve through the engine', () => {
+        const rows = [
+            { a: 5 },
+            { a: 7 },
+            { a: '=A1+A2' },
+        ];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a'],
+        });
+        expect(sheet.computed[2].a).toBe(12);
+    });
+    it('destroy() tears down the underlying engine', () => {
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows: [{ a: 1 }],
+            fields: ['a'],
+        });
+        sheet.destroy();
+        expect(hf.destroy).toHaveBeenCalledTimes(1);
+    });
+    it('update() returns fresh array instances each call (no shared mutation)', () => {
+        const rows = [{ a: 1, b: 1 }];
+        const sheet = createHyperFormulaSheet({
+            hyperformula: hf,
+            rows,
+            fields: ['a', 'b'],
+        });
+        const first = sheet.update(0, 'a', 2);
+        const second = sheet.update(0, 'b', 3);
+        expect(first.computed).not.toBe(second.computed);
+        expect(second.computed[0]).toEqual({ a: 2, b: 3 });
+    });
+});

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { formatNumericWithConfig, resolveDatePattern } from './cell-formatting';
-export { columnFilteringFeature, columnGroupingFeature, createCoreRowModel, createExpandedRowModel, createFilteredRowModel, createGroupedRowModel, createPaginatedRowModel, createSortedRowModel, applyGroupAggregate, filterFns, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, sortFns, tableFeatures, type Cell, type CellContext, type EditorContext, type CellData, type ActiveCellState, type CellFormatConfig, type CellFormatter, type Column, type ColumnDef, type ColumnDefTemplate, type GroupAggregator, type Header, type HeaderContext, type HeaderGroup, type Row, type RowData, type SortingState, type SvGrid as SvGridInstance, type SvGridOptions, type TableFeatures, type Updater, } from './core';
+export { columnFilteringFeature, columnGroupingFeature, createCoreRowModel, createExpandedRowModel, createFilteredRowModel, createGroupedRowModel, createPaginatedRowModel, createSortedRowModel, applyGroupAggregate, filterFns, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, sortFns, tableFeatures, type Cell, type CellContext, type CellSpanParams, type ValueParserParams, type EditorContext, type CellData, type ActiveCellState, type CellFormatConfig, type CellFormatter, type Column, type ColumnDef, type ColumnDefTemplate, type GroupAggregator, type Header, type HeaderContext, type HeaderGroup, type Row, type RowData, type SortingState, type SvGrid as SvGridInstance, type SvGridOptions, type TableFeatures, type Updater, } from './core';
 export { createGrid, createSvGrid, type SvelteGrid } from './createGrid.svelte';
 export { createGridState, createSvGridState } from './createGridState.svelte';
 export { subscribeGrid, subscribeSvGrid } from './subscribe';
@@ -10,8 +10,11 @@ export { default as SvGridChart } from './SvGridChart.svelte';
 export { buildChart, rowsToChartSpec, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, type ChartType, type ChartSpec, type ChartSeries, type ChartGeometry, type ChartBar, type ChartLine, type ChartLinePoint, type ChartPieSlice, type ChartSelection, type ChartReferenceLine, type ChartRefLineGeo, type ChartRefLineGeoV, type ChartScatterDot, type ScatterPoint, type NiceScale, type SeriesOverlay, type SeriesPattern, type ChartAnnotation, type ChartHeatmapCell, type ChartFunnelSegment, type ChartRadarSeries, type ChartRadarAxis, type ChartTreemapCell, type ChartCalendarCell, type ChartGaugeLayout, type ChartSankeyNode, type ChartSankeyLink, type TreeNode, } from './chart';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, type ChartExportOptions, } from './chart-export';
 export { buildSparkline, toSparklineValues, type SparklineConfig, type SparklineType, type SparklineGeometry, } from './sparkline';
-export { spreadsheetLayout, type SpreadsheetActionOptions, type MergeSpec, type CellBorderSpec, type BorderSpec, } from './spreadsheet';
+export { spreadsheetLayout, spansToMerges, type SpanColumn, type SpreadsheetActionOptions, type MergeSpec, type CellBorderSpec, type BorderSpec, } from './spreadsheet';
 export { rowResize, type RowResizeOptions } from './row-resize';
+export { rowDropZone, type RowDragEndEvent, type RowDropZoneOptions } from './row-drag';
+export { resolveColumnTypes, inferCellDataType, type CellDataType } from './column-types';
+export { computeColumnGroupMeta, hiddenLeavesForCollapse, type ColumnGroupMeta, type ColumnGroupShow, } from './column-groups';
 export { createHyperFormulaSheet, type HyperFormulaSheet, type HyperFormulaSheetConfig, type HyperFormulaInstance, } from './hyperformula-adapter';
 export { createCollaboration, broadcastChannelTransport, type CollabUser, type CollabCell, type CollabPresence, type CollabMessage, type CollabTransport, type Collaboration, } from './collaboration';
 export { createServerDataSource, type ServerDataSource, type ServerRequest, type ServerResult, type ServerController, type ServerState, type ServerSortModel, type ServerFilterModel, } from './server-data-source';

package/dist/index.js

@@ -10,8 +10,11 @@ export { default as SvGridChart } from './SvGridChart.svelte';
 export { buildChart, rowsToChartSpec, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, } from './chart';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, } from './chart-export';
 export { buildSparkline, toSparklineValues, } from './sparkline';
-export { spreadsheetLayout, } from './spreadsheet';
+export { spreadsheetLayout, spansToMerges, } from './spreadsheet';
 export { rowResize } from './row-resize';
+export { rowDropZone } from './row-drag';
+export { resolveColumnTypes, inferCellDataType } from './column-types';
+export { computeColumnGroupMeta, hiddenLeavesForCollapse, } from './column-groups';
 export { createHyperFormulaSheet, } from './hyperformula-adapter';
 export { createCollaboration, broadcastChannelTransport, } from './collaboration';
 export { createServerDataSource, } from './server-data-source';

package/dist/keyboard-handlers.coverage.test.d.ts

@@ -0,0 +1 @@
+export {};