@svgrid/grid 1.0.2 → 1.1.1

package/dist/SvGridChart.svelte.d.ts

@@ -19,6 +19,23 @@ type Props = {
     formatValue?: (value: number) => string;
     /** Fired when a category / slice is clicked (drill into the grid). */
     onSelect?: (selection: ChartSelection) => void;
+    /** Like `onSelect`, but only fires when the spec carries `rowIds` and
+     *  includes them in the payload. Use this to filter / highlight the
+     *  source grid when the user clicks a chart element. */
+    onDrill?: (selection: ChartSelection) => void;
+    /** Allow drag-to-zoom on the plot area. Double-click resets.
+     *  Only meaningful for cartesian charts (not pie). Default false. */
+    zoomable?: boolean;
+    /** Show a compact brush / mini-map under the main chart. A draggable
+     *  window selects what the main chart shows. Pairs naturally with
+     *  `zoomable`. Default false. */
+    brush?: boolean;
+    /** Height of the brush strip in pixels. Default 88. */
+    brushHeight?: number;
+    /** Show a small toolbar above the chart: reset-zoom (when zoomed) and
+     *  export (PNG / SVG / copy). Default true when zoomable or onDrill is
+     *  set, otherwise false. Set to `false` to hide explicitly. */
+    toolbar?: boolean;
 };
 declare const SvGridChart: import("svelte").Component<Props, {}, "">;
 type SvGridChart = ReturnType<typeof SvGridChart>;

package/dist/aligned-grids.d.ts

@@ -0,0 +1,6 @@
+export declare function createAlignedGrids<TFeatures, TData>(ctx: any): {
+    register: () => () => void;
+    broadcastScroll: (left: number) => void;
+    broadcastWidths: () => void;
+    alignedGridId: number;
+};

package/dist/aligned-grids.js

@@ -0,0 +1,84 @@
+// Aligned grids - keep two or more independent grids in lockstep on horizontal
+// scroll and column widths. Grids that share the same `alignedGridGroup` string
+// register with a module-level registry (same pattern as managed row dragging);
+// when one scrolls horizontally or a column is resized, the others follow.
+//
+// Loop-safety without flags: scroll sync no-ops when the target already has the
+// value (so the echo scroll event never fires); width sync compares a serialized
+// snapshot and pre-seeds it on apply, so the reactive effect that fires after
+// applying a peer's widths sees "no change" and doesn't echo.
+// Shared across every grid in the bundle.
+const groups = new Map();
+let seq = 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function createAlignedGrids(ctx) {
+    const id = ++seq;
+    let lastWidthsSerial = "";
+    const group = () => ctx.props.alignedGridGroup ?? null;
+    function peers() {
+        const g = group();
+        if (!g)
+            return [];
+        const m = groups.get(g);
+        if (!m)
+            return [];
+        const out = [];
+        for (const member of m.values())
+            if (member.id !== id)
+                out.push(member);
+        return out;
+    }
+    const self = {
+        id,
+        applyScroll(left) {
+            const el = ctx.scrollContainer;
+            // Only set when it differs, so no echo scroll event fires -> no loop.
+            if (el && el.scrollLeft !== left)
+                el.scrollLeft = left;
+        },
+        applyWidths(widths) {
+            const merged = { ...ctx.columnWidths, ...widths };
+            // Pre-seed the serial so the columnWidths effect that fires after this
+            // set sees an unchanged snapshot and skips its own broadcast.
+            lastWidthsSerial = JSON.stringify(merged);
+            ctx.columnWidths = merged;
+        },
+    };
+    // Register on mount; returns the unregister for the effect's cleanup.
+    function register() {
+        const g = group();
+        if (!g)
+            return () => { };
+        let m = groups.get(g);
+        if (!m) {
+            m = new Map();
+            groups.set(g, m);
+        }
+        m.set(id, self);
+        return () => {
+            const mm = groups.get(g);
+            if (!mm)
+                return;
+            mm.delete(id);
+            if (!mm.size)
+                groups.delete(g);
+        };
+    }
+    function broadcastScroll(left) {
+        const p = peers();
+        for (const member of p)
+            member.applyScroll(left);
+    }
+    function broadcastWidths() {
+        if (!group())
+            return;
+        const serial = JSON.stringify(ctx.columnWidths ?? {});
+        if (serial === lastWidthsSerial)
+            return; // nothing new (or echo of an apply)
+        lastWidthsSerial = serial;
+        const w = ctx.columnWidths;
+        for (const member of peers())
+            member.applyWidths(w);
+    }
+    return { register, broadcastScroll, broadcastWidths, alignedGridId: id };
+}

