@svgrid/grid 1.0.0

package/dist/filtering/excel-filters.test.js

@@ -0,0 +1,116 @@
+/**
+ * Unit tests for applyExcelFilter. Every operator + edge case.
+ */
+import { describe, expect, it } from 'vitest';
+import { applyExcelFilter } from './excel-filters';
+const make = (operator, value, valueTo) => ({
+    id: 'col',
+    operator,
+    value,
+    valueTo,
+});
+describe('applyExcelFilter - basic operators (smoke regression)', () => {
+    it('supports text operators (contains, startsWith, equals)', () => {
+        expect(applyExcelFilter('alphabet', make('contains', 'pha'))).toBe(true);
+        expect(applyExcelFilter('alphabet', make('startsWith', 'alp'))).toBe(true);
+        expect(applyExcelFilter('alphabet', make('equals', 'alphabet'))).toBe(true);
+    });
+    it('supports numeric operators (greaterThan, between)', () => {
+        expect(applyExcelFilter(15, make('greaterThan', 10))).toBe(true);
+        expect(applyExcelFilter(15, make('between', 10, 20))).toBe(true);
+    });
+    it('supports blank checks', () => {
+        expect(applyExcelFilter('', make('isBlank'))).toBe(true);
+        expect(applyExcelFilter('x', make('isBlank'))).toBe(false);
+    });
+});
+describe('applyExcelFilter - contains', () => {
+    it('matches case-insensitive substrings', () => {
+        expect(applyExcelFilter('Hello World', make('contains', 'world'))).toBe(true);
+        expect(applyExcelFilter('Hello World', make('contains', 'World'))).toBe(true);
+    });
+    it('returns false when substring absent', () => {
+        expect(applyExcelFilter('Hello', make('contains', 'xyz'))).toBe(false);
+    });
+    it('treats empty filter value as universal match', () => {
+        expect(applyExcelFilter('anything', make('contains', ''))).toBe(true);
+    });
+    it('coerces null cell to empty string', () => {
+        expect(applyExcelFilter(null, make('contains', 'x'))).toBe(false);
+        expect(applyExcelFilter(null, make('contains', ''))).toBe(true);
+    });
+});
+describe('applyExcelFilter - equals', () => {
+    it('matches case-insensitively', () => {
+        expect(applyExcelFilter('Boston', make('equals', 'boston'))).toBe(true);
+    });
+    it('rejects partial matches', () => {
+        expect(applyExcelFilter('Boston', make('equals', 'bost'))).toBe(false);
+    });
+    it('treats null as empty', () => {
+        expect(applyExcelFilter(null, make('equals', ''))).toBe(true);
+    });
+});
+describe('applyExcelFilter - startsWith', () => {
+    it('matches a prefix case-insensitively', () => {
+        expect(applyExcelFilter('Brooklyn', make('startsWith', 'brook'))).toBe(true);
+        expect(applyExcelFilter('Brooklyn', make('startsWith', 'lyn'))).toBe(false);
+    });
+});
+describe('applyExcelFilter - greaterThan', () => {
+    it('compares numerically when both sides parse as numbers', () => {
+        expect(applyExcelFilter(100, make('greaterThan', 99))).toBe(true);
+        expect(applyExcelFilter('100', make('greaterThan', 50))).toBe(true);
+        expect(applyExcelFilter(50, make('greaterThan', 50))).toBe(false);
+    });
+    it('falls back to string comparison when either side is non-numeric', () => {
+        expect(applyExcelFilter('banana', make('greaterThan', 'apple'))).toBe(true);
+        expect(applyExcelFilter('apple', make('greaterThan', 'banana'))).toBe(false);
+    });
+    it('treats null on either side as empty string in the fallback', () => {
+        expect(applyExcelFilter(null, make('greaterThan', 'a'))).toBe(false);
+        expect(applyExcelFilter('a', make('greaterThan', null))).toBe(true);
+    });
+});
+describe('applyExcelFilter - lessThan', () => {
+    it('compares numerically when both sides parse', () => {
+        expect(applyExcelFilter(10, make('lessThan', 20))).toBe(true);
+        expect(applyExcelFilter(20, make('lessThan', 10))).toBe(false);
+    });
+    it('falls back to string comparison', () => {
+        expect(applyExcelFilter('apple', make('lessThan', 'banana'))).toBe(true);
+    });
+    it('treats nulls as empty strings in fallback', () => {
+        expect(applyExcelFilter(null, make('lessThan', 'a'))).toBe(true);
+    });
+});
+describe('applyExcelFilter - between', () => {
+    it('includes both endpoints', () => {
+        expect(applyExcelFilter(5, make('between', 1, 10))).toBe(true);
+        expect(applyExcelFilter(1, make('between', 1, 10))).toBe(true);
+        expect(applyExcelFilter(10, make('between', 1, 10))).toBe(true);
+    });
+    it('excludes values outside the range', () => {
+        expect(applyExcelFilter(0, make('between', 1, 10))).toBe(false);
+        expect(applyExcelFilter(11, make('between', 1, 10))).toBe(false);
+    });
+    it('treats undefined endpoints as 0', () => {
+        expect(applyExcelFilter(0, make('between'))).toBe(true);
+        expect(applyExcelFilter(1, make('between'))).toBe(false);
+    });
+    it('treats null cell as 0', () => {
+        expect(applyExcelFilter(null, make('between', -1, 1))).toBe(true);
+    });
+});
+describe('applyExcelFilter - isBlank', () => {
+    it('matches null, undefined, and whitespace-only strings', () => {
+        expect(applyExcelFilter(null, make('isBlank'))).toBe(true);
+        expect(applyExcelFilter(undefined, make('isBlank'))).toBe(true);
+        expect(applyExcelFilter('', make('isBlank'))).toBe(true);
+        expect(applyExcelFilter('   ', make('isBlank'))).toBe(true);
+    });
+    it('rejects non-blank content', () => {
+        expect(applyExcelFilter('x', make('isBlank'))).toBe(false);
+        expect(applyExcelFilter(0, make('isBlank'))).toBe(false);
+    });
+});

