@svgrid/grid 2.2.15 → 2.2.17

package/dist/index.d.ts

@@ -5,10 +5,15 @@ export { createGrid, createSvGrid, type SvelteGrid } from './createGrid.svelte';
 export { createGridState, createSvGridState } from './createGridState.svelte';
 export { subscribeGrid, subscribeSvGrid } from './subscribe';
 export { default as SvGrid } from './SvGrid.svelte';
-export { default as SvGridBoard } from './SvGridBoard.svelte';
 export type { BoardConfig, BoardLane, BoardCardMoveEvent, BoardCardCommitEvent, BoardLayout, BoardSubtask, BoardComment, BoardMenuContext, BoardLaneMenuContext, BoardDrawerConfig } from './SvGrid.types';
+export { registerBoardView, getBoardView, hasBoardView } from './board-view.svelte';
+export * from './ai';
+export { registerExportProvider, getExportProvider, type GridExportProvider, type GridExportRunOptions, } from './export-provider';
 export type { SchedulerConfig, SchedulerDrawerConfig, SchedulerEventMoveEvent, SchedulerEventResizeEvent, SchedulerEventCommitEvent, SchedulerRangeSelection, SchedulerView, SchedulerResource, SchedulerCollisionMode, SchedulerException, SchedulerEditScope, SchedulerOccurrenceChangeEvent, } from './SvGrid.types';
 export { registerSchedulerView, getSchedulerView, hasSchedulerView } from './scheduler-view.svelte';
+export type { ChartViewConfig } from './SvGrid.types';
+export { registerChartView, getChartView, hasChartView } from './chart-view.svelte';
+export { registerPivotEngine, getPivotEngine, hasPivotEngine, type PivotEngine, type GridPivotConfig, type GridPivotValue, type GridPivotRow, } from './pivot-view.svelte';
 export { resolveEvents, hasConflict, overlapCount, overlapsBands, workingIntervals, withinWorking, type WorkingWindow, eventsOnDay, layoutDayEvents, monthWeekSegments, agendaGroups, rangeForView, daysForView, navigateAnchor, timelineAxis, timelineGeom, timelineRows, type ResolvedEvent, type EventSpec, type RecurrenceException, type PositionedEvent, type OverflowMarker, type DayLayout, type LayoutOptions, type MonthSegment, type AgendaGroup, type TimelineTick, type TimelineMajor, type TimelineAxis, type TimelineRow, } from './scheduler-model';
 export { default as SvGridDropdown } from './SvGridDropdown.svelte';
 export { default as SvCalendar, type CalendarValue, type CalendarPreset, type CalendarAnimation } from './SvCalendar.svelte';
@@ -17,7 +22,7 @@ export { default as SvTimePicker, type TimeValue } from './SvTimePicker.svelte';
 export { default as SvDateTimePicker, type DateTimeValue } from './SvDateTimePicker.svelte';
 export { default as SvDateRangeInput, type DateRangeValue } from './SvDateRangeInput.svelte';
 export { default as SvButtonGroup, type ButtonGroupItem, type ButtonGroupMode, type ButtonGroupValue } from './SvButtonGroup.svelte';
-export { editorAria, editorErrorId, editorHintId, nextEditorId, resolveMessages, type SvEditorProps, type EditorSize, type EditorDir, type EditorAriaState, } from './editor-contract';
+export { editorAria, editorErrorId, editorHintId, nextEditorId, resolveMessages, type SvEditorProps, type EditorSize, type EditorDir, type EditorAction, type EditorAriaState, } from './editor-contract';
 export { type EditorInteraction } from './editor-contract';
 export { FOCUSABLE_SELECTOR, getFocusable, createFocusTrap, type FocusTrap, type FocusTrapOptions, } from './a11y/focus-trap';
 export { lockScroll, scrollLockDepth } from './a11y/scroll-lock';
@@ -29,7 +34,25 @@ export { createPagination, type Pagination, type PaginationConfig } from './crea
 export { createStepper, type Stepper, type StepperConfig, type StepStatus } from './createStepper';
 export { createCarousel, type Carousel, type CarouselConfig } from './createCarousel.svelte';
 export { createCommand, type Command, type CommandConfig } from './createCommand.svelte';
-export { createForm, type Form, type FormConfig } from './createForm.svelte';
+export { createForm, type Form, type FormConfig, type FormMessages } from './createForm.svelte';
+export { default as SvSegmented, type SegmentedOption } from './SvSegmented.svelte';
+export { default as SvSpinner } from './SvSpinner.svelte';
+export { default as SvLoadingOverlay } from './SvLoadingOverlay.svelte';
+export { default as SvResult } from './SvResult.svelte';
+export { default as SvCollapsible } from './SvCollapsible.svelte';
+export { default as SvStack } from './SvStack.svelte';
+export { default as SvGroup } from './SvGroup.svelte';
+export { default as SvSimpleGrid } from './SvSimpleGrid.svelte';
+export { default as SvText } from './SvText.svelte';
+export { default as SvTitle } from './SvTitle.svelte';
+export { default as SvAnchor } from './SvAnchor.svelte';
+export { default as SvBlockquote } from './SvBlockquote.svelte';
+export { default as SvMark } from './SvMark.svelte';
+export { default as SvList } from './SvList.svelte';
+export { default as SvKbd } from './SvKbd.svelte';
+export { default as SvCode } from './SvCode.svelte';
+export { default as SvVisuallyHidden } from './SvVisuallyHidden.svelte';
+export { default as SvAspectRatio } from './SvAspectRatio.svelte';
 export { registerCellEditor, getCellEditor, hasCellEditor, unregisterCellEditor, registeredCellEditorTypes, defaultEditorProps, resolveEditorProps, type CellEditorContext, type CellEditorRegistration, } from './editor-registry';
 export { registerBuiltinEditors } from './builtin-editors';
 export { default as SvField } from './SvField.svelte';
