bo-grid 0.1.0 → 0.7.0

package/dist/grid/pin.d.ts

@@ -1,13 +1,18 @@
 import type { ColumnDef } from './column';
+export type PinSide = 'left' | 'right';
 export interface PinInfo {
     pinned: boolean;
-    /** Sticky left offset (px) when pinned. */
+    /** Which edge the column is pinned to, or null when not pinned. */
+    side: PinSide | null;
+    /** Sticky `left` offset (px) when side === 'left'. */
     left: number;
+    /** Sticky `right` offset (px) when side === 'right'. */
+    right: number;
     /** Concrete width (px). */
     width: number;
 }
 export interface PinLayout {
-    /** Columns with pinned ones moved to the front. */
+    /** Columns reordered: left-pinned first, then unpinned, then right-pinned. */
     columns: ColumnDef[];
     info: PinInfo[];
     /** Sum of all column widths (the horizontally-scrollable content width). */
@@ -15,9 +20,8 @@ export interface PinLayout {
     anyPinned: boolean;
 }
 /**
- * Arrange columns for pinning: pinned-left columns move to the front, and each
- * gets a sticky `left` offset (cumulative width of the pinned columns before it).
- * When nothing is pinned, column order is untouched and the grid stays in its
- * default fit-to-width layout.
+ * Arrange columns for pinning: left-pinned columns move to the front, right-
+ * pinned to the end, each with a cumulative sticky offset from its edge. When
+ * nothing is pinned, column order is untouched and the grid stays fit-to-width.
  */
 export declare function arrangePinned(cols: readonly ColumnDef[]): PinLayout;

package/dist/grid/pin.js

@@ -1,24 +1,47 @@
 import { colWidth } from './column';
+function sideOf(c) {
+    if (c.pinned === 'right')
+        return 'right';
+    if (c.pinned)
+        return 'left'; // true | 'left'
+    return null;
+}
 /**
- * Arrange columns for pinning: pinned-left columns move to the front, and each
- * gets a sticky `left` offset (cumulative width of the pinned columns before it).
- * When nothing is pinned, column order is untouched and the grid stays in its
- * default fit-to-width layout.
+ * Arrange columns for pinning: left-pinned columns move to the front, right-
+ * pinned to the end, each with a cumulative sticky offset from its edge. When
+ * nothing is pinned, column order is untouched and the grid stays fit-to-width.
  */
 export function arrangePinned(cols) {
-    const pinned = cols.filter((c) => c.pinned);
-    const anyPinned = pinned.length > 0;
-    const columns = anyPinned ? [...pinned, ...cols.filter((c) => !c.pinned)] : [...cols];
+    const left = cols.filter((c) => sideOf(c) === 'left');
+    const right = cols.filter((c) => sideOf(c) === 'right');
+    const mid = cols.filter((c) => sideOf(c) === null);
+    const columns = left.length || right.length ? [...left, ...mid, ...right] : [...cols];
+    const anyPinned = left.length > 0 || right.length > 0;
+    const widths = columns.map(colWidth);
+    const totalWidth = widths.reduce((a, b) => a + b, 0);
+    const nLeft = left.length;
+    const nRight = right.length;
+    const firstRight = columns.length - nRight;
     const info = [];
-    let left = 0;
-    let totalWidth = 0;
+    let leftOff = 0;
     for (let i = 0; i < columns.length; i++) {
-        const width = colWidth(columns[i]);
-        const isPinned = anyPinned && i < pinned.length;
-        info.push({ pinned: isPinned, left: isPinned ? left : 0, width });
-        if (isPinned)
-            left += width;
-        totalWidth += width;
+        const width = widths[i];
+        if (i < nLeft) {
+            info.push({ pinned: true, side: 'left', left: leftOff, right: 0, width });
+            leftOff += width;
+        }
+        else if (i >= firstRight) {
+            info.push({ pinned: true, side: 'right', left: 0, right: 0, width }); // right filled below
+        }
+        else {
+            info.push({ pinned: false, side: null, left: 0, right: 0, width });
+        }
+    }
+    // Right offsets accumulate from the right edge inward.
+    let rightOff = 0;
+    for (let i = columns.length - 1; i >= firstRight; i--) {
+        info[i].right = rightOff;
+        rightOff += widths[i];
     }
     return { columns, info, totalWidth, anyPinned };
 }

package/dist/grid/sizing.d.ts

@@ -3,8 +3,8 @@ import type { ColumnDef } from './column';
 export declare const MIN_COL_WIDTH = 48;
 /** User width overrides, keyed by column `key` so they survive reorder/pin. */
 export type WidthMap = Record<string, number>;
-/** Clamp + round a proposed drag width to the minimum. */
-export declare function clampWidth(w: number): number;
+/** Clamp + round a proposed drag width to [min, max], never below MIN_COL_WIDTH. */
+export declare function clampWidth(w: number, min?: number, max?: number): number;
 /** Whether a column may be resized, given the grid-level toggle. */
 export declare function isResizable(col: ColumnDef, gridResizable: boolean): boolean;
 /**

package/dist/grid/sizing.js

@@ -1,8 +1,9 @@
 /** Smallest width (px) a column may be dragged to. */
 export const MIN_COL_WIDTH = 48;
-/** Clamp + round a proposed drag width to the minimum. */
-export function clampWidth(w) {
-    return Math.max(MIN_COL_WIDTH, Math.round(w));
+/** Clamp + round a proposed drag width to [min, max], never below MIN_COL_WIDTH. */
+export function clampWidth(w, min = MIN_COL_WIDTH, max = Infinity) {
+    const lo = Math.max(MIN_COL_WIDTH, min);
+    return Math.min(Math.max(Math.round(w), lo), Math.max(lo, max));
 }
 /** Whether a column may be resized, given the grid-level toggle. */
 export function isResizable(col, gridResizable) {

package/dist/grid/source.d.ts

@@ -1,4 +1,5 @@
 import type { GridRow, SortState } from './column';
+import { type ColumnFilter } from './filtering';
 export interface RowRange {
     /** First row index (inclusive). */
     start: number;
@@ -13,6 +14,8 @@ export interface RowSourceParams {
     /** Full sort order (primary first) for multi-column sort. May be empty. */
     sorts?: SortState[];
     filter: string;
+    /** Structured per-column filters (header filter menu), keyed by column key. */
+    columnFilters?: Record<string, ColumnFilter>;
 }
 export interface RowSourceResult {
     /** Rows for the requested range, in order. */

package/dist/grid/source.js

@@ -1,4 +1,5 @@
 import { compareBySorts } from './column';
+import { passesFilters } from './filtering';
 /**
  * Adapt an in-memory array to the RowSource interface — applies sort/filter and
  * slices the requested range. Useful as a real client-side adapter and for
@@ -12,6 +13,10 @@ export function createArraySource(all, opts = {}) {
         if (f && filterKeys && filterKeys.length > 0) {
             rows = rows.filter((r) => filterKeys.some((k) => String(r[k] ?? '').toLowerCase().includes(f)));
         }
+        const cf = params.columnFilters;
+        if (cf && Object.keys(cf).length > 0) {
+            rows = rows.filter((r) => passesFilters(r, cf));
+        }
         const sorts = params.sorts?.length ? params.sorts : params.sort ? [params.sort] : [];
         if (sorts.length > 0) {
             rows = [...rows].sort((a, b) => compareBySorts(a, b, sorts));

package/dist/grid/source.svelte.d.ts

@@ -1,5 +1,6 @@
 import type { GridRow, SortState } from './column';
 import type { RowRange, RowSource } from './source';
+import type { ColumnFilter } from './filtering';
 /**
  * Drives a RowSource for the grid: fetches the visible window, caches rows by
  * index, tracks the total, and guards against stale responses. Cache is keyed by
@@ -17,5 +18,5 @@ export declare class RowSourceController {
     constructor(source: RowSource);
     rowAt(index: number): GridRow | null;
     private keyOf;
-    fetch(range: RowRange, sorts: SortState[], filter: string): Promise<void>;
+    fetch(range: RowRange, sorts: SortState[], filter: string, columnFilters?: Record<string, ColumnFilter>): Promise<void>;
 }

package/dist/grid/source.svelte.js

@@ -18,11 +18,12 @@ export class RowSourceController {
     rowAt(index) {
         return this.cache.get(index) ?? null;
     }
-    keyOf(sorts, filter) {
-        return `${sorts.map((s) => `${s.key}:${s.dir}`).join(',')}|${filter}`;
+    keyOf(sorts, filter, columnFilters) {
+        const cf = columnFilters ? JSON.stringify(columnFilters) : '';
+        return `${sorts.map((s) => `${s.key}:${s.dir}`).join(',')}|${filter}|${cf}`;
     }
-    async fetch(range, sorts, filter) {
-        const key = this.keyOf(sorts, filter);
+    async fetch(range, sorts, filter, columnFilters) {
+        const key = this.keyOf(sorts, filter, columnFilters);
         if (key !== this.key) {
             this.key = key;
             this.cache.clear();
@@ -40,7 +41,7 @@ export class RowSourceController {
             return;
         const id = ++this.reqId;
         this.loading = true;
-        const res = await this.source.getRows({ range, sort: sorts[0] ?? null, sorts, filter });
+        const res = await this.source.getRows({ range, sort: sorts[0] ?? null, sorts, filter, columnFilters });
         if (id !== this.reqId)
             return; // a newer request superseded this one
         this.total = res.total;

package/dist/grid/tree.d.ts

@@ -0,0 +1,12 @@
+import type { GridRow } from './column';
+import type { VisualRow } from './grouping';
+/** Resolve a row's children (undefined/empty = leaf). */
+export type GetChildren = (row: GridRow) => GridRow[] | undefined;
+/**
+ * Flatten a tree of rows into the visible, depth-tagged data rows the grid
+ * renders. Pre-order DFS: each node is emitted, then — if it has children and
+ * `isExpanded` returns true — its children, one level deeper. Collapsed or leaf
+ * nodes contribute only themselves. Pure: no row values are read, so a realtime
+ * tick never rebuilds this list.
+ */
+export declare function buildTreeRows(roots: readonly GridRow[], getChildren: GetChildren, isExpanded: (row: GridRow) => boolean): VisualRow[];

package/dist/grid/tree.js

@@ -0,0 +1,21 @@
+/**
+ * Flatten a tree of rows into the visible, depth-tagged data rows the grid
+ * renders. Pre-order DFS: each node is emitted, then — if it has children and
+ * `isExpanded` returns true — its children, one level deeper. Collapsed or leaf
+ * nodes contribute only themselves. Pure: no row values are read, so a realtime
+ * tick never rebuilds this list.
+ */
+export function buildTreeRows(roots, getChildren, isExpanded) {
+    const out = [];
+    const walk = (nodes, depth) => {
+        for (const row of nodes) {
+            const children = getChildren(row);
+            const hasChildren = !!children && children.length > 0;
+            out.push({ kind: 'data', row, depth, hasChildren });
+            if (hasChildren && isExpanded(row))
+                walk(children, depth + 1);
+        }
+    };
+    walk(roots, 0);
+    return out;
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { default as Grid } from './grid/Grid.svelte';
 export { default as Sparkline } from './sparkline/Sparkline.svelte';
 export type { ColumnDef, Align, GridRow, SortDir, SortState, CellEditEvent } from './grid/column';
 export type { AggKind, AggResult } from './grid/aggregate';
+export type { ColumnFilter, FilterKind, TextOp, NumberOp, DateOp } from './grid/filtering';
 export { fmtPrice, fmtPercent, fmtVolume, fmtDate } from './format/format';
 export type { DateStyle } from './format/format';
 export { aggregate } from './grid/aggregate';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bo-grid",
-  "version": "0.1.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "MIT",
   "description": "Tiny, fast Svelte 5 data grid: canvas sparklines, batched realtime cell updates, and virtual scrolling. A free, fintech-focused alternative to heavyweight grids.",
@@ -59,6 +59,8 @@
     "size": "vite build && node scripts/size-check.mjs",
     "size:lib": "vite build --config vite.lib.config.ts && node scripts/size-lib.mjs",
     "smoke": "vite build --base=./ --outDir demo-dist && node scripts/smoke.mjs",
+    "ssr": "node scripts/ssr.mjs",
+    "bench": "node scripts/bench.mjs",
     "test": "vitest run",
     "release": "node scripts/release.mjs",
     "release:dry": "node scripts/release.mjs --dry-run"