@svgrid/grid 1.0.0

package/dist/keyboard.js

@@ -0,0 +1,91 @@
+export function getKeyboardIntent(event) {
+    // Ctrl+Home / Ctrl+End come before plain Home / End so the modifier wins.
+    if (event.ctrlKey && event.key === 'Home')
+        return 'gridStart';
+    if (event.ctrlKey && event.key === 'End')
+        return 'gridEnd';
+    if (event.key === 'ArrowLeft')
+        return 'moveLeft';
+    if (event.key === 'ArrowRight')
+        return 'moveRight';
+    if (event.key === 'ArrowUp')
+        return 'moveUp';
+    if (event.key === 'ArrowDown')
+        return 'moveDown';
+    if (event.key === 'Home')
+        return 'rowStart';
+    if (event.key === 'End')
+        return 'rowEnd';
+    if (event.key === 'PageUp')
+        return 'pageUp';
+    if (event.key === 'PageDown')
+        return 'pageDown';
+    // Excel-style data-entry navigation:
+    //   Enter      → move down (Shift+Enter → up)
+    //   Tab        → move right (Shift+Tab → left), wraps at row boundaries
+    //   Delete     → clear contents of the selected cells
+    //   F2 / Space → start editing the active cell
+    if (event.key === 'Enter')
+        return event.shiftKey ? 'moveUp' : 'moveDown';
+    if (event.key === 'Tab')
+        return event.shiftKey ? 'tabPrev' : 'tabNext';
+    if (event.key === 'F2')
+        return 'activate';
+    if (event.key === ' ')
+        return 'activate';
+    if (event.key === 'Delete')
+        return 'clearCells';
+    return 'noop';
+}
+export function getNextActiveCell(current, intent, bounds) {
+    const pageSize = bounds.pageSize ?? 10;
+    let rowIndex = current.rowIndex;
+    let colIndex = current.colIndex;
+    if (intent === 'moveLeft')
+        colIndex -= 1;
+    if (intent === 'moveRight')
+        colIndex += 1;
+    if (intent === 'moveUp')
+        rowIndex -= 1;
+    if (intent === 'moveDown')
+        rowIndex += 1;
+    if (intent === 'tabNext') {
+        // Right one column; if we fall off the right edge, wrap to the
+        // first column of the next row - Excel's "data entry" behavior.
+        colIndex += 1;
+        if (colIndex > bounds.maxCol) {
+            colIndex = 0;
+            rowIndex += 1;
+        }
+    }
+    if (intent === 'tabPrev') {
+        colIndex -= 1;
+        if (colIndex < 0) {
+            colIndex = bounds.maxCol;
+            rowIndex -= 1;
+        }
+    }
+    if (intent === 'rowStart')
+        colIndex = 0;
+    if (intent === 'rowEnd')
+        colIndex = bounds.maxCol;
+    if (intent === 'gridStart') {
+        rowIndex = 0;
+        colIndex = 0;
+    }
+    if (intent === 'gridEnd') {
+        rowIndex = bounds.maxRow;
+        colIndex = bounds.maxCol;
+    }
+    if (intent === 'pageUp')
+        rowIndex -= pageSize;
+    if (intent === 'pageDown')
+        rowIndex += pageSize;
+    rowIndex = Math.min(Math.max(rowIndex, 0), Math.max(bounds.maxRow, 0));
+    colIndex = Math.min(Math.max(colIndex, 0), Math.max(bounds.maxCol, 0));
+    return {
+        rowIndex,
+        colIndex,
+        cellId: current.cellId,
+    };
+}

package/dist/keyboard.test.d.ts

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

