@svgrid/grid 2.2.16 → 2.2.17

package/dist/positioning.d.ts

@@ -0,0 +1,111 @@
+/**
+ * positioning - a small, dependency-free anchor-positioning engine for the
+ * overlay layer (popover, tooltip, menu, dropdowns). It replaces the vertical-
+ * flip-only `anchoredRect` for components that need the full placement matrix.
+ *
+ * Two halves:
+ *
+ * 1. `computePosition(reference, floating, options)` - PURE geometry. Given the
+ *    reference rect and the floating size (plus a viewport), it returns the
+ *    floating `x`/`y`, the resolved `placement` (after flip), the arrow offset,
+ *    and the available `maxWidth`/`maxHeight` on the chosen side. No DOM, so it
+ *    is fully unit-tested by feeding rects and asserting placement.
+ *
+ * 2. `autoUpdate(referenceEl, floatingEl, update)` - the browser half. Re-runs
+ *    `update` whenever the reference/floating resize, an ancestor scrolls, or the
+ *    window resizes (via `ResizeObserver` + scroll/resize listeners). SSR-safe
+ *    (a no-op without `window`).
+ *
+ * The middleware (flip / shift / size / arrow) is implemented inline - no
+ * Floating-UI dependency - matching the kit's zero-runtime-dep posture.
+ */
+/** A physical side the floating element is placed on, relative to the reference. */
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+/** Cross-axis alignment. `center` is the bare side (e.g. `'bottom'`). */
+export type Align = 'start' | 'center' | 'end';
+/** `'bottom'` = bottom-center; `'bottom-start'` / `'bottom-end'` align the edges. */
+export type Placement = Side | `${Side}-start` | `${Side}-end`;
+/** A viewport-relative rectangle (CSS `getBoundingClientRect` shape suffices). */
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** The available viewport (defaults to `window` in the browser). */
+export type Viewport = {
+    width: number;
+    height: number;
+};
+export type ComputePositionOptions = {
+    /** Preferred placement. Default `'bottom-start'`. */
+    placement?: Placement;
+    /** Main-axis gap between reference and floating. Default 6. */
+    offset?: number;
+    /** Viewport edge kept clear on every side. Default 8. */
+    padding?: number;
+    /** Flip to the opposite side when the preferred side overflows. Default true. */
+    flip?: boolean;
+    /** Shift along the cross axis to stay in view (without flipping). Default true. */
+    shift?: boolean;
+    /** Compute `maxWidth`/`maxHeight` for the chosen side. Default true. */
+    size?: boolean;
+    /** When set, compute the arrow offset for an arrow element of this size (px). */
+    arrow?: {
+        size: number;
+    };
+    /** Extra placements to try (after the automatic opposite) before giving up. */
+    fallbackPlacements?: Placement[];
+    /** Viewport to fit within. Defaults to the window; pure callers pass it. */
+    viewport?: Viewport;
+    /** Floor for the available main-axis size returned by `size`. Default 0. */
+    minMainAxis?: number;
+};
+export type ComputePositionResult = {
+    /** Floating left, in viewport (fixed-position) coordinates. */
+    x: number;
+    /** Floating top, in viewport (fixed-position) coordinates. */
+    y: number;
+    /** The resolved placement after flip. */
+    placement: Placement;
+    /** The resolved side after flip. */
+    side: Side;
+    /** The resolved cross-axis alignment. */
+    align: Align;
+    /** Space available for the floating on the chosen side's main axis (+cross). */
+    maxWidth: number;
+    maxHeight: number;
+    /**
+     * Arrow offset within the floating box: `x` for top/bottom placements, `y` for
+     * left/right. Only present when `options.arrow` is set. Clamped so the arrow
+     * stays inside the floating (minus padding).
+     */
+    arrow?: {
+        x?: number;
+        y?: number;
+    };
+};
+/** Split a placement into its side + alignment (`center` when no suffix). */
+export declare function parsePlacement(p: Placement): {
+    side: Side;
+    align: Align;
+};
+/**
+ * Compute the floating position anchored to `reference`, applying flip (opposite
+ * side when the preferred side overflows), shift (cross-axis clamp to stay in
+ * view), size (available max width/height on the chosen side) and an optional
+ * arrow offset. Pure - pass an explicit `viewport` in tests.
+ */
+export declare function computePosition(reference: Rect, floating: Viewport, options?: ComputePositionOptions): ComputePositionResult;
+/**
+ * Re-run `update` whenever the anchored position could change: the reference or
+ * floating element resizes, an ancestor scrolls, or the window scrolls/resizes.
+ * Returns a cleanup function. SSR-safe (a no-op without `window`).
+ *
+ * ```ts
+ * const stop = autoUpdate(triggerEl, panelEl, () => reposition())
+ * // ...later
+ * stop()
+ * ```
+ */
+export declare function autoUpdate(reference: Element, floating: HTMLElement, update: () => void): () => void;