@@ -138,9 +161,12 @@ export { default as SvStepper, type StepItem } from './SvStepper.svelte';
 export { default as SvAvatar } from './SvAvatar.svelte';
 export { avatarInitials, avatarColorHue } from './avatar';
 export { default as SvContextMenu } from './SvContextMenu.svelte';
-export { toast, dismissToast, clearToasts, pauseToast, resumeToast, toastStore, type Toast, type ToastVariant, type ToastOptions, type ToastFn, } from './toast-store.svelte';
+export { toast, dismissToast, updateToast, clearToasts, pauseToast, resumeToast, toastStore, type Toast, type ToastVariant, type ToastOptions, type ToastFn, type ToastAction, type UpdateToast, type PromiseMessages, } from './toast-store.svelte';
 export { default as SvMenu, type MenuItem } from './SvMenu.svelte';
 export { default as SvMenuList } from './SvMenuList.svelte';
+export { default as SvMenubar, type MenubarMenu } from './SvMenubar.svelte';
+export { default as SvHoverCard } from './SvHoverCard.svelte';
+export { default as SvPopconfirm } from './SvPopconfirm.svelte';
 export { default as SvNavPane, type NavItem, type NavSection, type NavModule } from './SvNavPane.svelte';
 export { default as SvProgress } from './SvProgress.svelte';
 export { default as SvCircularProgress } from './SvCircularProgress.svelte';
@@ -148,6 +174,7 @@ export { popIn } from './popover';
 export { default as SvForm, type FormField, type FormFieldType, type FormSection, type FormEntry } from './SvForm.svelte';
 export { rules, runRules, isEmptyValue, type Validator, type RuleOptions, type CompareOp } from './validators';
 export { anchoredRect, portalToBody, PANEL_THEME_VARS, type AnchoredRect } from './popover';
+export { computePosition, autoUpdate, parsePlacement, type Placement, type Side, type Align, type Rect, type Viewport, type ComputePositionOptions, type ComputePositionResult, } from './positioning';
 export { toDate, startOfDay, startOfWeek, startOfMonth, addDays, addMonths, addYears, clampDate, isSameDay, monthMatrix, weekdayOrder, isoWeek, decadeRange, withTime, snapMinute, type DateLike, } from './datetime/date-core';
 export { formatDate, parseDate, tokenizeMask } from './datetime/date-format';
 export { toICS, fromICS, ruleToRRule, rruleToRule, type ICalEvent } from './scheduler-ical';
@@ -158,7 +185,10 @@ export { default as FlexRender } from './FlexRender.svelte';
 export { renderComponent, renderSnippet } from './render-component';
 export { default as SvGridChart } from './SvGridChart.svelte';
 export { default as SvGridChartPanel } from './SvGridChartPanel.svelte';
+export { default as SvChart } from './SvGridChart.svelte';
+export { default as SvChartPanel } from './SvGridChartPanel.svelte';
 export type { ChartingConfig, ChartAggregateRequest, ChartAggregateBucket } from './SvGrid.types';
+export type { GridLocalization } from './SvGrid.types';
 export { buildChart, formatChartValue, rowsToChartSpec, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, type ChartType, type ChartSpec, type ChartSeries, type ChartGeometry, type ChartBar, type ChartLine, type ChartLinePoint, type ChartPieSlice, type ChartSelection, type ChartReferenceLine, type ChartRefLineGeo, type ChartRefLineGeoV, type ChartScatterDot, type ScatterPoint, type NiceScale, type SeriesOverlay, type SeriesPattern, type ChartAnnotation, type ChartHeatmapCell, type ChartFunnelSegment, type ChartRadarSeries, type ChartRadarAxis, type ChartTreemapCell, type ChartCalendarCell, type ChartGaugeLayout, type ChartSankeyNode, type ChartSankeyLink, type ChartValueFormat, type TreeNode, } from './chart';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, chartSpecToCsv, downloadChartCsv, type ChartExportOptions, } from './chart-export';
 export { buildSparkline, toSparklineValues, type SparklineConfig, type SparklineType, type SparklineGeometry, } from './sparkline';
