@svgrid/grid 3.0.4 → 3.0.5

package/dist/SvRowGroupPanel.svelte

@@ -1,186 +0,0 @@
-<!--
-  A row-group panel (like the "drag columns to group" bar in enterprise grids).
-  Shows the current group-by columns as chips you can remove or drag to reorder,
-  plus a "+ Group by" menu to add one. It is also a drop target: a column drag
-  that carries `text/sv-column` (its column id) adds that column. Wire `onChange`
-  to a server group model's `setGroupBy`, or to client grouping.
-
-      <SvRowGroupPanel
-        columns={[{ id: 'region', label: 'Region' }, { id: 'country', label: 'Country' }]}
-        groupBy={view.groupBy}
-        onChange={(g) => ctl.setGroupBy(g)}
-      />
--->
-<script lang="ts">
-  import { GRID_ICON_GLYPHS, type GridIconName, type GridIcons } from './grid-icons'
-
-  type Col = { id: string; label: string }
-  type Props = {
-    /** Columns that can be grouped on. */
-    columns: Col[]
-    /** Current group-by column ids, outer to inner. */
-    groupBy: string[]
-    /** Called with the new group-by order. */
-    onChange: (groupBy: string[]) => void
-    /** Text shown when nothing is grouped. */
-    placeholder?: string
-    /**
-     * Icon overrides, the same map `<SvGrid icons>` takes. This panel draws
-     * `drag-handle`, `remove` and `breadcrumb-separator`. You mount it
-     * yourself, so pass the same object you gave the grid to keep them
-     * consistent.
-     */
-    icons?: GridIcons
-  }
-  let { columns, groupBy, onChange, placeholder = 'Drag a column here to group by it', icons }: Props = $props()
-
-  const labelOf = (id: string) => columns.find((c) => c.id === id)?.label ?? id
-  const available = $derived(columns.filter((c) => !groupBy.includes(c.id)))
-
-  let dragIndex = $state<number | null>(null)
-
-  function remove(id: string) {
-    onChange(groupBy.filter((g) => g !== id))
-  }
-  function add(id: string) {
-    if (id && !groupBy.includes(id)) onChange([...groupBy, id])
-  }
-  function reorder(to: number) {
-    if (dragIndex === null || dragIndex === to) return
-    const next = [...groupBy]
-    const [moved] = next.splice(dragIndex, 1)
-    next.splice(to, 0, moved!)
-    dragIndex = null
-    onChange(next)
-  }
-  function onPanelDrop(e: DragEvent) {
-    const id = e.dataTransfer?.getData('text/sv-column')
-    if (id) add(id)
-  }
-  /** Keyboard equivalent of dragging a chip: moves the chip at `i` one slot earlier/later,
-   *  reusing `reorder()` (via `dragIndex`) so there is a single source of truth for the move. */
-  function moveByKeyboard(i: number, delta: number) {
-    const to = i + delta
-    if (to < 0 || to >= groupBy.length) return
-    dragIndex = i
-    reorder(to)
-  }
-  function onChipKeydown(e: KeyboardEvent, i: number) {
-    if (!e.altKey) return
-    if (e.key === 'ArrowLeft') {
-      e.preventDefault()
-      moveByKeyboard(i, -1)
-    } else if (e.key === 'ArrowRight') {
-      e.preventDefault()
-      moveByKeyboard(i, 1)
-    }
-  }
-</script>
-
-<!-- Same override-or-default resolution SvGrid uses, kept local because this
-     component is mounted by the consumer and never sees the grid's snippet. -->
-{#snippet ic(name: GridIconName)}
-  {@const override = icons?.[name]}
-  {#if override}{@render override()}{:else}{GRID_ICON_GLYPHS[name]}{/if}
-{/snippet}
-
-<div
-  class="sv-rowgroup-panel"
-  role="group"
-  aria-label="Row groups"
-  ondragover={(e) => e.preventDefault()}
-  ondrop={onPanelDrop}
->
-  <span class="sv-rgp-label" aria-hidden="true">Group by:</span>
-  {#if groupBy.length === 0}
-    <span class="sv-rgp-empty">{placeholder}</span>
-  {:else}
-    {#each groupBy as id, i (id)}
-      {#if i > 0}<span class="sv-rgp-sep" aria-hidden="true">{@render ic('breadcrumb-separator')}</span>{/if}
-      <!-- svelte-ignore a11y_no_noninteractive_tabindex, a11y_no_noninteractive_element_interactions -->
-      <span
-        class="sv-rgp-chip"
-        class:sv-rgp-chip-drag={dragIndex === i}
-        role="group"
-        tabindex="0"
-        aria-label={`Grouped by ${labelOf(id)}, position ${i + 1} of ${groupBy.length}. Press Alt+Arrow keys to reorder.`}
-        draggable="true"
-        ondragstart={() => (dragIndex = i)}
-        ondragend={() => (dragIndex = null)}
-        ondragover={(e) => e.preventDefault()}
-        ondrop={() => reorder(i)}
-        onkeydown={(e) => onChipKeydown(e, i)}
-      >
-        <span class="sv-rgp-grip" aria-hidden="true">{@render ic('drag-handle')}</span>
-        {labelOf(id)}
-        <button type="button" class="sv-rgp-x" onclick={() => remove(id)} aria-label={`Stop grouping by ${labelOf(id)}`}>{@render ic('remove')}</button>
-      </span>
-    {/each}
-  {/if}
-  {#if available.length}
-    <select
-      class="sv-rgp-add"
-      aria-label="Add a group column"
-      onchange={(e) => { add(e.currentTarget.value); e.currentTarget.value = '' }}
-    >
-      <option value="">+ Group by</option>
-      {#each available as c (c.id)}<option value={c.id}>{c.label}</option>{/each}
-    </select>
-  {/if}
-</div>
-
-<style>
-  .sv-rowgroup-panel {
-    display: flex;
-    align-items: center;
-    flex-wrap: wrap;
-    gap: 6px;
-    padding: 8px 10px;
-    border: 1px dashed var(--sg-border, #cbd5e1);
-    border-radius: 10px;
-    background: var(--sg-header-bg, #f8fafc);
-    font-size: 13px;
-  }
-  .sv-rgp-label { color: var(--sg-muted, #64748b); font-weight: 600; }
-  .sv-rgp-empty { color: var(--sg-muted, #94a3b8); font-style: italic; }
-  .sv-rgp-sep { color: var(--sg-muted, #94a3b8); }
-  .sv-rgp-chip {
-    display: inline-flex;
-    align-items: center;
-    gap: 6px;
-    padding: 3px 6px 3px 8px;
-    border-radius: 999px;
-    background: var(--sg-bg, #fff);
-    border: 1px solid var(--sg-border, #e2e8f0);
-    cursor: grab;
-    user-select: none;
-    font-weight: 600;
-  }
-  .sv-rgp-chip-drag { opacity: 0.5; }
-  .sv-rgp-grip { color: var(--sg-muted, #94a3b8); cursor: grab; }
-  .sv-rgp-x {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    width: 16px;
-    height: 16px;
-    border: 0;
-    border-radius: 50%;
-    background: none;
-    color: var(--sg-muted, #64748b);
-    cursor: pointer;
-    font-size: 14px;
-    line-height: 1;
-  }
-  .sv-rgp-x:hover { background: var(--sg-header-bg, #f1f5f9); color: var(--sg-fg, #0f172a); }
-  .sv-rgp-add {
-    font: inherit;
-    font-size: 13px;
-    padding: 4px 8px;
-    border-radius: 8px;
-    border: 1px solid var(--sg-border, #e2e8f0);
-    background: var(--sg-bg, #fff);
-    color: var(--sg-accent, #2563eb);
-    cursor: pointer;
-  }
-</style>

package/dist/SvRowGroupPanel.svelte.d.ts

@@ -1,25 +0,0 @@
-import { type GridIcons } from './grid-icons.js';
-type Col = {
-    id: string;
-    label: string;
-};
-type Props = {
-    /** Columns that can be grouped on. */
-    columns: Col[];
-    /** Current group-by column ids, outer to inner. */
-    groupBy: string[];
-    /** Called with the new group-by order. */
-    onChange: (groupBy: string[]) => void;
-    /** Text shown when nothing is grouped. */
-    placeholder?: string;
-    /**
-     * Icon overrides, the same map `<SvGrid icons>` takes. This panel draws
-     * `drag-handle`, `remove` and `breadcrumb-separator`. You mount it
-     * yourself, so pass the same object you gave the grid to keep them
-     * consistent.
-     */
-    icons?: GridIcons;
-};
-declare const SvRowGroupPanel: import("svelte").Component<Props, {}, "">;
-type SvRowGroupPanel = ReturnType<typeof SvRowGroupPanel>;
-export default SvRowGroupPanel;

package/dist/cdn/validate-_CDJzgIo.js

@@ -1,75 +0,0 @@
-//#region src/validate.ts
-var e = "https://svgrid.com/docs/getting-started/3-data-and-columns/";
-function t(e, n = []) {
-	for (let r of e) r.columns?.length ? t(r.columns, n) : n.push(r);
-	return n;
-}
-function n(n) {
-	let i = [], a = t(n.columns ?? []), o = (n.data ?? []).slice(0, 10);
-	if (o.length) {
-		let t = /* @__PURE__ */ new Set();
-		for (let e of o) if (e && typeof e == "object") for (let n of Object.keys(e)) t.add(n);
-		for (let n of a) {
-			let a = n.field;
-			if (!a || n.fieldFn || t.has(a)) continue;
-			let o = r(a, [...t]);
-			i.push(`[svgrid] Column field "${a}" does not exist on your row data, so that column renders empty.${o ? ` Did you mean "${o}"?` : ""} Available keys: ${[...t].slice(0, 12).join(", ")}. See ${e}`);
-		}
-	}
-	let s = /* @__PURE__ */ new Map();
-	for (let e of a) {
-		let t = e.id ?? e.field;
-		t && s.set(t, (s.get(t) ?? 0) + 1);
-	}
-	for (let [t, n] of s) n > 1 && i.push(`[svgrid] ${n} columns share the id "${t}". Column state (sorting, filtering, pinning, width) is keyed by id, so they will act as one. Give each an explicit \`id\`. See ${e}`);
-	let c = n.pageable === void 0 && n.showPagination === void 0;
-	n.pageSize !== void 0 && c && i.push("[svgrid] `pageSize` is set but pagination was never turned on, so it has no effect and every row renders. Add `pageable` to switch the pager on."), !(n.sortable === !0 || n.features?.rowSortingFeature) && a.some((e) => e.sortable === !0) && i.push("[svgrid] A column sets `sortable: true`, but sorting is not enabled on the grid, so its header does nothing. Add `sortable` to <SvGrid> (it registers the sorting feature for you).");
-	let l = /* @__PURE__ */ new Set();
-	for (let e of a) {
-		let t = e.id ?? e.field;
-		t && l.add(t);
-	}
-	for (let e of n.groupBy ?? []) {
-		if (l.has(e)) continue;
-		let t = r(e, [...l]);
-		i.push(`[svgrid] \`groupBy\` refers to column "${e}", which does not exist, so that grouping level is ignored.${t ? ` Did you mean "${t}"?` : ""} Column ids: ${[...l].slice(0, 12).join(", ")}`);
-	}
-	let u = n.treeData?.column;
-	if (u && !l.has(u) && i.push(`[svgrid] \`treeData.column\` refers to column "${u}", which does not exist, so the expander falls back to the first visible column.`), o.length && n.treeData) {
-		let e = /* @__PURE__ */ new Set();
-		for (let t of o) if (t && typeof t == "object") for (let n of Object.keys(t)) e.add(n);
-		let t = n.treeData.parentField;
-		if (t && !e.has(t)) {
-			let n = r(t, [...e]);
-			i.push(`[svgrid] \`treeData.parentField\` is "${t}", which is not on your row data, so every row becomes a root and no hierarchy appears.${n ? ` Did you mean "${n}"?` : ""}`);
-		}
-		let a = n.treeData.idField;
-		a && !e.has(a) && i.push(`[svgrid] \`treeData.idField\` is "${a}", which is not on your row data, so parent lookups cannot match and the tree stays flat.`);
-	}
-	return (n.initialColumnPinning?.left?.length ?? 0) + (n.initialColumnPinning?.right?.length ?? 0) > 0 && n.columnVirtualization !== !1 && i.push("[svgrid] `initialColumnPinning` is set while column virtualization is on (its default), so the pinned columns will not stick - the virtualizer recycles column nodes. Add `columnVirtualization={false}`."), n.externalPagination === !0 && n.rowCount === void 0 && i.push("[svgrid] `externalPagination` is on but `rowCount` is not set, so the pager cannot know how many pages exist. Pass the server total as `rowCount`."), n.externalSort === !0 && !n.onSortingChange && i.push("[svgrid] `externalSort` is on but there is no `onSortingChange` handler, so clicking a header changes nothing - the grid stopped sorting and nobody is listening. Add `onSortingChange` and re-fetch in your handler."), n.externalFilter === !0 && !n.onFiltersChange && i.push("[svgrid] `externalFilter` is on but there is no `onFiltersChange` handler, so filtering the grid changes nothing. Add `onFiltersChange` and re-fetch in your handler."), i;
-}
-function r(e, t) {
-	let n, r = Infinity;
-	for (let a of t) {
-		let t = i(e.toLowerCase(), a.toLowerCase());
-		t < r && (r = t, n = a);
-	}
-	let a = Math.min(3, Math.floor(e.length / 3) + 1);
-	return r <= a ? n : void 0;
-}
-function i(e, t) {
-	if (e === t) return 0;
-	let n = Array(t.length + 1);
-	for (let e = 0; e <= t.length; e++) n[e] = e;
-	for (let r = 1; r <= e.length; r++) {
-		let i = n[0];
-		n[0] = r;
-		for (let a = 1; a <= t.length; a++) {
-			let o = Math.min(n[a] + 1, n[a - 1] + 1, i + (e[r - 1] === t[a - 1] ? 0 : 1));
-			i = n[a], n[a] = o;
-		}
-	}
-	return n[t.length];
-}
-//#endregion
-export { n as validateGridConfig };

package/dist/server-group-model.d.ts

@@ -1,98 +0,0 @@
-/**
- * Server-side GROUP row model (SSRM grouping) - the first-class
- * companion to `createServerDataSource`. Grouping, aggregation, and lazy
- * expansion all flow through the SAME `ServerDataSource.getRows` contract:
- *
- *   - The request carries `groupBy` (the columns grouped on) and `groupKeys`
- *     (the path of the group being expanded). While `groupKeys.length <
- *     groupBy.length` the server returns GROUP rows (one per distinct key at
- *     that level, carrying the key + aggregate values); at the bottom level it
- *     returns the leaf rows under that path.
- *   - Expanding a group is just another `getRows` with `groupKeys` set to that
- *     group's path. This controller owns the group tree: expand / collapse,
- *     per-node lazy fetch + cache, race-safety, and flattening to a display
- *     list the grid renders (group rows with an expander, leaves underneath).
- *
- * Headless and framework-agnostic on purpose: render from `state.displayRows`
- * and call `toggleGroup` from the group cell's expander.
- */
-import type { ServerAggregation, ServerDataSource, ServerDisplayRow, ServerFilterModel, ServerGroupRow, ServerSortModel } from './server-data-source.js';
-export type ServerGroupState<TData> = {
-    /** The flattened tree: top-level groups, with expanded groups' children spliced in. */
-    displayRows: ServerDisplayRow<TData>[];
-    groupBy: string[];
-    /** True during the initial top-level fetch (before the root has ever loaded). */
-    loading: boolean;
-    /** The rejection from the last failed top-level fetch, else null. */
-    error: unknown;
-    sortModel: ServerSortModel;
-    filterModel: ServerFilterModel;
-    /** Ids (JSON of the path) of the currently expanded groups. */
-    expandedGroups: string[];
-};
-export type ServerGroupControllerOptions<TData> = {
-    /** Columns to group on, outer to inner. Empty in `treeData` mode. */
-    groupBy?: string[];
-    /** Value columns to roll up per group. */
-    aggregations?: ServerAggregation[];
-    /** Max children fetched per group in one request. Default 200. */
-    pageSize?: number;
-    /**
-     * Self-referential tree mode: instead of grouping flat rows by columns, each
-     * row is a node whose children are fetched on expand. Requires `getRowId`
-     * (the node id, which builds the `groupKeys` path) and `hasChildren` (whether
-     * a node is expandable). `getRows` receives `groupKeys` = the path to the
-     * node being expanded, and returns that node's direct children.
-     */
-    treeData?: boolean;
-    /** Node id, used to build the `groupKeys` path. Required in `treeData` mode. */
-    getRowId?: (row: TData) => string;
-    /** Whether a node can be expanded. Required in `treeData` mode. */
-    hasChildren?: (row: TData) => boolean;
-    /** Emit a subtotal "footer" row after each expanded group's children. */
-    groupFooters?: boolean;
-    /** Placeholder rows shown while a group's first block is loading. Default 3. */
-    skeletonRows?: number;
-    onChange: (state: ServerGroupState<TData>) => void;
-};
-export type ServerGroupController<TData> = {
-    /** (Re-)fetch the tree from the top. Call once to load the first level. */
-    refresh(): void;
-    setSort(sortModel: ServerSortModel): void;
-    setFilter(filterModel: ServerFilterModel): void;
-    /** Change the grouping columns. Collapses everything and reloads the top level. */
-    setGroupBy(groupBy: string[]): void;
-    /** Expand or collapse a group row (from its expander). */
-    toggleGroup(row: ServerGroupRow<TData>): void;
-    expandGroup(path: string[]): void;
-    collapseGroup(path: string[]): void;
-    /** Fetch the next block of a group's children (intra-group paging). */
-    loadMoreChildren(path: string[]): void;
-    isExpanded(path: string[]): boolean;
-    getState(): ServerGroupState<TData>;
-    /** Stop accepting in-flight responses. Call on unmount. */
-    dispose(): void;
-};
-/**
- * Map a `ServerGroupState.displayRows` to grid rows: each row's data spread at
- * the top level (so normal `field` columns show group subtotals on group rows
- * and cell values on leaves) plus a `__group` marker the built-in `SvGroupCell`
- * reads to draw the expander + indentation. Feed the result to `<SvGrid data>`.
- */
-export type ServerGroupGridRow<TData> = TData & {
-    __group: ServerDisplayRow<TData>;
-};
-export declare function serverGroupRows<TData>(state: ServerGroupState<TData> | undefined | null): ServerGroupGridRow<TData>[];
-/**
- * Build the `serverGroup` prop for `<SvGrid>` from a controller, so the grid's
- * built-in tree keyboard (ArrowRight / ArrowLeft expand / collapse) and treegrid
- * a11y work with no app-level key handling. Reads the `__group` marker that
- * `serverGroupRows` attaches. Usage: `<SvGrid ... serverGroup={serverGroupNav(ctl)} />`.
- */
-export declare function serverGroupNav<TData>(ctl: ServerGroupController<TData>): {
-    isGroup: (row: ServerGroupGridRow<TData>) => boolean;
-    level: (row: ServerGroupGridRow<TData>) => number;
-    expanded: (row: ServerGroupGridRow<TData>) => boolean;
-    onToggle: (row: ServerGroupGridRow<TData>) => void;
-};
-export declare function createServerGroupModel<TData>(source: ServerDataSource<TData>, options: ServerGroupControllerOptions<TData>): ServerGroupController<TData>;

package/dist/server-group-model.js

@@ -1,263 +0,0 @@
-export function serverGroupRows(state) {
-    return (state?.displayRows ?? []).map((r) => ({ ...('data' in r ? r.data : {}), __group: r }));
-}
-/**
- * Build the `serverGroup` prop for `<SvGrid>` from a controller, so the grid's
- * built-in tree keyboard (ArrowRight / ArrowLeft expand / collapse) and treegrid
- * a11y work with no app-level key handling. Reads the `__group` marker that
- * `serverGroupRows` attaches. Usage: `<SvGrid ... serverGroup={serverGroupNav(ctl)} />`.
- */
-export function serverGroupNav(ctl) {
-    return {
-        isGroup: (row) => row.__group?.kind === 'group',
-        level: (row) => row.__group?.level ?? 0,
-        expanded: (row) => row.__group?.kind === 'group' ? row.__group.expanded : false,
-        onToggle: (row) => {
-            if (row.__group?.kind === 'group')
-                ctl.toggleGroup(row.__group);
-            else if (row.__group?.kind === 'more')
-                ctl.loadMoreChildren(row.__group.path);
-        },
-    };
-}
-const keyOf = (path) => JSON.stringify(path);
-export function createServerGroupModel(source, options) {
-    let groupBy = [...(options.groupBy ?? [])];
-    const aggregations = options.aggregations ?? [];
-    const pageSize = options.pageSize ?? 200;
-    const treeData = !!options.treeData;
-    if (treeData && (!options.getRowId || !options.hasChildren)) {
-        throw new Error('createServerGroupModel: treeData requires getRowId and hasChildren');
-    }
-    const getRowId = options.getRowId;
-    const hasChildren = options.hasChildren;
-    const groupFooters = !!options.groupFooters;
-    const skeletonRows = Math.max(0, options.skeletonRows ?? 3);
-    let sortModel = [];
-    let filterModel = {};
-    const nodes = new Map();
-    const expanded = new Set(); // path keys
-    // Generation guard: bumped on any tree reset so every fetch in flight for the
-    // previous shape is discarded when it lands (the classic stale-response bug).
-    let generation = 0;
-    let disposed = false;
-    const rootKey = keyOf([]);
-    function ensureNode(key) {
-        let node = nodes.get(key);
-        if (!node) {
-            node = { loaded: false, loading: false, error: null, count: 0, children: [] };
-            nodes.set(key, node);
-        }
-        return node;
-    }
-    // Walk the loaded tree from the root, splicing expanded groups' children in.
-    function flatten() {
-        const out = [];
-        const walk = (path) => {
-            const node = nodes.get(keyOf(path));
-            if (!node?.loaded)
-                return;
-            for (const child of node.children) {
-                if (child.kind === 'leaf') {
-                    out.push({ kind: 'leaf', id: child.id, level: child.level, data: child.data });
-                    continue;
-                }
-                const cid = keyOf(child.path);
-                const cnode = nodes.get(cid);
-                const isExp = expanded.has(cid);
-                out.push({
-                    kind: 'group',
-                    id: cid,
-                    path: child.path,
-                    field: child.field,
-                    key: child.key,
-                    level: child.level,
-                    expanded: isExp,
-                    loading: !!cnode?.loading,
-                    aggregates: child.aggregates,
-                    data: child.data,
-                });
-                if (isExp) {
-                    if (cnode?.loaded) {
-                        walk(child.path);
-                        // Subtotal row after the group's children.
-                        if (groupFooters) {
-                            out.push({
-                                kind: 'footer',
-                                id: cid + 'footer',
-                                level: child.level + 1,
-                                path: child.path,
-                                key: child.key,
-                                aggregates: child.aggregates,
-                                data: child.data,
-                            });
-                        }
-                    }
-                    else if (cnode?.loading) {
-                        // First block in flight: placeholder skeleton rows.
-                        for (let i = 0; i < skeletonRows; i += 1) {
-                            out.push({ kind: 'skeleton', id: cid + 'sk' + i, level: child.level + 1 });
-                        }
-                    }
-                }
-            }
-            // Intra-group paging: emit a "load more" affordance when only part of this
-            // node's children have been fetched.
-            if (node.children.length < node.count) {
-                out.push({
-                    kind: 'more',
-                    id: keyOf([...path, 'more']),
-                    level: path.length,
-                    path,
-                    remaining: node.count - node.children.length,
-                    loading: node.loading,
-                });
-            }
-        };
-        walk([]);
-        return out;
-    }
-    function emit() {
-        if (disposed)
-            return;
-        const root = nodes.get(rootKey);
-        options.onChange({
-            displayRows: flatten(),
-            groupBy: [...groupBy],
-            loading: !!root?.loading && !root?.loaded,
-            error: root?.error ?? null,
-            sortModel,
-            filterModel,
-            expandedGroups: [...expanded],
-        });
-    }
-    // append=false loads the first block of a node's children (on expand);
-    // append=true fetches the NEXT block and concatenates (intra-group paging).
-    async function fetchNode(path, append = false) {
-        if (disposed)
-            return;
-        const gen = generation;
-        const key = keyOf(path);
-        const node = ensureNode(key);
-        if (node.loading)
-            return; // a fetch for this node is already in flight
-        node.loading = true;
-        node.error = null;
-        emit();
-        const level = path.length;
-        const groupField = groupBy[level];
-        const startRow = append ? node.children.length : 0;
-        try {
-            const res = await source.getRows({
-                startRow,
-                endRow: startRow + pageSize,
-                pageIndex: Math.floor(startRow / pageSize),
-                pageSize,
-                sortModel,
-                filterModel,
-                groupBy,
-                groupKeys: path,
-                aggregations,
-            });
-            if (disposed || gen !== generation)
-                return; // stale: the tree was reset
-            node.count = res.rowCount;
-            const block = res.rows.map((data, i) => {
-                // A row is an expandable "group" when: (tree mode) the source says it has
-                // children, or (grouping mode) we are above the innermost groupBy level.
-                const isGroup = treeData ? hasChildren(data) : level < groupBy.length;
-                if (isGroup) {
-                    const gk = treeData
-                        ? getRowId(data)
-                        : ((v) => (v == null ? '' : String(v)))(data[groupField]);
-                    const aggregates = {};
-                    for (const a of aggregations)
-                        aggregates[a.col] = data[a.col];
-                    return { kind: 'group', path: [...path, gk], field: treeData ? '' : groupField, key: gk, level, aggregates, data };
-                }
-                const id = treeData && getRowId ? `${key}:${getRowId(data)}` : `${key}:${startRow + i}`;
-                return { kind: 'leaf', id, level, data };
-            });
-            node.children = append ? [...node.children, ...block] : block;
-            node.loaded = true;
-            node.loading = false;
-            emit();
-        }
-        catch (err) {
-            if (disposed || gen !== generation)
-                return;
-            node.error = err;
-            if (!append)
-                node.loaded = false;
-            node.loading = false;
-            emit();
-        }
-    }
-    // Clear the cache and reload the root plus any still-expanded paths (in
-    // parallel; flatten only descends into loaded nodes, so children appear as
-    // each level lands).
-    function resetTree() {
-        generation += 1;
-        nodes.clear();
-        void fetchNode([]);
-        for (const k of expanded)
-            void fetchNode(JSON.parse(k));
-    }
-    function expandGroup(path) {
-        const key = keyOf(path);
-        if (expanded.has(key))
-            return;
-        expanded.add(key);
-        const node = nodes.get(key);
-        if (!node?.loaded && !node?.loading)
-            void fetchNode(path);
-        else
-            emit();
-    }
-    function collapseGroup(path) {
-        if (expanded.delete(keyOf(path)))
-            emit();
-    }
-    return {
-        refresh: resetTree,
-        setSort(next) {
-            sortModel = next;
-            resetTree();
-        },
-        setFilter(next) {
-            filterModel = next;
-            resetTree();
-        },
-        setGroupBy(next) {
-            groupBy = [...next];
-            expanded.clear();
-            resetTree();
-        },
-        toggleGroup(row) {
-            if (expanded.has(row.id))
-                collapseGroup(row.path);
-            else
-                expandGroup(row.path);
-        },
-        expandGroup,
-        collapseGroup,
-        loadMoreChildren: (path) => void fetchNode(path, true),
-        isExpanded: (path) => expanded.has(keyOf(path)),
-        getState() {
-            const root = nodes.get(rootKey);
-            return {
-                displayRows: flatten(),
-                groupBy: [...groupBy],
-                loading: !!root?.loading && !root?.loaded,
-                error: root?.error ?? null,
-                sortModel,
-                filterModel,
-                expandedGroups: [...expanded],
-            };
-        },
-        dispose() {
-            disposed = true;
-            generation += 1;
-        },
-    };
-}