package/dist/positioning.js

@@ -0,0 +1,191 @@
+/**
+ * positioning - a small, dependency-free anchor-positioning engine for the
+ * overlay layer (popover, tooltip, menu, dropdowns). It replaces the vertical-
+ * flip-only `anchoredRect` for components that need the full placement matrix.
+ *
+ * Two halves:
+ *
+ * 1. `computePosition(reference, floating, options)` - PURE geometry. Given the
+ *    reference rect and the floating size (plus a viewport), it returns the
+ *    floating `x`/`y`, the resolved `placement` (after flip), the arrow offset,
+ *    and the available `maxWidth`/`maxHeight` on the chosen side. No DOM, so it
+ *    is fully unit-tested by feeding rects and asserting placement.
+ *
+ * 2. `autoUpdate(referenceEl, floatingEl, update)` - the browser half. Re-runs
+ *    `update` whenever the reference/floating resize, an ancestor scrolls, or the
+ *    window resizes (via `ResizeObserver` + scroll/resize listeners). SSR-safe
+ *    (a no-op without `window`).
+ *
+ * The middleware (flip / shift / size / arrow) is implemented inline - no
+ * Floating-UI dependency - matching the kit's zero-runtime-dep posture.
+ */
+const SIDES = { top: 'bottom', bottom: 'top', left: 'right', right: 'left' };
+/** Split a placement into its side + alignment (`center` when no suffix). */
+export function parsePlacement(p) {
+    const [side, align] = p.split('-');
+    return { side, align: align ?? 'center' };
+}
+function opposite(p) {
+    const { side, align } = parsePlacement(p);
+    return (align === 'center' ? SIDES[side] : `${SIDES[side]}-${align}`);
+}
+function clamp(v, min, max) {
+    if (max < min)
+        return min;
+    return v < min ? min : v > max ? max : v;
+}
+/** Floating x/y for a given side+align (before flip/shift). */
+function coordsFor(side, align, r, f, offset) {
+    if (side === 'top' || side === 'bottom') {
+        const y = side === 'top' ? r.y - f.height - offset : r.y + r.height + offset;
+        const x = align === 'start' ? r.x : align === 'end' ? r.x + r.width - f.width : r.x + r.width / 2 - f.width / 2;
+        return { x, y };
+    }
+    const x = side === 'left' ? r.x - f.width - offset : r.x + r.width + offset;
+    const y = align === 'start' ? r.y : align === 'end' ? r.y + r.height - f.height : r.y + r.height / 2 - f.height / 2;
+    return { x, y };
+}
+/** How far the floating exceeds the viewport on the placement's MAIN axis. >0 = overflow. */
+function mainAxisOverflow(side, x, y, f, v, pad) {
+    switch (side) {
+        case 'top':
+            return pad - y;
+        case 'bottom':
+            return y + f.height - (v.height - pad);
+        case 'left':
+            return pad - x;
+        default:
+            return x + f.width - (v.width - pad);
+    }
+}
+function resolveViewport(v) {
+    if (v)
+        return v;
+    if (typeof window !== 'undefined')
+        return { width: window.innerWidth, height: window.innerHeight };
+    return { width: 0, height: 0 };
+}
+/**
+ * Compute the floating position anchored to `reference`, applying flip (opposite
+ * side when the preferred side overflows), shift (cross-axis clamp to stay in
+ * view), size (available max width/height on the chosen side) and an optional
+ * arrow offset. Pure - pass an explicit `viewport` in tests.
+ */
+export function computePosition(reference, floating, options = {}) {
+    const offset = options.offset ?? 6;
+    const pad = options.padding ?? 8;
+    const doFlip = options.flip !== false;
+    const doShift = options.shift !== false;
+    const v = resolveViewport(options.viewport);
+    const preferred = options.placement ?? 'bottom-start';
+    // ---- flip: pick the placement whose main-axis overflow is smallest ----
+    const candidates = [preferred];
+    if (doFlip) {
+        candidates.push(opposite(preferred));
+        for (const fb of options.fallbackPlacements ?? [])
+            candidates.push(fb);
+    }
+    let chosen = preferred;
+    let best = Infinity;
+    for (const cand of candidates) {
+        const { side, align } = parsePlacement(cand);
+        const { x, y } = coordsFor(side, align, reference, floating, offset);
+        const overflow = mainAxisOverflow(side, x, y, floating, v, pad);
+        if (overflow <= 0) {
+            chosen = cand;
+            best = overflow;
+            break;
+        }
+        if (overflow < best) {
+            best = overflow;
+            chosen = cand;
+        }
+    }
+    const { side, align } = parsePlacement(chosen);
+    let { x, y } = coordsFor(side, align, reference, floating, offset);
+    // ---- shift: clamp along the CROSS axis so the floating stays in view ----
+    if (doShift) {
+        if (side === 'top' || side === 'bottom') {
+            x = clamp(x, pad, v.width - pad - floating.width);
+        }
+        else {
+            y = clamp(y, pad, v.height - pad - floating.height);
+        }
+    }
+    // ---- size: available room on the chosen side ----
+    const minMain = options.minMainAxis ?? 0;
+    let maxWidth;
+    let maxHeight;
+    if (side === 'top' || side === 'bottom') {
+        const avail = side === 'top' ? reference.y - offset - pad : v.height - pad - (reference.y + reference.height + offset);
+        maxHeight = Math.max(minMain, Math.floor(avail));
+        maxWidth = Math.max(0, v.width - 2 * pad);
+    }
+    else {
+        const avail = side === 'left' ? reference.x - offset - pad : v.width - pad - (reference.x + reference.width + offset);
+        maxWidth = Math.max(minMain, Math.floor(avail));
+        maxHeight = Math.max(0, v.height - 2 * pad);
+    }
+    const result = { x, y, placement: chosen, side, align, maxWidth, maxHeight };
+    // ---- arrow: point at the reference center, clamped inside the floating ----
+    if (options.arrow) {
+        const a = options.arrow.size;
+        if (side === 'top' || side === 'bottom') {
+            const center = reference.x + reference.width / 2;
+            const ax = clamp(center - x - a / 2, pad, floating.width - a - pad);
+            result.arrow = { x: ax };
+        }
+        else {
+            const center = reference.y + reference.height / 2;
+            const ay = clamp(center - y - a / 2, pad, floating.height - a - pad);
+            result.arrow = { y: ay };
+        }
+    }
+    return result;
+}
+/** Collect scrollable ancestors so `autoUpdate` can listen to their scroll. */
+function scrollParents(node) {
+    const out = [];
+    let el = node.parentElement;
+    while (el) {
+        const style = getComputedStyle(el);
+        if (/(auto|scroll|overlay|hidden)/.test(style.overflow + style.overflowY + style.overflowX))
+            out.push(el);
+        el = el.parentElement;
+    }
+    return out;
+}
+/**
+ * Re-run `update` whenever the anchored position could change: the reference or
+ * floating element resizes, an ancestor scrolls, or the window scrolls/resizes.
+ * Returns a cleanup function. SSR-safe (a no-op without `window`).
+ *
+ * ```ts
+ * const stop = autoUpdate(triggerEl, panelEl, () => reposition())
+ * // ...later
+ * stop()
+ * ```
+ */
+export function autoUpdate(reference, floating, update) {
+    if (typeof window === 'undefined')
+        return () => { };
+    const ancestors = scrollParents(reference);
+    for (const a of ancestors)
+        a.addEventListener('scroll', update, { passive: true });
+    window.addEventListener('scroll', update, { passive: true });
+    window.addEventListener('resize', update);
+    let ro;
+    if (typeof ResizeObserver === 'function') {
+        ro = new ResizeObserver(update);
+        ro.observe(reference);
+        ro.observe(floating);
+    }
+    update();
+    return () => {
+        for (const a of ancestors)
+            a.removeEventListener('scroll', update);
+        window.removeEventListener('scroll', update);
+        window.removeEventListener('resize', update);
+        ro?.disconnect();
+    };
+}