package/dist/aligned-grids.test.d.ts

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

package/dist/aligned-grids.test.js

@@ -0,0 +1,75 @@
+/**
+ * Unit tests for aligned grids: two members sharing a group mirror horizontal
+ * scroll and column-resize widths to each other. Driven with minimal fake ctxs.
+ */
+import { describe, expect, it } from 'vitest';
+import { createAlignedGrids } from './aligned-grids';
+function makeCtx(group) {
+    return {
+        props: { alignedGridGroup: group },
+        scrollContainer: { scrollLeft: 0 },
+        columnWidths: {},
+    };
+}
+describe('aligned grids', () => {
+    it('mirrors horizontal scroll to peers in the same group', () => {
+        const a = makeCtx('g');
+        const b = makeCtx('g');
+        const ha = createAlignedGrids(a);
+        const hb = createAlignedGrids(b);
+        const un1 = ha.register();
+        const un2 = hb.register();
+        ha.broadcastScroll(240);
+        expect(b.scrollContainer.scrollLeft).toBe(240);
+        // and the other way
+        hb.broadcastScroll(80);
+        expect(a.scrollContainer.scrollLeft).toBe(80);
+        un1();
+        un2();
+    });
+    it('mirrors column-resize widths to peers (matched by column id)', () => {
+        const a = makeCtx('g');
+        const b = makeCtx('g');
+        const ha = createAlignedGrids(a);
+        const hb = createAlignedGrids(b);
+        ha.register();
+        hb.register();
+        a.columnWidths = { Feb: 180 };
+        ha.broadcastWidths();
+        expect(b.columnWidths.Feb).toBe(180);
+    });
+    it('does NOT mirror across different groups', () => {
+        const a = makeCtx('one');
+        const b = makeCtx('two');
+        const ha = createAlignedGrids(a);
+        const hb = createAlignedGrids(b);
+        ha.register();
+        hb.register();
+        ha.broadcastScroll(200);
+        expect(b.scrollContainer.scrollLeft).toBe(0);
+        a.columnWidths = { Feb: 999 };
+        ha.broadcastWidths();
+        expect(b.columnWidths.Feb).toBeUndefined();
+    });
+    it('is inert with no group set, and after unregister', () => {
+        const a = makeCtx(undefined);
+        const b = makeCtx(undefined);
+        const ha = createAlignedGrids(a);
+        const hb = createAlignedGrids(b);
+        ha.register();
+        hb.register();
+        ha.broadcastScroll(120);
+        expect(b.scrollContainer.scrollLeft).toBe(0);
+        // Grouped, then unregistered -> no longer receives updates.
+        const c = makeCtx('gg');
+        const d = makeCtx('gg');
+        const hc = createAlignedGrids(c);
+        const hd = createAlignedGrids(d);
+        const unc = hc.register();
+        const und = hd.register();
+        und(); // d leaves the group
+        hc.broadcastScroll(55);
+        expect(d.scrollContainer.scrollLeft).toBe(0);
+        unc();
+    });
+});

package/dist/build-api.coverage.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Coverage-focused behavioral tests for the SvGridApi assembled in
+ * `build-api.ts`. The existing `svgrid.api.test.ts` / `svgrid.api-extensions
+ * .test.ts` cover filters, row selection, pagination, navigation, and
+ * getState/setState. This file exercises the remaining surface:
+ *   - getCellValue / setCellValue
+ *   - selectCells / getSelected
+ *   - addRow(s) / removeRow(s) / applyTransaction
+ *   - addColumn(s) / removeColumn / setColumnVisible / getColumns
+ *   - setColumnWidth / setColumnPinning / setColumnOrder
+ *   - setFacetFilter
+ *   - undo / redo / canUndo / canRedo / clearHistory
+ *   - find (open/close/query/hits)
+ *   - grouping (setGroupBy / expandAllGroups / collapseAllGroups)
+ *   - autosizeColumn / refresh
+ *
+ * All tests mount the real <SvGrid /> in jsdom and drive the api handed back
+ * from onApiReady.
+ */
+export {};