@@ -175,6 +205,8 @@ export { default as SvGroupCell } from './SvGroupCell.svelte';
 export { default as SvRowGroupPanel } from './SvRowGroupPanel.svelte';
 export { createNamedViews, memoryViews, localStorageViews, attachAutoSavedView, type SavedView, type ViewStorage, type NamedViews, type AutoSavedViewOptions, } from './named-views';
 export { resolveCellFormat, computeColumnStat, lerpColor, rgba, contrastText, formatNeedsStats, formatsNeedingStats, type ConditionalFormat, type ConditionalFormatSpec, type ColorScaleFormat, type ColorScaleStop, type ScaleBounds, type DataBarFormat, type IconSetFormat, type RuleFormat, type ResolvedCellFormat, } from './conditional-formatting';
+export { defaultGridMessages, resolveGridMessages, type GridMessages, } from './grid-messages';
+export { insertGroupFooters, buildAutoGroupColumns, type GroupDisplayType, type GroupFooterOptions, type AutoGroupColumnSpec, type AutoGroupResult, } from './group-display';
 export { getKeyboardIntent, getNextActiveCell, type GridKeyboardIntent } from './keyboard';
 export { createVirtualizer } from './virtualization/virtualizer';
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte';

package/dist/index.js

@@ -5,8 +5,18 @@ export { createGrid, createSvGrid } from './createGrid.svelte';
 export { createGridState, createSvGridState } from './createGridState.svelte';
 export { subscribeGrid, subscribeSvGrid } from './subscribe';
 export { default as SvGrid } from './SvGrid.svelte';
-export { default as SvGridBoard } from './SvGridBoard.svelte';
+export { registerBoardView, getBoardView, hasBoardView } from './board-view.svelte';
+// Built-in AI helpers (free): natural-language filter, smart-fill, summarize,
+// classify, anomaly detection, chart-this and export planning. They ship no
+// model client and no-op until you register one with `setAIProvider(...)`, so
+// they tree-shake out of the base bundle unless you actually import them. The
+// export-provider seam lets @svgrid/enterprise register its Excel/PDF engine so
+// AI-planned exports can WRITE those formats.
+export * from './ai';
+export { registerExportProvider, getExportProvider, } from './export-provider';
 export { registerSchedulerView, getSchedulerView, hasSchedulerView } from './scheduler-view.svelte';
+export { registerChartView, getChartView, hasChartView } from './chart-view.svelte';
+export { registerPivotEngine, getPivotEngine, hasPivotEngine, } from './pivot-view.svelte';
 // Pure scheduler layout/model helpers (framework-free, like recurrence/date-core).
 // The calendar RENDERER that consumes these ships in @svgrid/enterprise.
 export { resolveEvents, hasConflict, overlapCount, overlapsBands, workingIntervals, withinWorking, eventsOnDay, layoutDayEvents, monthWeekSegments, agendaGroups, rangeForView, daysForView, navigateAnchor, timelineAxis, timelineGeom, timelineRows, } from './scheduler-model';
@@ -41,6 +51,25 @@ export { createCarousel } from './createCarousel.svelte';
 export { createCommand } from './createCommand.svelte';
 // Schema-driven form core (SvForm): values/errors/touched + validation + submit.
 export { createForm } from './createForm.svelte';
+export { default as SvSegmented } from './SvSegmented.svelte';
+export { default as SvSpinner } from './SvSpinner.svelte';
+export { default as SvLoadingOverlay } from './SvLoadingOverlay.svelte';
+export { default as SvResult } from './SvResult.svelte';
+export { default as SvCollapsible } from './SvCollapsible.svelte';
+export { default as SvStack } from './SvStack.svelte';
+export { default as SvGroup } from './SvGroup.svelte';
+export { default as SvSimpleGrid } from './SvSimpleGrid.svelte';
+// UI kit - typography + display primitives (Pillar C2)
+export { default as SvText } from './SvText.svelte';
+export { default as SvTitle } from './SvTitle.svelte';
+export { default as SvAnchor } from './SvAnchor.svelte';
+export { default as SvBlockquote } from './SvBlockquote.svelte';
+export { default as SvMark } from './SvMark.svelte';
+export { default as SvList } from './SvList.svelte';
+export { default as SvKbd } from './SvKbd.svelte';
+export { default as SvCode } from './SvCode.svelte';
+export { default as SvVisuallyHidden } from './SvVisuallyHidden.svelte';
+export { default as SvAspectRatio } from './SvAspectRatio.svelte';
 // UI kit - custom cell-editor registry (register any component as a grid editor)
 export { registerCellEditor, getCellEditor, hasCellEditor, unregisterCellEditor, registeredCellEditorTypes, defaultEditorProps, resolveEditorProps, } from './editor-registry';
 export { registerBuiltinEditors } from './builtin-editors';
@@ -167,9 +196,12 @@ export { default as SvStepper } from './SvStepper.svelte';
 export { default as SvAvatar } from './SvAvatar.svelte';
 export { avatarInitials, avatarColorHue } from './avatar';
 export { default as SvContextMenu } from './SvContextMenu.svelte';