package/dist/keyboard.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { getKeyboardIntent, getNextActiveCell } from './keyboard';
+describe('keyboard navigation engine', () => {
+    it('maps keys to navigation intents', () => {
+        expect(getKeyboardIntent(new KeyboardEvent('keydown', { key: 'ArrowLeft' }))).toBe('moveLeft');
+        expect(getKeyboardIntent(new KeyboardEvent('keydown', { key: 'Home', ctrlKey: true }))).toBe('gridStart');
+        expect(getKeyboardIntent(new KeyboardEvent('keydown', { key: ' ' }))).toBe('activate');
+    });
+    it('computes next active cell within bounds', () => {
+        const next = getNextActiveCell({ rowIndex: 1, colIndex: 1, cellId: null }, 'moveDown', { maxRow: 2, maxCol: 3, pageSize: 10 });
+        expect(next.rowIndex).toBe(2);
+        expect(next.colIndex).toBe(1);
+    });
+    it('handles row and grid boundary intents', () => {
+        const rowEnd = getNextActiveCell({ rowIndex: 2, colIndex: 1, cellId: null }, 'rowEnd', { maxRow: 2, maxCol: 4, pageSize: 2 });
+        expect(rowEnd.colIndex).toBe(4);
+        const gridStart = getNextActiveCell({ rowIndex: 2, colIndex: 4, cellId: null }, 'gridStart', { maxRow: 2, maxCol: 4, pageSize: 2 });
+        expect(gridStart.rowIndex).toBe(0);
+        expect(gridStart.colIndex).toBe(0);
+    });
+    it('clamps page navigation to valid bounds', () => {
+        const pageUp = getNextActiveCell({ rowIndex: 1, colIndex: 0, cellId: null }, 'pageUp', { maxRow: 20, maxCol: 2, pageSize: 10 });
+        const pageDown = getNextActiveCell({ rowIndex: 18, colIndex: 0, cellId: null }, 'pageDown', { maxRow: 20, maxCol: 2, pageSize: 10 });
+        expect(pageUp.rowIndex).toBe(0);
+        expect(pageDown.rowIndex).toBe(20);
+    });
+});

package/dist/merge-objects.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merges objects together while keeping their getters alive.
+ * Taken from SolidJS:
+ * https://github.com/solidjs/solid/blob/24abc825c0996fd2bc8c1de1491efe9a7e743aff/packages/solid/src/server/rendering.ts#L82-L115
+ */
+export declare function mergeObjects<T>(source: T): T;
+export declare function mergeObjects<T, U>(source: T, source1: U): T & U;
+export declare function mergeObjects<T, U, V>(source: T, source1: U, source2: V): T & U & V;
+export declare function mergeObjects<T, U, V, W>(source: T, source1: U, source2: V, source3: W): T & U & V & W;

package/dist/merge-objects.js

@@ -0,0 +1,28 @@
+export function mergeObjects(...sources) {
+    const target = {};
+    for (let source of sources) {
+        if (typeof source === 'function')
+            source = source();
+        if (source) {
+            const descriptors = Object.getOwnPropertyDescriptors(source);
+            for (const key in descriptors) {
+                if (key in target)
+                    continue;
+                Object.defineProperty(target, key, {
+                    enumerable: true,
+                    get() {
+                        for (let i = sources.length - 1; i >= 0; i--) {
+                            let scopedSource = sources[i];
+                            if (typeof scopedSource === 'function')
+                                scopedSource = scopedSource();
+                            const value = (scopedSource || {})[key];
+                            if (value !== undefined)
+                                return value;
+                        }
+                    },
+                });
+            }
+        }
+    }
+    return target;
+}