package/dist/filtering/locale-filter.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Pure unit tests for the locale-aware text normalization + Excel
+ * filter pipeline. No DOM, no mounted grid - just the two exported
+ * helpers `normalizeForFilter` and `applyExcelFilter`.
+ *
+ * Covers:
+ *   - Diacritic stripping (Café → cafe)
+ *   - Composed / decomposed Unicode round-trip
+ *   - Locale-specific lowercasing (Turkish dotted-I)
+ *   - All Excel operators × locale option × accented inputs
+ *   - Edge cases: empty strings, null/undefined, numeric mixed with text
+ */
+export {};

package/dist/filtering/locale-filter.test.js

@@ -0,0 +1,189 @@
+/**
+ * Pure unit tests for the locale-aware text normalization + Excel
+ * filter pipeline. No DOM, no mounted grid - just the two exported
+ * helpers `normalizeForFilter` and `applyExcelFilter`.
+ *
+ * Covers:
+ *   - Diacritic stripping (Café → cafe)
+ *   - Composed / decomposed Unicode round-trip
+ *   - Locale-specific lowercasing (Turkish dotted-I)
+ *   - All Excel operators × locale option × accented inputs
+ *   - Edge cases: empty strings, null/undefined, numeric mixed with text
+ */
+import { describe, expect, it } from 'vitest';
+import { applyExcelFilter, normalizeForFilter, } from './excel-filters';
+describe('normalizeForFilter - diacritic stripping', () => {
+    it('strips Latin accents (NFD path)', () => {
+        expect(normalizeForFilter('Café')).toBe('cafe');
+        expect(normalizeForFilter('CAFÉ')).toBe('cafe');
+        expect(normalizeForFilter('München')).toBe('munchen');
+        expect(normalizeForFilter('São Paulo')).toBe('sao paulo');
+        expect(normalizeForFilter('Tōkyō')).toBe('tokyo');
+        expect(normalizeForFilter('Genève')).toBe('geneve');
+        expect(normalizeForFilter('Québec')).toBe('quebec');
+        expect(normalizeForFilter('Málaga')).toBe('malaga');
+        expect(normalizeForFilter('Brasília')).toBe('brasilia');
+    });
+    it('handles already-decomposed input (NFD-stable)', () => {
+        // "Café" composed (4 code points) vs decomposed (5 code points).
+        const composed = 'Café'.normalize('NFC');
+        const decomposed = 'Café'.normalize('NFD');
+        expect(normalizeForFilter(composed)).toBe('cafe');
+        expect(normalizeForFilter(decomposed)).toBe('cafe');
+    });
+    it('preserves base ASCII unchanged', () => {
+        expect(normalizeForFilter('Hello World')).toBe('hello world');
+        expect(normalizeForFilter('ABC-123')).toBe('abc-123');
+        expect(normalizeForFilter('email@example.com')).toBe('email@example.com');
+    });
+    it('returns empty string for empty / falsy input', () => {
+        expect(normalizeForFilter('')).toBe('');
+    });
+    it('keeps non-Latin alphabets intact', () => {
+        // The diacritic strip only touches the Combining Diacritical Marks
+        // block (U+0300..U+036F). CJK / Cyrillic / Arabic stay as-is.
+        expect(normalizeForFilter('東京')).toBe('東京');
+        expect(normalizeForFilter('Москва')).toBe('москва');
+        expect(normalizeForFilter('القاهرة')).toBe('القاهرة');
+    });
+});
+describe('normalizeForFilter - locale-aware lowercase', () => {
+    it('default (no locale) makes English "istanbul" match dotted Turkish "İstanbul"', () => {
+        // No locale: NFD decomposes İ → I + combining dot above; the dot is
+        // stripped; remaining 'I' becomes 'i' under default lowercase.
+        expect(normalizeForFilter('İstanbul')).toBe('istanbul');
+        expect(normalizeForFilter('istanbul')).toBe('istanbul');
+    });
+    it('Turkish locale honors dotted-I / dotless-i asymmetry', () => {
+        // With "tr-TR" the bare 'I' (post-dot-strip) lowercases to dotless
+        // 'ı'. This is intentional Turkish behavior and is why we expose a
+        // locale prop: consumers who explicitly want Turkish casing get it.
+        // English-typed "istanbul" then no longer matches Turkish "İstanbul"
+        // - locale-pickers should make that trade-off knowingly.
+        expect(normalizeForFilter('İSTANBUL', 'tr-TR')).toBe('ıstanbul');
+        expect(normalizeForFilter('I', 'tr-TR')).toBe('ı');
+    });
+    it('default (no locale) behaves like toLowerCase()', () => {
+        expect(normalizeForFilter('HELLO')).toBe('hello');
+        expect(normalizeForFilter('CafÉ')).toBe('cafe'); // É
+    });
+    it('accepts an array of fallback locales', () => {
+        expect(normalizeForFilter('Café', ['fr-CA', 'en-US'])).toBe('cafe');
+    });
+    it('Greek / Cyrillic / German all fold cleanly', () => {
+        // Greek: stripped tones (oxia)
+        expect(normalizeForFilter('Αθήνα')).toBe('αθηνα');
+        // German: umlauts strip
+        expect(normalizeForFilter('Düsseldorf')).toBe('dusseldorf');
+        // Cyrillic: no diacritics, just locale-aware lowercase
+        expect(normalizeForFilter('Москва', 'ru-RU')).toBe('москва');
+    });
+});
+describe('applyExcelFilter - contains (locale-aware)', () => {
+    it('matches case + accent insensitively without a locale', () => {
+        const ok = applyExcelFilter('Café Genève', {
+            id: 'name', operator: 'contains', value: 'cafe geneve',
+        });
+        expect(ok).toBe(true);
+    });
+    it('matches with a German locale', () => {
+        const ok = applyExcelFilter('München', {
+            id: 'city', operator: 'contains', value: 'munch',
+        }, { locale: 'de-DE' });
+        expect(ok).toBe(true);
+    });
+    it('matches with a French locale', () => {
+        const ok = applyExcelFilter('Montréal', {
+            id: 'city', operator: 'contains', value: 'montreal',
+        }, { locale: 'fr-CA' });
+        expect(ok).toBe(true);
+    });
+    it('matches with a Portuguese locale', () => {
+        const ok = applyExcelFilter('São Paulo', {
+            id: 'city', operator: 'contains', value: 'sao paulo',
+        }, { locale: 'pt-BR' });
+        expect(ok).toBe(true);
+    });
+    it('rejects non-matching queries even with locale', () => {
+        const ok = applyExcelFilter('München', {
+            id: 'city', operator: 'contains', value: 'berlin',
+        }, { locale: 'de-DE' });
+        expect(ok).toBe(false);
+    });
+    it('empty needle matches every cell (includes "")', () => {
+        expect(applyExcelFilter('München', {
+            id: 'city', operator: 'contains', value: '',
+        })).toBe(true);
+    });
+});
+describe('applyExcelFilter - equals (locale-aware)', () => {
+    it('case + accent insensitive equals', () => {
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'CAFE' })).toBe(true);
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafe' })).toBe(true);
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'Café' })).toBe(true);
+    });
+    it('rejects when normalized strings differ', () => {
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'cafes' })).toBe(false);
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'equals', value: 'café!' })).toBe(false);
+    });
+});
+describe('applyExcelFilter - startsWith (locale-aware)', () => {
+    it('matches stripped prefix', () => {
+        expect(applyExcelFilter('München-Schwabing', {
+            id: 'x', operator: 'startsWith', value: 'munchen',
+        })).toBe(true);
+    });
+    it('rejects mid-string match', () => {
+        expect(applyExcelFilter('Großmünchen', {
+            id: 'x', operator: 'startsWith', value: 'munchen',
+        })).toBe(false);
+    });
+});
+describe('applyExcelFilter - numeric operators (locale-independent)', () => {
+    it('greaterThan / lessThan / between still work', () => {
+        expect(applyExcelFilter(150, { id: 'price', operator: 'greaterThan', value: 100 })).toBe(true);
+        expect(applyExcelFilter(150, { id: 'price', operator: 'lessThan', value: 200 })).toBe(true);
+        expect(applyExcelFilter(150, {
+            id: 'price', operator: 'between', value: 100, valueTo: 200,
+        })).toBe(true);
+    });
+    it('between rejects out-of-range', () => {
+        expect(applyExcelFilter(50, {
+            id: 'price', operator: 'between', value: 100, valueTo: 200,
+        })).toBe(false);
+    });
+});
+describe('applyExcelFilter - isBlank', () => {
+    it('treats empty / whitespace-only as blank', () => {
+        expect(applyExcelFilter('', { id: 'x', operator: 'isBlank' })).toBe(true);
+        expect(applyExcelFilter('   ', { id: 'x', operator: 'isBlank' })).toBe(true);
+        expect(applyExcelFilter(null, { id: 'x', operator: 'isBlank' })).toBe(true);
+        expect(applyExcelFilter(undefined, { id: 'x', operator: 'isBlank' })).toBe(true);
+    });
+    it('rejects non-blank cells', () => {
+        expect(applyExcelFilter('Café', { id: 'x', operator: 'isBlank' })).toBe(false);
+        expect(applyExcelFilter(' x ', { id: 'x', operator: 'isBlank' })).toBe(false);
+    });
+});
+describe('applyExcelFilter - regression: pre-locale behavior preserved', () => {
+    // Before locale support, ASCII case-insensitive matching was the rule.
+    // Verify nothing regressed for the common path.
+    it('plain ASCII contains', () => {
+        expect(applyExcelFilter('Ada Lovelace', {
+            id: 'name', operator: 'contains', value: 'lovelace',
+        })).toBe(true);
+        expect(applyExcelFilter('Ada Lovelace', {
+            id: 'name', operator: 'contains', value: 'LOVELACE',
+        })).toBe(true);
+    });
+    it('plain ASCII equals', () => {
+        expect(applyExcelFilter('active', {
+            id: 'status', operator: 'equals', value: 'ACTIVE',
+        })).toBe(true);
+    });
+    it('plain ASCII startsWith', () => {
+        expect(applyExcelFilter('Linus Torvalds', {
+            id: 'name', operator: 'startsWith', value: 'linus',
+        })).toBe(true);
+    });
+});