-export { toast, dismissToast, clearToasts, pauseToast, resumeToast, toastStore, } from './toast-store.svelte';
+export { toast, dismissToast, updateToast, clearToasts, pauseToast, resumeToast, toastStore, } from './toast-store.svelte';
 export { default as SvMenu } from './SvMenu.svelte';
 export { default as SvMenuList } from './SvMenuList.svelte';
+export { default as SvMenubar } from './SvMenubar.svelte';
+export { default as SvHoverCard } from './SvHoverCard.svelte';
+export { default as SvPopconfirm } from './SvPopconfirm.svelte';
 export { default as SvNavPane } from './SvNavPane.svelte';
 export { default as SvProgress } from './SvProgress.svelte';
 export { default as SvCircularProgress } from './SvCircularProgress.svelte';
@@ -177,6 +209,7 @@ export { popIn } from './popover';
 export { default as SvForm } from './SvForm.svelte';
 export { rules, runRules, isEmptyValue } from './validators';
 export { anchoredRect, portalToBody, PANEL_THEME_VARS } from './popover';
+export { computePosition, autoUpdate, parsePlacement, } from './positioning';
 export { toDate, startOfDay, startOfWeek, startOfMonth, addDays, addMonths, addYears, clampDate, isSameDay, monthMatrix, weekdayOrder, isoWeek, decadeRange, withTime, snapMinute, } from './datetime/date-core';
 export { formatDate, parseDate, tokenizeMask } from './datetime/date-format';
 export { toICS, fromICS, ruleToRRule, rruleToRule } from './scheduler-ical';
@@ -187,6 +220,12 @@ export { default as FlexRender } from './FlexRender.svelte';
 export { renderComponent, renderSnippet } from './render-component';
 export { default as SvGridChart } from './SvGridChart.svelte';
 export { default as SvGridChartPanel } from './SvGridChartPanel.svelte';
+// Preferred names for the standalone chart primitives. `SvChart` is a genuine
+// standalone component (spec-driven, no grid needed), so it sits alongside its
+// unprefixed siblings SvGauge / SvSparkline. The `SvGrid*` names remain exported
+// as aliases so existing imports keep working.
+export { default as SvChart } from './SvGridChart.svelte';
+export { default as SvChartPanel } from './SvGridChartPanel.svelte';
 export { buildChart, formatChartValue, rowsToChartSpec, niceScale, niceLogScale, linearTrend, simpleMovingAverage, exponentialMovingAverage, computeOverlay, buildLinePath, sampleGradient, pickContrastText, DEFAULT_PALETTE, } from './chart';
 export { chartToSvgString, downloadChartSvg, chartToPngBlob, downloadChartPng, chartSpecToCsv, downloadChartCsv, } from './chart-export';
 export { buildSparkline, toSparklineValues, } from './sparkline';
@@ -203,6 +242,8 @@ export { default as SvGroupCell } from './SvGroupCell.svelte';
 export { default as SvRowGroupPanel } from './SvRowGroupPanel.svelte';
 export { createNamedViews, memoryViews, localStorageViews, attachAutoSavedView, } from './named-views';
 export { resolveCellFormat, computeColumnStat, lerpColor, rgba, contrastText, formatNeedsStats, formatsNeedingStats, } from './conditional-formatting';
+export { defaultGridMessages, resolveGridMessages, } from './grid-messages';
+export { insertGroupFooters, buildAutoGroupColumns, } from './group-display';
 export { getKeyboardIntent, getNextActiveCell } from './keyboard';
 export { createVirtualizer } from './virtualization/virtualizer';
 export { createSvelteVirtualizer } from './virtualization/svelte-virtualizer.svelte';

package/dist/js-scroller.svelte.d.ts

@@ -0,0 +1,35 @@
+type ScrollerVirtualizer = {
+    setScrollOffset: (offset: number) => void;
+    getOffsetForIndex: (index: number) => number;
+    getSizeForIndex: (index: number) => number;
+};
+export type JsScrollerConfig = {
+    /** The shared virtualizer to drive. */
+    virtualizer: ScrollerVirtualizer;
+    /** Full scrollable content height (px). */
+    totalSize: () => number;
+    /** Visible viewport height (px). */
+    viewport: () => number;
+    /** Row height used to convert line-mode wheel deltas to px. */
+    lineStep: () => number;
+};
+export declare function createJsScroller(cfg: JsScrollerConfig): {
+    readonly scrollOffset: number;
+    readonly maxOffset: number;
+    readonly thumbH: number;
+    readonly thumbTop: number;
+    readonly dragging: boolean;
+    scrollTo: (offset: number) => void;
+    scrollByPx: (delta: number) => void;
+    ensureVisible: (top: number, h: number) => void;
+    ensureIndexVisible: (index: number) => void;
+    onWheel: (e: WheelEvent) => void;
+    onThumbDown: (e: PointerEvent) => void;
+    onThumbMove: (e: PointerEvent) => void;
+    onThumbUp: (e: PointerEvent) => void;
+    onTrackDown: (e: PointerEvent) => void;
+    onContentDown: (e: PointerEvent) => void;
+    onContentMove: (e: PointerEvent) => void;
+    onContentUp: (e: PointerEvent) => void;
+};
+export {};