package/dist/named-views.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Named views. A thin, packaged manager on top of `api.getState()` /
+ * `api.setState()` so the "save / restore named layouts" feature every
+ * enterprise grid ships is one import instead of hand-rolled glue.
+ *
+ * Storage is pluggable: `localStorageViews(key)` persists per browser, or
+ * pass your own adapter to sync views to a server / per-user account. The
+ * manager itself is pure and synchronous, so it is trivially testable.
+ */
+import type { SvGridViewState } from './svgrid-wrapper.types';
+export type SavedView = {
+    name: string;
+    state: Partial<SvGridViewState>;
+    createdAt: number;
+};
+export type ViewStorage = {
+    read(): SavedView[];
+    write(views: SavedView[]): void;
+};
+/** Minimal grid handle the manager needs - `SvGridApi` satisfies it. */
+export type ViewStateHost = {
+    getState(): SvGridViewState;
+    setState(state: Partial<SvGridViewState>): void;
+};
+export type NamedViews = {
+    list(): SavedView[];
+    /** Capture the grid's current state under `name` (overwrites a duplicate). */
+    save(name: string): SavedView;
+    /** Apply a saved view to the grid. Returns false if the name is unknown. */
+    load(name: string): boolean;
+    /** Delete a saved view. Returns false if the name is unknown. */
+    remove(name: string): boolean;
+    rename(from: string, to: string): boolean;
+    has(name: string): boolean;
+};
+/** In-memory storage (default). State lives only as long as the manager. */
+export declare function memoryViews(initial?: SavedView[]): ViewStorage;
+/** localStorage-backed storage. Safe to construct in SSR (no-ops there). */
+export declare function localStorageViews(key: string): ViewStorage;
+export declare function createNamedViews(host: ViewStateHost, options?: {
+    storage?: ViewStorage;
+}): NamedViews;

package/dist/named-views.js

@@ -0,0 +1,80 @@
+/** In-memory storage (default). State lives only as long as the manager. */
+export function memoryViews(initial = []) {
+    let views = [...initial];
+    return {
+        read: () => views,
+        write: (next) => {
+            views = next;
+        },
+    };
+}
+/** localStorage-backed storage. Safe to construct in SSR (no-ops there). */
+export function localStorageViews(key) {
+    const available = typeof localStorage !== 'undefined';
+    return {
+        read() {
+            if (!available)
+                return [];
+            try {
+                const raw = localStorage.getItem(key);
+                const parsed = raw ? JSON.parse(raw) : [];
+                return Array.isArray(parsed) ? parsed : [];
+            }
+            catch {
+                return [];
+            }
+        },
+        write(views) {
+            if (!available)
+                return;
+            try {
+                localStorage.setItem(key, JSON.stringify(views));
+            }
+            catch {
+                /* quota / private mode - ignore */
+            }
+        },
+    };
+}
+export function createNamedViews(host, options = {}) {
+    const storage = options.storage ?? memoryViews();
+    const all = () => storage.read();
+    const find = (name) => all().find((v) => v.name === name);
+    return {
+        list: () => all().slice().sort((a, b) => a.createdAt - b.createdAt),
+        has: (name) => Boolean(find(name)),
+        save(name) {
+            const view = {
+                name,
+                state: host.getState(),
+                createdAt: find(name)?.createdAt ?? Date.now(),
+            };
+            storage.write([...all().filter((v) => v.name !== name), view]);
+            return view;
+        },
+        load(name) {
+            const view = find(name);
+            if (!view)
+                return false;
+            host.setState(view.state);
+            return true;
+        },
+        remove(name) {
+            const next = all().filter((v) => v.name !== name);
+            if (next.length === all().length)
+                return false;
+            storage.write(next);
+            return true;
+        },
+        rename(from, to) {
+            const view = find(from);
+            if (!view || find(to))
+                return false;
+            storage.write([
+                ...all().filter((v) => v.name !== from),
+                { ...view, name: to },
+            ]);
+            return true;
+        },
+    };
+}

package/dist/named-views.test.d.ts

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

