@svgrid/grid 1.1.1 → 1.2.1

package/dist/hyperformula-adapter.test.js

@@ -1,205 +0,0 @@
-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/keyboard-handlers.coverage.test.d.ts

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