package/dist/js-scroller.svelte.js

@@ -0,0 +1,154 @@
+/**
+ * createJsScroller - a JS-driven vertical scroller for the virtualized selection
+ * controls (SvListBox / SvDropDownList / SvTree).
+ *
+ * Native overflow scroll is composited off the main thread, so on a fast
+ * scrollbar-thumb drag the browser paints the new (empty) scroll position a
+ * frame before JS can re-window the virtualizer - the "blank flash while
+ * scrolling". This helper removes that async gap the way Smart's list does: the
+ * content does NOT use native scroll. A single `scrollOffset` state positions
+ * the rows (`translateY`) AND drives the virtualizer window in the same reactive
+ * flush, and a custom scrollbar + wheel/touch handlers set that offset directly.
+ *
+ * The component owns the markup (translated rows + the `sb`/`thumb` elements);
+ * this owns the offset, the geometry, and the input handlers.
+ */
+import { untrack } from 'svelte';
+export function createJsScroller(cfg) {
+    // The single source of truth for the scroll position.
+    let scrollOffset = $state(0);
+    const maxOffset = $derived(Math.max(0, cfg.totalSize() - cfg.viewport()));
+    // Push the offset into the virtualizer whenever it changes. `untrack` keeps
+    // the virtualizer's `version` write out of this effect's dependencies.
+    $effect(() => {
+        const o = scrollOffset;
+        untrack(() => cfg.virtualizer.setScrollOffset(o));
+    });
+    // Re-clamp if the content shrinks under the current offset.
+    $effect(() => {
+        const m = maxOffset;
+        if (untrack(() => scrollOffset) > m)
+            scrollOffset = m;
+    });
+    function scrollTo(offset) {
+        scrollOffset = Math.max(0, Math.min(maxOffset, offset));
+    }
+    function scrollByPx(delta) {
+        scrollTo(scrollOffset + delta);
+    }
+    function onWheel(e) {
+        if (maxOffset <= 0)
+            return;
+        // deltaMode: 0 = pixels, 1 = lines, 2 = pages.
+        const step = e.deltaMode === 1 ? e.deltaY * cfg.lineStep() : e.deltaMode === 2 ? e.deltaY * cfg.viewport() : e.deltaY;
+        const before = scrollOffset;
+        scrollByPx(step);
+        // Only swallow the wheel when it moved us, so the page can scroll once the
+        // list is pinned at its top/bottom edge.
+        if (scrollOffset !== before)
+            e.preventDefault();
+    }
+    // --- Custom scrollbar geometry --------------------------------------------
+    const thumbH = $derived(maxOffset > 0 && cfg.totalSize() > 0
+        ? Math.max(24, Math.min(cfg.viewport(), (cfg.viewport() / cfg.totalSize()) * cfg.viewport()))
+        : 0);
+    const trackRange = $derived(Math.max(0, cfg.viewport() - thumbH));
+    const thumbTop = $derived(maxOffset > 0 ? (scrollOffset / maxOffset) * trackRange : 0);
+    let dragging = $state(false);
+    let dragStartY = 0;
+    let dragStartOffset = 0;
+    function onThumbDown(e) {
+        e.stopPropagation();
+        e.preventDefault();
+        dragging = true;
+        dragStartY = e.clientY;
+        dragStartOffset = scrollOffset;
+        e.currentTarget.setPointerCapture(e.pointerId);
+    }
+    function onThumbMove(e) {
+        if (!dragging)
+            return;
+        const dy = e.clientY - dragStartY;
+        scrollTo(dragStartOffset + (trackRange > 0 ? (dy / trackRange) * maxOffset : 0));
+    }
+    function onThumbUp(e) {
+        dragging = false;
+        releaseCapture(e);
+    }
+    function onTrackDown(e) {
+        const rect = e.currentTarget.getBoundingClientRect();
+        scrollByPx(e.clientY - rect.top < thumbTop ? -cfg.viewport() : cfg.viewport());
+    }
+    // --- Touch: drag the content to pan ---------------------------------------
+    let touchActive = false;
+    let touchStartY = 0;
+    let touchStartOffset = 0;
+    function onContentDown(e) {
+        if (e.pointerType !== 'touch')
+            return;
+        touchActive = true;
+        touchStartY = e.clientY;
+        touchStartOffset = scrollOffset;
+        e.currentTarget.setPointerCapture(e.pointerId);
+    }
+    function onContentMove(e) {
+        if (!touchActive)
+            return;
+        scrollTo(touchStartOffset - (e.clientY - touchStartY));
+    }
+    function onContentUp(e) {
+        if (!touchActive)
+            return;
+        touchActive = false;
+        releaseCapture(e);
+    }
+    function releaseCapture(e) {
+        try {
+            ;
+            e.currentTarget.releasePointerCapture(e.pointerId);
+        }
+        catch {
+            /* capture may already be gone */
+        }
+    }
+    /** Scroll the minimal amount to bring `[top, top+h]` fully into view. */
+    function ensureVisible(top, h) {
+        if (top < scrollOffset)
+            scrollTo(top);
+        else if (top + h > scrollOffset + cfg.viewport())
+            scrollTo(top + h - cfg.viewport());
+    }
+    /** Bring a virtualizer row index into view (variable-height aware). */
+    function ensureIndexVisible(index) {
+        ensureVisible(cfg.virtualizer.getOffsetForIndex(index), cfg.virtualizer.getSizeForIndex(index));
+    }
+    return {
+        get scrollOffset() {
+            return scrollOffset;
+        },
+        get maxOffset() {
+            return maxOffset;
+        },
+        get thumbH() {
+            return thumbH;
+        },
+        get thumbTop() {
+            return thumbTop;
+        },
+        get dragging() {
+            return dragging;
+        },
+        scrollTo,
+        scrollByPx,
+        ensureVisible,
+        ensureIndexVisible,
+        onWheel,
+        onThumbDown,
+        onThumbMove,
+        onThumbUp,
+        onTrackDown,
+        onContentDown,
+        onContentMove,
+        onContentUp,
+    };
+}