package/dist/named-views.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createNamedViews, memoryViews } from './named-views';
+function fakeHost(initial = {}) {
+    let state = { sorting: [], columnFilters: [], ...initial };
+    return {
+        getState: () => state,
+        setState: vi.fn((s) => {
+            state = { ...state, ...s };
+        }),
+        _peek: () => state,
+    };
+}
+describe('createNamedViews', () => {
+    it('saves the current state and lists it', () => {
+        const host = fakeHost({ sorting: [{ id: 'name', desc: true }] });
+        const views = createNamedViews(host, { storage: memoryViews() });
+        views.save('By name');
+        expect(views.list().map((v) => v.name)).toEqual(['By name']);
+        expect(views.has('By name')).toBe(true);
+    });
+    it('load applies the saved state via setState', () => {
+        const host = fakeHost({ sorting: [{ id: 'age', desc: false }] });
+        const views = createNamedViews(host, { storage: memoryViews() });
+        views.save('snap');
+        host.setState({ sorting: [] }); // mutate away
+        host.setState.mockClear();
+        expect(views.load('snap')).toBe(true);
+        expect(host.setState).toHaveBeenCalledWith(expect.objectContaining({ sorting: [{ id: 'age', desc: false }] }));
+        expect(views.load('missing')).toBe(false);
+    });
+    it('save overwrites a duplicate name but keeps its createdAt', () => {
+        const host = fakeHost();
+        const views = createNamedViews(host, { storage: memoryViews() });
+        const a = views.save('v');
+        const b = views.save('v');
+        expect(views.list()).toHaveLength(1);
+        expect(b.createdAt).toBe(a.createdAt);
+    });
+    it('remove and rename', () => {
+        const host = fakeHost();
+        const views = createNamedViews(host, { storage: memoryViews() });
+        views.save('a');
+        views.save('b');
+        expect(views.rename('a', 'c')).toBe(true);
+        expect(views.rename('c', 'b')).toBe(false); // target exists
+        expect(views.remove('c')).toBe(true);
+        expect(views.remove('c')).toBe(false);
+        expect(views.list().map((v) => v.name)).toEqual(['b']);
+    });
+    it('persists through a storage adapter', () => {
+        const store = memoryViews();
+        createNamedViews(fakeHost({ sorting: [{ id: 'x', desc: true }] }), { storage: store }).save('keep');
+        // A fresh manager over the same storage sees it.
+        const reopened = createNamedViews(fakeHost(), { storage: store });
+        expect(reopened.has('keep')).toBe(true);
+    });
+});

package/dist/new-features.test.d.ts

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

package/dist/new-features.test.js

