@svgrid/grid 3.0.3 → 3.0.5

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

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>