package/dist/list-option.d.ts

@@ -8,6 +8,14 @@ export type ListOption = {
     /** Optional color swatch (any CSS color) shown before the label. */
     color?: string;
 };
+/**
+ * Coerce a raw options array into well-formed ListOptions. A primitive item
+ * (`1`, `'a'`) becomes `{ value, label: String(value) }`; an object missing a
+ * `label` or `value` gets the other filled in. This makes a caller who passes
+ * e.g. `[1, 2, 3]` or `['a', 'b']` render sensibly instead of crashing a keyed
+ * `#each` on `undefined`/duplicate `value`s.
+ */
+export declare function normalizeOptions(raw: ReadonlyArray<ListOption | string | number> | null | undefined): ListOption[];
 /** Case-insensitive substring filter over option labels. */
 export declare function filterOptions(options: ReadonlyArray<ListOption>, query: string): ListOption[];
 /** An option carrying its position in the flat source array (for prop-getters). */
@@ -28,6 +36,44 @@ export type OptionGroup = {
 export declare function groupOptions(options: ReadonlyArray<ListOption>): OptionGroup[];
 /** Whether any option declares a `group` (so headings are worth rendering). */
 export declare function hasGroups(options: ReadonlyArray<ListOption>): boolean;
+/** Fixed px, or a per-option function - lets a virtualized list mix row heights. */
+export type RowHeight = number | ((opt: IndexedOption, index: number) => number);
+/** One row of the flattened virtualization model: a group heading or an option. */
+export type VirtualListRow = {
+    type: 'group';
+    label: string;
+    size: number;
+} | {
+    type: 'option';
+    opt: IndexedOption;
+    size: number;
+};
+export type FlatVirtualModel = {
+    /** Group headings + options in render order, each with its px height. */
+    entries: VirtualListRow[];
+    /** Whether any group heading rows are present. */
+    hasGroups: boolean;
+    /** Height (px) of the entry at flat index `i` - feeds the virtualizer's `estimateSize`. */
+    sizeAt: (i: number) => number;
+    /** Maps an OPTION index (position in the source options array, as used by
+     *  `optionProps(index)`) to its flat entry index - so the active option can
+     *  be scrolled into view even with group rows interleaved. */
+    optionFlatIndex: number[];
+};
+/**
+ * Flatten a (possibly grouped) option list into a single virtualization model:
+ * group headings become rows interleaved with their options, and each row
+ * carries its pixel height. This is what lets the selection controls window a
+ * GROUPED list (previously they fell back to rendering every node) and support
+ * variable row heights, while reusing the shared `createSvelteVirtualizer`.
+ *
+ * Pure - no DOM. Builds on `groupOptions`, which already tags each option with
+ * its flat `index` (the value `optionProps(index)` expects).
+ */
+export declare function flattenForVirtual(options: ReadonlyArray<ListOption>, opts: {
+    rowHeight: RowHeight;
+    groupHeaderHeight?: number;
+}): FlatVirtualModel;
 /**
  * Next enabled option index whose label starts with `buffer` (type-ahead),
  * searching forward from just after `from` and wrapping. Returns -1 for no

package/dist/list-option.js

@@ -1,3 +1,22 @@
+/**
+ * Coerce a raw options array into well-formed ListOptions. A primitive item
+ * (`1`, `'a'`) becomes `{ value, label: String(value) }`; an object missing a
+ * `label` or `value` gets the other filled in. This makes a caller who passes
+ * e.g. `[1, 2, 3]` or `['a', 'b']` render sensibly instead of crashing a keyed
+ * `#each` on `undefined`/duplicate `value`s.
+ */
+export function normalizeOptions(raw) {
+    if (!raw)
+        return [];
+    return raw.map((o) => {
+        if (o != null && typeof o === 'object') {
+            const opt = o;
+            const value = opt.value ?? opt.label ?? '';
+            return { ...opt, value, label: opt.label ?? String(value) };
+        }
+        return { value: o, label: String(o) };
+    });
+}
 /** Case-insensitive substring filter over option labels. */
 export function filterOptions(options, query) {
     const q = query.trim().toLowerCase();
@@ -30,6 +49,40 @@ export function groupOptions(options) {
 export function hasGroups(options) {
     return options.some((o) => o.group != null);
 }
+/**
+ * Flatten a (possibly grouped) option list into a single virtualization model:
+ * group headings become rows interleaved with their options, and each row
+ * carries its pixel height. This is what lets the selection controls window a
+ * GROUPED list (previously they fell back to rendering every node) and support
+ * variable row heights, while reusing the shared `createSvelteVirtualizer`.
+ *
+ * Pure - no DOM. Builds on `groupOptions`, which already tags each option with
+ * its flat `index` (the value `optionProps(index)` expects).
+ */
+export function flattenForVirtual(options, opts) {
+    const headerH = Math.max(1, opts.groupHeaderHeight ?? 28);
+    const rh = opts.rowHeight;
+    const sizeOf = (o) => Math.max(1, typeof rh === 'function' ? rh(o, o.index) : rh);
+    const entries = [];
+    const optionFlatIndex = new Array(options.length);
+    let anyGroups = false;
+    for (const g of groupOptions(options)) {
+        if (g.group != null) {
+            anyGroups = true;
+            entries.push({ type: 'group', label: g.group, size: headerH });
+        }
+        for (const opt of g.options) {
+            optionFlatIndex[opt.index] = entries.length;
+            entries.push({ type: 'option', opt, size: sizeOf(opt) });
+        }
+    }
+    return {
+        entries,
+        hasGroups: anyGroups,
+        sizeAt: (i) => entries[i]?.size ?? 0,
+        optionFlatIndex,
+    };
+}
 /**
  * Next enabled option index whose label starts with `buffer` (type-ahead),
  * searching forward from just after `from` and wrapping. Returns -1 for no

package/dist/menus.js

@@ -322,16 +322,21 @@ export function createMenus(ctx) {
         ctx.internalColumns = ctx.internalColumns.filter((d) => (d.id ?? d.field) !== t.columnId);
     }
     // Built-in items, keyed. `run` reads the live target passed at click time.
+    // `msg` names the GridMessages key so the label localizes (falls back to the
+    // English `label` when no `localeText` is set).
     const builtins = {
-        copy: { label: "Copy", run: () => ctx.copySelectionToClipboard() },
-        cut: { label: "Cut", run: () => ctx.cutSelectionToClipboard() },
-        paste: { label: "Paste", run: () => void ctx.pasteFromClipboard() },
-        clear: { label: "Clear", run: () => ctx.clearSelectedCells() },
-        row_above: { label: "Insert row above", run: (t) => insertRowAt(t, 0) },
-        row_below: { label: "Insert row below", run: (t) => insertRowAt(t, 1) },
-        remove_row: { label: "Remove row", run: removeRowAt },
-        remove_col: { label: "Remove column", run: removeColAt },
-        comment: { label: "Edit comment", run: (t) => openCommentEditor(t) },
+        copy: { label: "Copy", msg: "menuCopy", run: () => ctx.copySelectionToClipboard() },
+        cut: { label: "Cut", msg: "menuCut", run: () => ctx.cutSelectionToClipboard() },
+        paste: { label: "Paste", msg: "menuPaste", run: () => void ctx.pasteFromClipboard() },
+        clear: { label: "Clear", msg: "menuClear", run: () => ctx.clearSelectedCells() },
+        row_above: { label: "Insert row above", msg: "menuInsertRowAbove", run: (t) => insertRowAt(t, 0) },
+        row_below: { label: "Insert row below", msg: "menuInsertRowBelow", run: (t) => insertRowAt(t, 1) },
+        remove_row: { label: "Remove row", msg: "menuRemoveRow", run: removeRowAt },
+        remove_col: { label: "Remove column", msg: "menuRemoveColumn", run: removeColAt },
+        comment: { label: "Edit comment", msg: "menuEditComment", run: (t) => openCommentEditor(t) },
+        // Charting: open the chart panel scoped to the current cell selection. Gated
+        // on `chartingEnabled` in the resolver below.
+        chart: { label: "Chart selected range", msg: "chartRange", run: () => { ctx.chartPanelOpen = true; } },
     };
     const DEFAULT_ITEMS = [
         "copy", "cut", "paste", "clear", "separator",
@@ -399,9 +404,14 @@ export function createMenus(ctx) {
         if (!target)
             return [];
         const cfg = ctx.props.contextMenu;
+        const messages = ctx.messages;
         const entries = Array.isArray(cfg)
             ? cfg
-            : [...DEFAULT_ITEMS, ...(ctx.props.editableComments ? ["separator", "comment"] : [])];
+            : [
+                ...DEFAULT_ITEMS,
+                ...(ctx.chartingEnabled ? ["separator", "chart"] : []),
+                ...(ctx.props.editableComments ? ["separator", "comment"] : []),
+            ];
         const out = [];
         for (const entry of entries) {
             if (entry === "separator") {
@@ -409,10 +419,14 @@ export function createMenus(ctx) {
                 continue;
             }
             if (typeof entry === "string") {
+                // The chart item only makes sense when charting is enabled.
+                if (entry === "chart" && !ctx.chartingEnabled)
+                    continue;
                 const b = builtins[entry];
                 if (!b)
                     continue;
-                out.push({ key: entry, label: b.label, run: () => b.run(target) });
+                const label = (b.msg && messages?.[b.msg]) || b.label;
+                out.push({ key: entry, label, run: () => b.run(target) });
                 continue;
             }
             if (entry.hidden?.(target))

package/dist/pivot-view.svelte.d.ts

@@ -0,0 +1,72 @@
+/**
+ * pivot-engine registry - the injection seam for in-grid pivot mode. Setting the
+ * `pivot` prop on `<SvGrid>` turns the live grid into a pivot table in place, but
+ * the pivot ENGINE (which aggregates rows into a pivot result with nested column
+ * headers) ships in `@svgrid/enterprise`. This tiny reactive holder lets
+ * enterprise register that engine at import time; the grid looks it up and runs
+ * it over its filtered + sorted rows, or shows an upsell placeholder when the
+ * engine is absent. Mirrors the `scheduler-view` / `editor-registry` pattern.
+ *
+ * Unlike the scheduler (which swaps in a whole renderer component), the pivot
+ * engine is a PURE function - the pivot result renders through the grid's normal
+ * table + grouped-column-header path.
+ *
+ * ONE ENGINE, two entry points: the engine registered here is enterprise's
+ * `createPivotModel`. The `pivot` prop on `<SvGrid>` (declarative, no UI) reaches
+ * it through this seam; the visual `<SvPivotDesigner>` component calls the same
+ * `createPivotModel` directly and adds a drag-drop field designer, heat-tinting,
+ * expand/collapse and a chart view on top. Pick the prop for code-defined
+ * pivots, the designer for an end-user field picker - both aggregate identically.
+ *
+ * ```ts
+ * // in @svgrid/enterprise, at module load (via enablePivot()):
+ * import { registerPivotEngine } from '@svgrid/grid'
+ * import { createPivotModel } from './pivot'
+ * registerPivotEngine((data, config) => createPivotModel(data, config))
+ * ```
+ */
+import type { ColumnDef, RowData, TableFeatures } from './index';
+/** One value measure in a pivot: which field, how to aggregate, how to label. */
+export type GridPivotValue<TData = RowData> = {
+    field: keyof TData & string;
+    agg?: 'sum' | 'avg' | 'min' | 'max' | 'count' | 'countDistinct' | 'first' | 'last';
+    label?: string;
+    format?: unknown;
+};
+/**
+ * Free-grid pivot config. Structurally compatible with enterprise `PivotConfig`
+ * so the free package carries zero dependency on enterprise; the enterprise
+ * config remains assignable to this.
+ */
+export type GridPivotConfig<TData = RowData> = {
+    /** Row-axis dimensions, outer-most first. */
+    rows: ReadonlyArray<keyof TData & string>;
+    /** Column-axis dimensions, outer-most first. */
+    cols: ReadonlyArray<keyof TData & string>;
+    /** One or more measures aggregated under each column-axis leaf. */
+    values: ReadonlyArray<GridPivotValue<TData>>;
+    grandTotalRow?: boolean;
+    grandTotalCol?: boolean;
+    rowSubtotals?: boolean;
+    colSort?: (a: unknown, b: unknown, level: number) => number;
+    rowSort?: (a: unknown, b: unknown, level: number) => number;
+};
+/** A pivot row as emitted by the engine (plain object, keyed by leaf column id). */
+export type GridPivotRow = Record<string, unknown> & {
+    __pivotId: string;
+    __pivotDepth: number;
+    __pivotLabel: string;
+    __pivotParentId: string | null;
+    __pivotExpandable: boolean;
+};
+/** The registered pivot engine: pure `(data, config) => { rows, columns }`. */
+export type PivotEngine = <TFeatures extends TableFeatures = TableFeatures, TData extends RowData = RowData>(data: ReadonlyArray<TData>, config: GridPivotConfig<TData>) => {
+    rows: GridPivotRow[];
+    columns: Array<ColumnDef<TFeatures, GridPivotRow>>;
+};
+/** Register the pivot engine. Enterprise calls this from `enablePivot()`. */
+export declare function registerPivotEngine(fn: PivotEngine): void;
+/** The registered pivot engine, or null when enterprise is not installed. */
+export declare function getPivotEngine(): PivotEngine | null;
+/** Whether a pivot engine has been registered. */
+export declare function hasPivotEngine(): boolean;

package/dist/pivot-view.svelte.js

@@ -0,0 +1,13 @@
+let engine = $state(null);
+/** Register the pivot engine. Enterprise calls this from `enablePivot()`. */
+export function registerPivotEngine(fn) {
+    engine = fn;
+}
+/** The registered pivot engine, or null when enterprise is not installed. */
+export function getPivotEngine() {
+    return engine;
+}
+/** Whether a pivot engine has been registered. */
+export function hasPivotEngine() {
+    return engine != null;
+}