@@ -0,0 +1,183 @@
+/**
+ * Tests for the headless-engine features shipped alongside the wrapper
+ * additions (`getRowId`, the `between` filter operator). Wrapper-level
+ * additions are covered by the source-level smoke tests in
+ * `svgrid.new-features.wrapper.test.ts` - jsdom + Svelte 5 mount is
+ * brittle for tests that only need to confirm props are read.
+ */
+import { describe, expect, it } from 'vitest';
+import { columnFilteringFeature, createCoreRowModel, createSvGrid, rowSortingFeature, tableFeatures, } from './index';
+import { applyExcelFilter } from './filtering/excel-filters';
+const data = [
+    { id: 'ada', name: 'Ada Lovelace', age: 36 },
+    { id: 'linus', name: 'Linus Torvalds', age: 54 },
+    { id: 'grace', name: 'Grace Hopper', age: 85 },
+];
+const columns = [
+    { field: 'id', header: 'ID' },
+    { field: 'name', header: 'Name' },
+    { field: 'age', header: 'Age' },
+];
+const features = tableFeatures({ rowSortingFeature });
+describe('createSvGrid - getRowId', () => {
+    it('falls back to the array index as id when no getRowId is provided', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            columns,
+            data,
+        });
+        const rows = grid.getRowModel().rows;
+        expect(rows.map((r) => r.id)).toEqual(['0', '1', '2']);
+    });
+    it('uses the result of getRowId(row, index) as the row id', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            columns,
+            data,
+            getRowId: (row) => row.id,
+        });
+        const rows = grid.getRowModel().rows;
+        expect(rows.map((r) => r.id)).toEqual(['ada', 'linus', 'grace']);
+    });
+    it('passes the row index to getRowId', () => {
+        const seen = [];
+        createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            columns,
+            data,
+            getRowId: (row, index) => {
+                seen.push({ id: row.id, index });
+                return row.id;
+            },
+        }).getRowModel().rows;
+        expect(seen).toEqual([
+            { id: 'ada', index: 0 },
+            { id: 'linus', index: 1 },
+            { id: 'grace', index: 2 },
+        ]);
+    });
+    it('preserves the same id across `getRowModel()` invocations (stable identity)', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            columns,
+            data,
+            getRowId: (row) => `r:${row.id}`,
+        });
+        const first = grid.getRowModel().rows.map((r) => r.id);
+        const second = grid.getRowModel().rows.map((r) => r.id);
+        expect(first).toEqual(second);
+        expect(first).toEqual(['r:ada', 'r:linus', 'r:grace']);
+    });
+});
+describe('applyExcelFilter - between operator', () => {
+    it('returns true when the value is inside the inclusive range', () => {
+        expect(applyExcelFilter(50, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
+    });
+    it('is inclusive at the lower bound', () => {
+        expect(applyExcelFilter(18, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
+    });
+    it('is inclusive at the upper bound', () => {
+        expect(applyExcelFilter(65, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(true);
+    });
+    it('returns false when the value is below the range', () => {
+        expect(applyExcelFilter(17, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(false);
+    });
+    it('returns false when the value is above the range', () => {
+        expect(applyExcelFilter(66, { id: 'age', operator: 'between', value: 18, valueTo: 65 })).toBe(false);
+    });
+    it('parses string endpoints as numbers (the wrapper hands strings through)', () => {
+        expect(applyExcelFilter('30', { id: 'age', operator: 'between', value: '18', valueTo: '65' })).toBe(true);
+    });
+    it('works with ISO date strings via lexicographic compare', () => {
+        expect(applyExcelFilter('2026-06-15', {
+            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
+        })).toBe(true);
+        expect(applyExcelFilter('2025-12-31', {
+            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
+        })).toBe(false);
+        expect(applyExcelFilter('2027-01-01', {
+            id: 'd', operator: 'between', value: '2026-01-01', valueTo: '2026-12-31',
+        })).toBe(false);
+    });
+});
+describe('ColumnDef.sortable + ColumnDef.filterable', () => {
+    const features = tableFeatures({
+        rowSortingFeature,
+        columnFilteringFeature,
+    });
+    function columnsWith(opts) {
+        return [
+            { field: 'id', header: 'ID' },
+            { field: 'name', header: 'Name', sortable: opts.nameSortable, filterable: opts.nameFilterable },
+            { field: 'age', header: 'Age', sortable: opts.ageSortable },
+        ];
+    }
+    it('getCanSort() returns true by default when rowSortingFeature is on', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            data,
+            columns: columnsWith({}),
+        });
+        const name = grid.getAllColumns().find((c) => c.id === 'name');
+        expect(name?.getCanSort()).toBe(true);
+    });
+    it('getCanSort() returns false when columnDef.sortable === false', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            data,
+            columns: columnsWith({ nameSortable: false }),
+        });
+        const name = grid.getAllColumns().find((c) => c.id === 'name');
+        const age = grid.getAllColumns().find((c) => c.id === 'age');
+        expect(name?.getCanSort()).toBe(false);
+        expect(age?.getCanSort()).toBe(true);
+    });
+    it('getCanSort() still returns false even with sortable: true if the feature is OFF', () => {
+        const noSortFeatures = tableFeatures({ columnFilteringFeature });
+        const grid = createSvGrid({
+            _features: noSortFeatures,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            data,
+            columns: [
+                { field: 'name', header: 'Name', sortable: true },
+            ],
+        });
+        const name = grid.getAllColumns().find((c) => c.id === 'name');
+        expect(name?.getCanSort()).toBe(false);
+    });
+    it('getCanFilter() returns false when columnDef.filterable === false', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            data,
+            columns: columnsWith({ nameFilterable: false }),
+        });
+        const name = grid.getAllColumns().find((c) => c.id === 'name');
+        const age = grid.getAllColumns().find((c) => c.id === 'age');
+        expect(name?.getCanFilter()).toBe(false);
+        expect(age?.getCanFilter()).toBe(true);
+    });
+    it('sortable + filterable are independent', () => {
+        const grid = createSvGrid({
+            _features: features,
+            _rowModels: { coreRowModel: createCoreRowModel() },
+            data,
+            columns: [
+                { field: 'name', header: 'Name', sortable: false, filterable: true },
+                { field: 'age', header: 'Age', sortable: true, filterable: false },
+            ],
+        });
+        const name = grid.getAllColumns().find((c) => c.id === 'name');
+        const age = grid.getAllColumns().find((c) => c.id === 'age');
+        expect(name?.getCanSort()).toBe(false);
+        expect(name?.getCanFilter()).toBe(true);
+        expect(age?.getCanSort()).toBe(true);
+        expect(age?.getCanFilter()).toBe(false);
+    });
+});