package/dist/flex-render.d.ts

@@ -0,0 +1 @@
+export { default as FlexRender } from './FlexRender.svelte';

package/dist/flex-render.js

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+export { default as FlexRender } from './FlexRender.svelte';

package/dist/flex-render.test.d.ts

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

package/dist/flex-render.test.js

@@ -0,0 +1,142 @@
+/**
+ * FlexRender tests. The component routes one of {content+context, cell,
+ * header, footer} into the right render path: string, RenderComponentConfig,
+ * RenderSnippetConfig, or raw value.
+ */
+import { describe, expect, it } from 'vitest';
+import { mount, unmount } from 'svelte';
+import FlexRender from './FlexRender.svelte';
+import { RenderComponentConfig, RenderSnippetConfig } from './render-component';
+function mountFlex(props) {
+    const target = document.createElement('div');
+    document.body.appendChild(target);
+    const app = mount(FlexRender, { target, props });
+    return {
+        target,
+        destroy: () => {
+            unmount(app);
+            target.remove();
+        },
+    };
+}
+describe('FlexRender', () => {
+    it('renders a plain string content directly', () => {
+        const { target, destroy } = mountFlex({
+            content: 'Hello header',
+            context: { column: {}, table: {} },
+        });
+        try {
+            expect(target.textContent).toContain('Hello header');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('calls a function content with the context and renders the result', () => {
+        const fn = (ctx) => `value=${ctx.value}`;
+        const { target, destroy } = mountFlex({
+            content: fn,
+            context: { value: 42 },
+        });
+        try {
+            expect(target.textContent).toContain('value=42');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('renders nothing when content is undefined', () => {
+        const { target, destroy } = mountFlex({
+            content: undefined,
+            context: {},
+        });
+        try {
+            expect(target.textContent?.trim()).toBe('');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('pulls content + context from `cell` when provided', () => {
+        const cell = {
+            column: { columnDef: { cell: (ctx) => `row=${ctx.row.id}` } },
+            getContext: () => ({ row: { id: 7 } }),
+        };
+        const { target, destroy } = mountFlex({ cell });
+        try {
+            expect(target.textContent).toContain('row=7');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('pulls content + context from `header` when provided', () => {
+        const header = {
+            column: { columnDef: { header: 'Total' } },
+            getContext: () => ({}),
+        };
+        const { target, destroy } = mountFlex({ header });
+        try {
+            expect(target.textContent).toContain('Total');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('pulls content + context from `footer` when provided', () => {
+        const footer = {
+            column: { columnDef: { footer: 'Sum' } },
+            getContext: () => ({}),
+        };
+        const { target, destroy } = mountFlex({ footer });
+        try {
+            expect(target.textContent).toContain('Sum');
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('renders a RenderComponentConfig result (smoke)', () => {
+        // Anonymous Svelte-like component would require compilation; we just
+        // exercise the constructor path so the discriminator branch executes.
+        const fn = () => new RenderComponentConfig(null, {});
+        const { destroy } = mountFlex({
+            content: fn,
+            context: {},
+        });
+        try {
+            // No throw means the discriminator was hit.
+            expect(true).toBe(true);
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('renders a RenderSnippetConfig result (smoke)', () => {
+        const fakeSnippet = (() => null);
+        const fn = () => new RenderSnippetConfig(fakeSnippet, undefined);
+        const { destroy } = mountFlex({
+            content: fn,
+            context: {},
+        });
+        try {
+            expect(true).toBe(true);
+        }
+        finally {
+            destroy();
+        }
+    });
+    it('renders a raw scalar value when the function returns one', () => {
+        const fn = () => 99;
+        const { target, destroy } = mountFlex({
+            content: fn,
+            context: {},
+        });
+        try {
+            expect(target.textContent).toContain('99');
+        }
+        finally {
+            destroy();
+        }
+    });
+});

package/dist/group-aggregate.test.d.ts

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

package/dist/group-aggregate.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { applyGroupAggregate } from './core';
+// Minimal Row stubs - applyGroupAggregate only touches getCellValueByColumnId
+// and original.
+function rows(values) {
+    return values.map((v) => ({
+        original: { v, cat: 'x' },
+        getCellValueByColumnId: (id) => (id === 'v' ? v : 'x'),
+    }));
+}
+describe('applyGroupAggregate', () => {
+    const r = rows([10, 20, 30]);
+    it('sum / avg / min / max', () => {
+        expect(applyGroupAggregate('sum', 'v', r)).toBe(60);
+        expect(applyGroupAggregate('avg', 'v', r)).toBe(20);
+        expect(applyGroupAggregate('min', 'v', r)).toBe(10);
+        expect(applyGroupAggregate('max', 'v', r)).toBe(30);
+    });
+    it('count / countDistinct / first / extent', () => {
+        expect(applyGroupAggregate('count', 'v', r)).toBe(3);
+        expect(applyGroupAggregate('countDistinct', 'cat', r)).toBe(1);
+        expect(applyGroupAggregate('first', 'v', r)).toBe(10);
+        expect(applyGroupAggregate('extent', 'v', r)).toBe('10 – 30');
+    });
+    it('custom function receives numeric values + rows', () => {
+        const median = applyGroupAggregate((vals) => vals.sort((a, b) => a - b)[Math.floor(vals.length / 2)], 'v', r);
+        expect(median).toBe(20);
+    });
+    it('numeric reducers ignore non-numeric and empty groups', () => {
+        expect(applyGroupAggregate('sum', 'v', rows([]))).toBeUndefined();
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+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 { createGrid, createSvGrid, type SvelteGrid } from './createGrid.svelte';
+export { createGridState, createSvGridState } from './createGridState.svelte';
+export { subscribeGrid, subscribeSvGrid } from './subscribe';
+export { default as SvGrid } from './SvGrid.svelte';
+export { default as FlexRender } from './FlexRender.svelte';
+export { renderComponent, renderSnippet } from './render-component';
+export { default as SvGridChart } from './SvGridChart.svelte';
+export { buildChart, rowsToChartSpec, niceScale, 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, } from './chart';
+export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, type ChartExportOptions, } from './chart-export';
+export { buildSparkline, toSparklineValues, type SparklineConfig, type SparklineType, type SparklineGeometry, } from './sparkline';
+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';
+export { createNamedViews, memoryViews, localStorageViews, type SavedView, type ViewStorage, type NamedViews, } from './named-views';
+export { resolveCellFormat, computeColumnStat, lerpColor, contrastText, type ConditionalFormat, type ConditionalFormatSpec, type ColorScaleFormat, type DataBarFormat, type IconSetFormat, type RuleFormat, type ResolvedCellFormat, } from './conditional-formatting';
+export { getKeyboardIntent, getNextActiveCell, type GridKeyboardIntent } from './keyboard';
+export { createVirtualizer } from './virtualization/virtualizer';
+export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte';
+export { createColumnVirtualizer } from './virtualization/column-virtualizer';
+export type { VirtualItem, VirtualizerOptions, VirtualizerState } from './virtualization/types';
+export type { SvGridApi, SvGridFilterOperator, SvGridWrapperProps } from './svgrid-wrapper.types';
+export { parseEditorValue, normalizeEditorOptions, type CellEditorType, type CellEditorOption, } from './editors/cell-editors';
+export { applyExcelFilter, normalizeForFilter, type ExcelFilter, type ExcelFilterOperator, type ExcelFilterOptions, } from './filtering/excel-filters';
+export { getGridCellDomId, getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, type GridCellA11yInput, type GridColumnA11yInput, type GridSortDirection, } from './a11y';
+/**
+ * Compatibility alias for teams migrating from `createTable`.
+ */
+export { createSvGrid as createTable } from './createGrid.svelte';

package/dist/index.js

@@ -0,0 +1,27 @@
+export { formatNumericWithConfig, resolveDatePattern } from './cell-formatting';
+export { columnFilteringFeature, columnGroupingFeature, createCoreRowModel, createExpandedRowModel, createFilteredRowModel, createGroupedRowModel, createPaginatedRowModel, createSortedRowModel, applyGroupAggregate, filterFns, rowExpandingFeature, rowPaginationFeature, rowSelectionFeature, rowSortingFeature, sortFns, tableFeatures, } from './core';
+export { createGrid, createSvGrid } from './createGrid.svelte';
+export { createGridState, createSvGridState } from './createGridState.svelte';
+export { subscribeGrid, subscribeSvGrid } from './subscribe';
+export { default as SvGrid } from './SvGrid.svelte';
+export { default as FlexRender } from './FlexRender.svelte';
+export { renderComponent, renderSnippet } from './render-component';
+export { default as SvGridChart } from './SvGridChart.svelte';
+export { buildChart, rowsToChartSpec, niceScale, DEFAULT_PALETTE, } from './chart';
+export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, } from './chart-export';
+export { buildSparkline, toSparklineValues, } from './sparkline';
+export { createCollaboration, broadcastChannelTransport, } from './collaboration';
+export { createServerDataSource, } from './server-data-source';
+export { createNamedViews, memoryViews, localStorageViews, } from './named-views';
+export { resolveCellFormat, computeColumnStat, lerpColor, contrastText, } from './conditional-formatting';
+export { getKeyboardIntent, getNextActiveCell } from './keyboard';
+export { createVirtualizer } from './virtualization/virtualizer';
+export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte';
+export { createColumnVirtualizer } from './virtualization/column-virtualizer';
+export { parseEditorValue, normalizeEditorOptions, } from './editors/cell-editors';
+export { applyExcelFilter, normalizeForFilter, } from './filtering/excel-filters';
+export { getGridCellDomId, getGridCellA11yProps, getGridHeaderA11yProps, getGridRootA11yProps, getGridRowA11yProps, } from './a11y';
+/**
+ * Compatibility alias for teams migrating from `createTable`.
+ */
+export { createSvGrid as createTable } from './createGrid.svelte';

package/dist/keyboard.d.ts

@@ -0,0 +1,8 @@
+import type { ActiveCellState } from './core';
+export type GridKeyboardIntent = 'moveLeft' | 'moveRight' | 'moveUp' | 'moveDown' | 'tabNext' | 'tabPrev' | 'rowStart' | 'rowEnd' | 'gridStart' | 'gridEnd' | 'pageUp' | 'pageDown' | 'activate' | 'clearCells' | 'noop';
+export declare function getKeyboardIntent(event: KeyboardEvent): GridKeyboardIntent;
+export declare function getNextActiveCell(current: ActiveCellState, intent: GridKeyboardIntent, bounds: {
+    maxRow: number;
+    maxCol: number;
+    pageSize?: number;
+}): ActiveCellState;