@svgrid/grid 3.0.4 → 4.0.0

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;
-        },
-    };
-}

package/src/SvGroupCell.svelte

@@ -1,141 +0,0 @@
-<!--
-  Built-in group cell for the server-side group/tree model. Drop it into the
-  grouping column and it draws the expander + indentation for group rows (and an
-  indented leaf value) - no hand-written cell recipe. Pair with `serverGroupRows`
-  to feed `<SvGrid data>`, and wire `onToggle` to the controller's `toggleGroup`.
-
-      cell: (ctx) => renderComponent(SvGroupCell, {
-        row: ctx.row.original, onToggle: ctl.toggleGroup, leafField: 'name',
-      })
--->
-<script lang="ts" generics="TData">
-  import type { ServerDisplayRow } from './server-data-source'
-  import type { GridIcons } from './grid-icons'
-
-  type GroupGridRow = { __group?: ServerDisplayRow<TData> } & Record<string, unknown>
-  type Props = {
-    /** The grid row from `serverGroupRows` (carries the `__group` marker). */
-    row: GroupGridRow
-    /**
-     * Expand / collapse a group, or load more children. Receives the grid row;
-     * wire to `serverGroupNav(ctl).onToggle` (which drives clicks and keyboard).
-     */
-    onToggle: (row: GroupGridRow) => void
-    /** Field to show for leaf rows in the group column (blank if omitted). */
-    leafField?: string
-    /** Pixels of indentation per level. Default 18. */
-    indent?: number
-    /**
-     * Icon overrides, the same map `<SvGrid icons>` takes. Only
-     * `chevron-right` is drawn here. You mount this component yourself, so it
-     * cannot inherit the grid's icons - pass the same object to both to keep
-     * the expander consistent with the rest of the chrome.
-     */
-    icons?: GridIcons
-  }
-
-  let { row, onToggle, leafField, indent = 18, icons }: Props = $props()
-  const chevron = $derived(icons?.['chevron-right'])
-  const meta = $derived(row.__group)
-</script>
-
-{#if meta && meta.kind === 'group'}
-  <button
-    type="button"
-    class="sv-group-cell"
-    style={`padding-inline-start: ${meta.level * indent}px`}
-    aria-expanded={meta.expanded}
-    aria-label={meta.expanded ? 'Collapse group' : 'Expand group'}
-    onclick={() => onToggle(row)}
-  >
-    <!-- Same chevron the grid's own expanders and SvTree draw, so every
-         expander in the library looks identical. -->
-    <span class="sv-group-chev" class:open={meta.expanded} aria-hidden="true">
-      {#if chevron}
-        {@render chevron()}
-      {:else}
-        <svg viewBox="0 0 24 24" width="12" height="12" fill="none" stroke="currentColor"
-          stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="m9 18 6-6-6-6" /></svg>
-      {/if}
-    </span>
-    <span class="sv-group-key">{meta.key}</span>
-    {#if meta.loading}<span class="sv-group-load" aria-hidden="true">…</span>{/if}
-  </button>
-{:else if meta && meta.kind === 'more'}
-  <button
-    type="button"
-    class="sv-group-more"
-    style={`padding-inline-start: ${meta.level * indent}px`}
-    disabled={meta.loading}
-    onclick={() => onToggle(row)}
-  >
-    {meta.loading ? 'Loading...' : `Load ${meta.remaining} more`}
-  </button>
-{:else if meta && meta.kind === 'footer'}
-  <span class="sv-group-footer" style={`padding-inline-start: ${meta.level * indent}px`}>Total</span>
-{:else if meta && meta.kind === 'skeleton'}
-  <span class="sv-group-skeleton" style={`margin-inline-start: ${meta.level * indent}px`} aria-hidden="true"></span>
-{:else if meta}
-  <span class="sv-group-leaf" style={`padding-inline-start: ${(meta.level + 1) * indent}px`}>
-    {leafField ? (row[leafField] ?? '') : ''}
-  </span>
-{/if}
-
-<style>
-  .sv-group-cell {
-    display: inline-flex;
-    align-items: center;
-    gap: 6px;
-    background: none;
-    border: 0;
-    padding: 0;
-    font: inherit;
-    color: inherit;
-    cursor: pointer;
-  }
-  .sv-group-chev {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    width: 12px;
-    height: 12px;
-    transition: transform 0.15s;
-    color: var(--sg-muted, #64748b);
-  }
-  /* An `icons` override renders inside this wrapper, and this style block is
-     scoped, so its markup needs :global() to be reached. Sizing it here means
-     a custom chevron lands in the same box as the built-in and rotates with
-     the wrapper rather than needing to know the rule exists. */
-  .sv-group-chev :global(svg),
-  .sv-group-chev :global(img) {
-    width: 100%;
-    height: 100%;
-    display: block;
-  }
-  .sv-group-chev.open { transform: rotate(90deg); }
-  .sv-group-key { font-weight: 600; }
-  .sv-group-load { color: var(--sg-muted, #64748b); font-size: 12px; }
-  .sv-group-leaf { color: var(--sg-muted, #475569); }
-  .sv-group-more {
-    background: none;
-    border: 0;
-    padding: 0;
-    font: inherit;
-    font-size: 13px;
-    color: var(--sg-accent, #2563eb);
-    cursor: pointer;
-  }
-  .sv-group-more:disabled { color: var(--sg-muted, #64748b); cursor: default; }
-  .sv-group-footer { font-weight: 600; color: var(--sg-muted, #64748b); font-size: 12px; text-transform: uppercase; letter-spacing: 0.03em; }
-  .sv-group-skeleton {
-    display: inline-block;
-    width: 60%;
-    height: 10px;
-    border-radius: 5px;
-    background: linear-gradient(90deg, var(--sg-border, #e2e8f0) 25%, var(--sg-header-bg, #f1f5f9) 50%, var(--sg-border, #e2e8f0) 75%);
-    background-size: 200% 100%;
-    animation: sv-group-shimmer 1.2s infinite;
-  }
-  @keyframes sv-group-shimmer { from { background-position: 200% 0; } to { background-position: -200% 0; } }
-  @media (prefers-reduced-motion: reduce) { .sv-group-skeleton { animation: none; } }
-</style>

package/src/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>