package/dist/render-component.d.ts

@@ -0,0 +1,13 @@
+import type { Component, ComponentProps, Snippet } from 'svelte';
+export declare class RenderComponentConfig<TComponent extends Component> {
+    component: TComponent;
+    props?: (ComponentProps<TComponent> | Record<string, never>) | undefined;
+    constructor(component: TComponent, props?: (ComponentProps<TComponent> | Record<string, never>) | undefined);
+}
+export declare class RenderSnippetConfig<TProps> {
+    snippet: Snippet<[TProps]>;
+    params?: TProps | undefined;
+    constructor(snippet: Snippet<[TProps]>, params?: TProps | undefined);
+}
+export declare const renderComponent: <TComponent extends Component<any>, TProps extends ComponentProps<TComponent>>(component: TComponent, props?: TProps) => RenderComponentConfig<TComponent>;
+export declare const renderSnippet: <TProps>(snippet: Snippet<[TProps]>, params?: TProps) => RenderSnippetConfig<TProps>;

package/dist/render-component.js

@@ -0,0 +1,14 @@
+export class RenderComponentConfig {
+    constructor(component, props) {
+        this.component = component;
+        this.props = props;
+    }
+}
+export class RenderSnippetConfig {
+    constructor(snippet, params) {
+        this.snippet = snippet;
+        this.params = params;
+    }
+}
+export const renderComponent = (component, props) => new RenderComponentConfig(component, props);
+export const renderSnippet = (snippet, params) => new RenderSnippetConfig(snippet, params);

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

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

package/dist/render-component.test.js

@@ -0,0 +1,41 @@
+/**
+ * Unit tests for the renderComponent / renderSnippet factories.
+ */
+import { describe, expect, it } from 'vitest';
+import { RenderComponentConfig, RenderSnippetConfig, renderComponent, renderSnippet, } from './render-component';
+describe('renderComponent', () => {
+    it('returns a RenderComponentConfig instance', () => {
+        const FakeComponent = (() => null);
+        const config = renderComponent(FakeComponent);
+        expect(config).toBeInstanceOf(RenderComponentConfig);
+        expect(config.component).toBe(FakeComponent);
+        expect(config.props).toBeUndefined();
+    });
+    it('captures the props payload as-is', () => {
+        const FakeComponent = (() => null);
+        const config = renderComponent(FakeComponent, { id: 1, label: 'Hello' });
+        expect(config.props).toEqual({ id: 1, label: 'Hello' });
+    });
+    it('reuses the constructor instance fields', () => {
+        const FakeComponent = (() => null);
+        const a = renderComponent(FakeComponent, { x: 1 });
+        const b = renderComponent(FakeComponent, { x: 1 });
+        // Different instances - the factory does not memoize.
+        expect(a).not.toBe(b);
+        expect(a.component).toBe(b.component);
+    });
+});
+describe('renderSnippet', () => {
+    it('returns a RenderSnippetConfig instance with the captured snippet + params', () => {
+        const fakeSnippet = (() => null);
+        const config = renderSnippet(fakeSnippet, { value: 42 });
+        expect(config).toBeInstanceOf(RenderSnippetConfig);
+        expect(config.snippet).toBe(fakeSnippet);
+        expect(config.params).toEqual({ value: 42 });
+    });
+    it('allows an undefined params payload', () => {
+        const fakeSnippet = (() => null);
+        const config = renderSnippet(fakeSnippet);
+        expect(config.params).toBeUndefined();
+    });
+});