package/dist/scheduler-model.d.ts

@@ -52,6 +52,9 @@ export type RecurrenceException = {
     end?: DateLike | null;
     title?: string;
     allDay?: boolean;
+    /** Per-occurrence overrides for any other field, merged over the row for just
+     *  this occurrence (attendees, calendar, color, resource, ...). */
+    fields?: Record<string, unknown>;
 };
 /** Field accessors the model uses to read an event off a row. The component
  *  builds this from `SchedulerConfig`, applying its move/edit overlay first so

package/dist/scheduler-model.js

@@ -140,6 +140,14 @@ export function resolveEvents(rows, spec, rangeStart, rangeEnd) {
                 let iEnd = new Date(occStart.getTime() + durationMs);
                 let iTitle = title;
                 let iAllDay = allDay;
+                // Per-occurrence overrides of ANY other field: merge onto a copy of the
+                // row for this instance, then re-derive the surfaced props from it so a
+                // "This event" change to attendees / calendar / color / resource shows.
+                let iRow = row;
+                let iColor = color;
+                let iColor2 = color2;
+                let iStatus = status;
+                let iResource = resourceId;
                 if (ex) {
                     const exS = toDate(ex.start);
                     const exE = toDate(ex.end);
@@ -154,6 +162,15 @@ export function resolveEvents(rows, spec, rangeStart, rangeEnd) {
                         iTitle = ex.title;
                     if (ex.allDay != null)
                         iAllDay = ex.allDay;
+                    if (ex.fields) {
+                        iRow = { ...row, ...ex.fields };
+                        iColor = spec.getColor?.(iRow) ?? color;
+                        iColor2 = spec.getSecondaryColor?.(iRow) ?? color2;
+                        iStatus = spec.getStatus?.(iRow) ?? status;
+                        iResource = spec.getResource?.(iRow) ?? resourceId;
+                        if (ex.title == null)
+                            iTitle = spec.getTitle?.(iRow) ?? iTitle;
+                    }
                 }
                 if (!rangesOverlap(iStart, iEnd, rangeStart, rangeEnd))
                     continue;
@@ -161,15 +178,15 @@ export function resolveEvents(rows, spec, rangeStart, rangeEnd) {
                     // Key on the CANONICAL occurrence start so a moved occurrence keeps its identity.
                     key: `${rowKey}#${occStart.getFullYear()}-${occStart.getMonth() + 1}-${occStart.getDate()}T${occStart.getHours()}:${occStart.getMinutes()}`,
                     rowKey,
-                    row,
+                    row: iRow,
                     title: iTitle,
                     start: iStart,
                     end: iEnd,
                     allDay: iAllDay,
-                    color,
-                    color2,
-                    status,
-                    resourceId,
+                    color: iColor,
+                    color2: iColor2,
+                    status: iStatus,
+                    resourceId: iResource,
                     recurring: true,
                     occurrenceStart: occStart,
                     isException: !!ex,

package/dist/svgrid-wrapper.types.d.ts

@@ -1,4 +1,5 @@
 import type { CellFormatConfig, ColumnDef, RowData, SvGridOptions, TableFeatures } from './core';
+import type { Props } from './SvGrid.types';
 import type { GridExportOptions, GridClipboardOptions } from './export-format';
 import type { ChartSpec, ChartType } from './chart';
 export type SvGridFilterOperator = 'contains' | 'equals' | 'startsWith' | 'greaterThan' | 'lessThan' | 'between' | 'isBlank';
@@ -168,6 +169,23 @@ export type SvGridApi<TFeatures extends TableFeatures, TData extends RowData> =
     setSort(columnId: string, direction: 'asc' | 'desc' | null): void;
     clearSort(): void;
     setGroupBy(columnIds: ReadonlyArray<string>): void;
+    /**
+     * Change a grid prop at runtime, e.g. `api.setOption('sortable', true)`. The
+     * override is merged over the incoming prop and the grid re-renders reactively -
+     * identical to the parent passing a new prop value. Pass `undefined` to clear the
+     * override and fall back to the prop.
+     *
+     * Note: seed-once props are NOT retroactive - `initialSorting`,
+     * `initialColumnPinning`, `initialHiddenColumns`, `columnOrder`, the initial
+     * `pageSize`, and the one-shot `externalSort` / `externalFilter` are read at mount,
+     * so overriding them later has no effect. Prefer the dedicated data path for
+     * `data` / `columns` (this works, but the sync effects are the idiomatic route).
+     */
+    setOption<K extends keyof Props<TFeatures, TData>>(key: K, value: Props<TFeatures, TData>[K] | undefined): void;
+    /** Read a prop's effective value: the runtime override if set, else the incoming prop. */
+    getOption<K extends keyof Props<TFeatures, TData>>(key: K): Props<TFeatures, TData>[K];
+    /** Clear every runtime override set via `setOption`, reverting to the incoming props. */
+    resetOptions(): void;
     /** Set the operator filter for a column. Pass `null` to clear. */
     setFilter(columnId: string, filter: {
         operator: SvGridFilterOperator;

package/dist/toast-store.svelte.d.ts

@@ -1,4 +1,28 @@
+/**
+ * toast-store - the headless model behind <SvToaster>: a singleton reactive
+ * queue of transient notifications with auto-dismiss timers, plus the `toast()`
+ * API you call from anywhere. Every toast is also pushed to the shared ARIA
+ * live region via `announce()`, so screen-reader users hear it even though the
+ * visual toast is off to the side.
+ *
+ * ```ts
+ * import { toast } from '@svgrid/grid'
+ * toast.success('Saved')
+ * toast.error('Could not save', { duration: 0 }) // sticky
+ * ```
+ *
+ * Mount a single <SvToaster /> once near the app root to render the queue.
+ */
+import type { Snippet } from 'svelte';
 export type ToastVariant = 'info' | 'success' | 'warning' | 'error';
+/** A button rendered inside a toast (a primary `action` or a secondary `cancel`). */
+export type ToastAction = {
+    label: string;
+    /** Invoked with the toast id when pressed. */
+    onClick?: (id: number) => void;
+    /** Keep the toast open after the click (default: dismiss it). */
+    keepOpen?: boolean;
+};
 export type ToastOptions = {
     variant?: ToastVariant;
     /** Auto-dismiss after N ms. `0` = sticky (dismiss manually). Default 4000. */
@@ -7,6 +31,12 @@ export type ToastOptions = {
     dismissible?: boolean;
     /** Optional bold title above the message. */
     title?: string;
+    /** Primary action button. */
+    action?: ToastAction;
+    /** Secondary (cancel) action button. */
+    cancel?: ToastAction;
+    /** Render a fully custom toast body instead of the icon + title + message. */
+    render?: Snippet<[Toast]>;
 };
 export type Toast = {
     id: number;
@@ -15,6 +45,17 @@ export type Toast = {
     duration: number;
     dismissible: boolean;
     title?: string;
+    action?: ToastAction;
+    cancel?: ToastAction;
+    render?: Snippet<[Toast]>;
+};
+/** Patch applied by `toast.update(id, patch)`; every field is optional. */
+export type UpdateToast = Partial<Omit<Toast, 'id'>>;
+/** Messages for `toast.promise`; success/error may derive from the value/error. */
+export type PromiseMessages<T> = {
+    loading: string;
+    success: string | ((value: T) => string);
+    error: string | ((error: unknown) => string);
 };
 type VariantOptions = Omit<ToastOptions, 'variant'>;
 export type ToastFn = {
@@ -23,6 +64,17 @@ export type ToastFn = {
     success: (message: string, options?: VariantOptions) => number;
     warning: (message: string, options?: VariantOptions) => number;
     error: (message: string, options?: VariantOptions) => number;
+    /**
+     * Show a sticky loading toast, then update it IN PLACE to success/error when
+     * the promise settles. Returns the original promise so callers can await it.
+     */
+    promise: <T>(promise: Promise<T>, messages: PromiseMessages<T>, options?: ToastOptions) => Promise<T>;
+    /** Patch an existing toast (message/variant/title/action/duration/render). */
+    update: (id: number, patch: UpdateToast) => void;
+    /** Push a toast with a fully custom body snippet. Returns its id. */
+    custom: (render: Snippet<[Toast]>, options?: ToastOptions) => number;
+    /** Dismiss a toast by id. */
+    dismiss: (id: number) => void;
 };
 /** Live reactive list of active toasts (read inside a component/effect). */
 export declare const toastStore: {
@@ -32,6 +84,8 @@ export declare const toastStore: {
 export declare const toast: ToastFn;
 /** Dismiss a toast by id. */
 export declare const dismissToast: (id: number) => void;
+/** Patch an existing toast in place (message/variant/title/action/duration/render). */
+export declare const updateToast: (id: number, patch: UpdateToast) => void;
 /** Remove every toast (and cancel their timers). */
 export declare const clearToasts: () => void;
 /** Pause a toast's auto-dismiss countdown (e.g. while hovered). */

package/dist/toast-store.svelte.js

@@ -1,18 +1,3 @@
-/**
- * toast-store - the headless model behind <SvToaster>: a singleton reactive
- * queue of transient notifications with auto-dismiss timers, plus the `toast()`
- * API you call from anywhere. Every toast is also pushed to the shared ARIA
- * live region via `announce()`, so screen-reader users hear it even though the
- * visual toast is off to the side.
- *
- * ```ts
- * import { toast } from '@svgrid/grid'
- * toast.success('Saved')
- * toast.error('Could not save', { duration: 0 }) // sticky
- * ```
- *
- * Mount a single <SvToaster /> once near the app root to render the queue.
- */
 import { announce } from './a11y/live-region';
 function createToastStore() {
     const toasts = $state([]);
@@ -72,6 +57,9 @@ function createToastStore() {
             duration,
             dismissible: options.dismissible ?? true,
             title: options.title,
+            action: options.action,
+            cancel: options.cancel,
+            render: options.render,
         };
         toasts.push(entry);
         // Errors/warnings interrupt (assertive); info/success are polite.
@@ -82,16 +70,76 @@ function createToastStore() {
             schedule(id, duration);
         return id;
     }
+    /** Patch an existing toast in place (used by `promise`, and callable directly). */
+    function update(id, patch) {
+        const t = toasts.find((x) => x.id === id);
+        if (!t)
+            return;
+        if (patch.message != null)
+            t.message = patch.message;
+        if (patch.title !== undefined)
+            t.title = patch.title;
+        if (patch.variant)
+            t.variant = patch.variant;
+        if (patch.dismissible !== undefined)
+            t.dismissible = patch.dismissible;
+        if (patch.action !== undefined)
+            t.action = patch.action;
+        if (patch.cancel !== undefined)
+            t.cancel = patch.cancel;
+        if (patch.render !== undefined)
+            t.render = patch.render;
+        // A new duration restarts the auto-dismiss timer (0 = make it sticky again).
+        if (patch.duration !== undefined) {
+            const timer = timers.get(id);
+            if (timer) {
+                clearTimeout(timer);
+                timers.delete(id);
+            }
+            meta.delete(id);
+            t.duration = patch.duration;
+            if (patch.duration > 0)
+                schedule(id, patch.duration);
+        }
+        announce(t.title ? `${t.title}: ${t.message}` : t.message, {
+            assertive: t.variant === 'error' || t.variant === 'warning',
+        });
+    }
+    function promise(p, messages, options = {}) {
+        const id = push(messages.loading, {
+            ...options,
+            variant: 'info',
+            duration: 0,
+            dismissible: options.dismissible ?? false,
+        });
+        p.then((value) => update(id, {
+            message: typeof messages.success === 'function' ? messages.success(value) : messages.success,
+            variant: 'success',
+            duration: options.duration ?? 4000,
+            dismissible: true,
+        }), (error) => update(id, {
+            message: typeof messages.error === 'function' ? messages.error(error) : messages.error,
+            variant: 'error',
+            duration: options.duration ?? 6000,
+            dismissible: true,
+        }));
+        return p;
+    }
     const toast = push;
     toast.info = (m, o = {}) => push(m, { ...o, variant: 'info' });
     toast.success = (m, o = {}) => push(m, { ...o, variant: 'success' });
     toast.warning = (m, o = {}) => push(m, { ...o, variant: 'warning' });
     toast.error = (m, o = {}) => push(m, { ...o, variant: 'error' });
+    toast.promise = promise;
+    toast.update = update;
+    toast.custom = (render, o = {}) => push('', { ...o, render });
+    toast.dismiss = dismiss;
     return {
         get toasts() {
             return toasts;
         },
         toast,
+        update,
         dismiss,
         clear,
         pause,
@@ -105,6 +153,8 @@ export const toastStore = { get toasts() { return store.toasts; } };
 export const toast = store.toast;
 /** Dismiss a toast by id. */
 export const dismissToast = (id) => store.dismiss(id);
+/** Patch an existing toast in place (message/variant/title/action/duration/render). */
+export const updateToast = (id, patch) => store.update(id, patch);
 /** Remove every toast (and cancel their timers). */
 export const clearToasts = () => store.clear();
 /** Pause a toast's auto-dismiss countdown (e.g. while hovered). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svgrid/grid",
-  "version": "2.2.16",
+  "version": "2.2.17",
   "description": "SvGrid - a headless-first, Svelte 5-native data grid engine and render component.",
   "author": "jQWidgets <boikom@jqwidgets.com>",
   "license": "MIT",
@@ -22,6 +22,9 @@
     "datagrid"
   ],
   "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
   "svelte": "./dist/index.js",
@@ -51,6 +54,11 @@
       "svelte": "./dist/export-format.js",
       "import": "./dist/export-format.js"
     },
+    "./filtering": {
+      "types": "./dist/filtering/excel-filters.d.ts",
+      "svelte": "./dist/filtering/excel-filters.js",
+      "import": "./dist/filtering/excel-filters.js"
+    },
     "./flex-render": {
       "types": "./dist/flex-render.d.ts",
       "svelte": "./dist/flex-render.js",