@svgrid/grid 2.1.21 → 2.1.23

package/dist/dock-model.d.ts

@@ -0,0 +1,105 @@
+/**
+ * dock-model - the pure, immutable tree behind <SvDockLayout>. A docking layout
+ * is a tree of two node kinds:
+ *
+ *   group  a row/column of children (nested groups or tab-leaves), each holding
+ *          a normalized `size` weight, with resizable splitters between them.
+ *   tabs   a leaf: one or more panes shown as tabs (only `active` is visible).
+ *
+ * Every restructuring a user does by dragging - dock a pane to a neighbour's
+ * edge (split) or centre (add as a tab), close a pane, drag a splitter - is a
+ * pure transform here that returns a NEW tree. The Svelte view owns the DOM and
+ * the drag gestures; all the tree surgery lives here so it is unit-testable
+ * without a browser. Modelled on Smart's `smart-layout` group/item structure.
+ */
+export type DockPane = {
+    id: string;
+    title: string;
+    /** Show a close (x) affordance on the tab. Default true. */
+    closable?: boolean;
+    /** Minimum size (px) for this pane's leaf along the split axis. */
+    minSize?: number;
+};
+/** A leaf: a stack of panes rendered as tabs (`active` is the visible one). */
+export type DockTabs = {
+    type: 'tabs';
+    id: string;
+    panes: DockPane[];
+    active: number;
+};
+/** A row (side-by-side) or column (stacked) of children with per-child sizes. */
+export type DockGroup = {
+    type: 'group';
+    id: string;
+    direction: 'row' | 'column';
+    children: DockNode[];
+    /** Size weight per child; parallel to `children`, normalized to sum ~1. */
+    sizes: number[];
+};
+export type DockNode = DockGroup | DockTabs;
+/** Where a dragged pane lands relative to a target leaf. */
+export type DockZone = 'left' | 'right' | 'top' | 'bottom' | 'center';
+export type IdGen = () => string;
+export declare function pane(id: string, title: string, closable?: boolean): DockPane;
+/** Largest per-pane `minSize` in a leaf (0 if none). Used by splitter clamping. */
+export declare function leafMinSize(node: DockTabs): number;
+export declare function tabs(genId: IdGen, panes: DockPane[], active?: number): DockTabs;
+export declare function group(genId: IdGen, direction: 'row' | 'column', children: DockNode[], sizes?: number[]): DockGroup;
+/** Return sizes summing to 1, padded/trimmed to `count`. Even split when absent. */
+export declare function normalizeSizes(sizes: number[] | undefined, count: number): number[];
+/** The tabs leaf that holds `paneId`, or null. */
+export declare function findTabsWithPane(root: DockNode, paneId: string): DockTabs | null;
+/** Every pane id in the tree, in document order. */
+export declare function allPaneIds(root: DockNode): string[];
+/**
+ * Collapse the tree after edits: drop empty tabs and empty groups, unwrap a
+ * group that has a single child, and flatten a child group into its parent when
+ * they share a direction (so repeated docking never nests infinitely deep).
+ * Returns the tidied node, or null when nothing is left.
+ */
+export declare function normalize(node: DockNode): DockNode | null;
+/** Set the active tab index of a tabs leaf. */
+export declare function setActive(root: DockNode, tabsId: string, active: number): DockNode;
+/** Replace a group's size weights (e.g. after a splitter drag). */
+export declare function setSizes(root: DockNode, groupId: string, sizes: number[]): DockNode;
+/**
+ * Reorder a pane WITHIN its tabs leaf (dragging a tab along the strip). `active`
+ * follows the pane that was showing. No-op if the indices are out of range.
+ */
+export declare function reorderPane(root: DockNode, tabsId: string, from: number, to: number): DockNode;
+/**
+ * Remove a pane. Returns the tidied tree (or null if it emptied) plus the pane
+ * that was pulled out, so a caller can re-dock it elsewhere.
+ */
+export declare function removePane(root: DockNode, paneId: string): {
+    root: DockNode | null;
+    pane: DockPane | null;
+};
+/**
+ * Dock `movingPane` relative to the leaf `targetTabsId`. `center` adds it as a
+ * tab; an edge splits: the target is wrapped in (or extended into) a group whose
+ * direction matches the edge, with the new pane on the requested side.
+ */
+export declare function dockInto(root: DockNode, targetTabsId: string, movingPane: DockPane, zone: DockZone, genId: IdGen): DockNode;
+/** Pull a whole tabs leaf out of the tree (for auto-hide). Returns the tidied
+ *  tree (or null) plus the extracted leaf. */
+export declare function removeLeaf(root: DockNode, tabsId: string): {
+    root: DockNode | null;
+    leaf: DockTabs | null;
+};
+/** Dock a whole leaf against an EDGE of the entire tree (for pinning an
+ *  auto-hidden panel back in). Wraps the root in a new group as needed; the
+ *  pinned leaf takes `fraction` of that axis (clamped 0.1..0.6), the rest keeps
+ *  the existing content. */
+export declare function dockLeafToEdge(root: DockNode | null, leaf: DockTabs, side: Exclude<DockZone, 'center'>, genId: IdGen, fraction?: number): DockNode;
+/** Move an existing pane to a new dock position (remove then dock). */
+export declare function movePane(root: DockNode, paneId: string, targetTabsId: string, zone: DockZone, genId: IdGen): DockNode;
+/** A pane (tab). Alias of `pane`, named for the public builder set. */
+export declare function dockPane(id: string, title: string, opts?: boolean | {
+    closable?: boolean;
+    minSize?: number;
+}): DockPane;
+/** A tab-leaf holding one or more panes. */
+export declare function dockTabs(panes: DockPane[], active?: number): DockTabs;
+/** A row (side-by-side) or column (stacked) of children. */
+export declare function dockGroup(direction: 'row' | 'column', children: DockNode[], sizes?: number[]): DockGroup;

package/dist/dock-model.js

@@ -0,0 +1,288 @@
+/**
+ * dock-model - the pure, immutable tree behind <SvDockLayout>. A docking layout
+ * is a tree of two node kinds:
+ *
+ *   group  a row/column of children (nested groups or tab-leaves), each holding
+ *          a normalized `size` weight, with resizable splitters between them.
+ *   tabs   a leaf: one or more panes shown as tabs (only `active` is visible).
+ *
+ * Every restructuring a user does by dragging - dock a pane to a neighbour's
+ * edge (split) or centre (add as a tab), close a pane, drag a splitter - is a
+ * pure transform here that returns a NEW tree. The Svelte view owns the DOM and
+ * the drag gestures; all the tree surgery lives here so it is unit-testable
+ * without a browser. Modelled on Smart's `smart-layout` group/item structure.
+ */
+// ---- construction helpers -------------------------------------------------
+export function pane(id, title, closable = true) {
+    return { id, title, closable };
+}
+/** Largest per-pane `minSize` in a leaf (0 if none). Used by splitter clamping. */
+export function leafMinSize(node) {
+    return node.panes.reduce((m, p) => Math.max(m, p.minSize ?? 0), 0);
+}
+export function tabs(genId, panes, active = 0) {
+    return { type: 'tabs', id: genId(), panes, active: clampIndex(active, panes.length) };
+}
+export function group(genId, direction, children, sizes) {
+    return { type: 'group', id: genId(), direction, children, sizes: normalizeSizes(sizes, children.length) };
+}
+// ---- small utilities ------------------------------------------------------
+function clampIndex(i, len) {
+    if (len <= 0)
+        return 0;
+    return Math.max(0, Math.min(i, len - 1));
+}
+/** Return sizes summing to 1, padded/trimmed to `count`. Even split when absent. */
+export function normalizeSizes(sizes, count) {
+    if (count <= 0)
+        return [];
+    const src = sizes && sizes.length === count ? sizes.slice() : new Array(count).fill(1);
+    const total = src.reduce((a, b) => a + (b > 0 ? b : 0), 0);
+    if (total <= 0)
+        return new Array(count).fill(1 / count);
+    return src.map((s) => (s > 0 ? s : 0) / total);
+}
+// ---- queries --------------------------------------------------------------
+/** The tabs leaf that holds `paneId`, or null. */
+export function findTabsWithPane(root, paneId) {
+    if (root.type === 'tabs')
+        return root.panes.some((p) => p.id === paneId) ? root : null;
+    for (const c of root.children) {
+        const hit = findTabsWithPane(c, paneId);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/** Every pane id in the tree, in document order. */
+export function allPaneIds(root) {
+    if (root.type === 'tabs')
+        return root.panes.map((p) => p.id);
+    return root.children.flatMap(allPaneIds);
+}
+// ---- normalization --------------------------------------------------------
+/**
+ * Collapse the tree after edits: drop empty tabs and empty groups, unwrap a
+ * group that has a single child, and flatten a child group into its parent when
+ * they share a direction (so repeated docking never nests infinitely deep).
+ * Returns the tidied node, or null when nothing is left.
+ */
+export function normalize(node) {
+    if (node.type === 'tabs') {
+        if (node.panes.length === 0)
+            return null;
+        return { ...node, active: clampIndex(node.active, node.panes.length) };
+    }
+    // Normalize children first, dropping the empties.
+    const kept = [];
+    const keptSizes = [];
+    node.children.forEach((child, i) => {
+        const n = normalize(child);
+        if (n) {
+            kept.push(n);
+            keptSizes.push(node.sizes[i] ?? 1);
+        }
+    });
+    if (kept.length === 0)
+        return null;
+    if (kept.length === 1)
+        return kept[0]; // unwrap single-child group
+    // Flatten same-direction child groups into this one.
+    const flatChildren = [];
+    const flatSizes = [];
+    kept.forEach((child, i) => {
+        if (child.type === 'group' && child.direction === node.direction) {
+            const share = keptSizes[i];
+            child.children.forEach((gc, j) => {
+                flatChildren.push(gc);
+                flatSizes.push(share * (child.sizes[j] ?? 1 / child.children.length));
+            });
+        }
+        else {
+            flatChildren.push(child);
+            flatSizes.push(keptSizes[i]);
+        }
+    });
+    return { ...node, children: flatChildren, sizes: normalizeSizes(flatSizes, flatChildren.length) };
+}
+// ---- mutations (return a new tree) ----------------------------------------
+/** Set the active tab index of a tabs leaf. */
+export function setActive(root, tabsId, active) {
+    return mapNodes(root, (n) => n.type === 'tabs' && n.id === tabsId ? { ...n, active: clampIndex(active, n.panes.length) } : n);
+}
+/** Replace a group's size weights (e.g. after a splitter drag). */
+export function setSizes(root, groupId, sizes) {
+    return mapNodes(root, (n) => n.type === 'group' && n.id === groupId ? { ...n, sizes: normalizeSizes(sizes, n.children.length) } : n);
+}
+/**
+ * Reorder a pane WITHIN its tabs leaf (dragging a tab along the strip). `active`
+ * follows the pane that was showing. No-op if the indices are out of range.
+ */
+export function reorderPane(root, tabsId, from, to) {
+    return mapNodes(root, (n) => {
+        if (n.type !== 'tabs' || n.id !== tabsId)
+            return n;
+        if (from < 0 || from >= n.panes.length)
+            return n;
+        const showing = n.panes[n.active]?.id;
+        const panes = n.panes.slice();
+        const [moved] = panes.splice(from, 1);
+        if (!moved)
+            return n;
+        // `to` is an insertion point in [0, length] (length = append), not a select
+        // index - clampIndex would wrongly cap it at length-1.
+        panes.splice(Math.max(0, Math.min(to, panes.length)), 0, moved);
+        const active = panes.findIndex((p) => p.id === showing);
+        return { ...n, panes, active: active < 0 ? 0 : active };
+    });
+}
+/**
+ * Remove a pane. Returns the tidied tree (or null if it emptied) plus the pane
+ * that was pulled out, so a caller can re-dock it elsewhere.
+ */
+export function removePane(root, paneId) {
+    let removed = null;
+    const strip = (node) => {
+        if (node.type === 'tabs') {
+            const idx = node.panes.findIndex((p) => p.id === paneId);
+            if (idx < 0)
+                return node;
+            removed = node.panes[idx];
+            const panes = node.panes.filter((_, i) => i !== idx);
+            return { ...node, panes, active: clampIndex(node.active > idx ? node.active - 1 : node.active, panes.length) };
+        }
+        return { ...node, children: node.children.map(strip) };
+    };
+    const stripped = strip(root);
+    return { root: normalize(stripped), pane: removed };
+}
+/**
+ * Dock `movingPane` relative to the leaf `targetTabsId`. `center` adds it as a
+ * tab; an edge splits: the target is wrapped in (or extended into) a group whose
+ * direction matches the edge, with the new pane on the requested side.
+ */
+export function dockInto(root, targetTabsId, movingPane, zone, genId) {
+    const dir = zone === 'left' || zone === 'right' ? 'row' : 'column';
+    const before = zone === 'left' || zone === 'top';
+    const transform = (node) => {
+        if (node.type === 'tabs') {
+            if (node.id !== targetTabsId)
+                return node;
+            if (zone === 'center') {
+                const panes = [...node.panes, movingPane];
+                return { ...node, panes, active: panes.length - 1 };
+            }
+            // Edge on a bare leaf: wrap it in a new group with the new leaf beside it.
+            const leaf = tabs(genId, [movingPane], 0);
+            const kids = before ? [leaf, node] : [node, leaf];
+            return group(genId, dir, kids);
+        }
+        // Group: if it directly contains the target leaf and matches the edge
+        // direction, insert a sibling in place (keeps the tree flat).
+        const idx = node.children.findIndex((c) => c.type === 'tabs' && c.id === targetTabsId);
+        if (idx >= 0 && zone !== 'center' && node.direction === dir) {
+            const leaf = tabs(genId, [movingPane], 0);
+            const children = node.children.slice();
+            const sizes = node.sizes.slice();
+            const half = (node.sizes[idx] ?? 1 / node.children.length) / 2;
+            const insertAt = before ? idx : idx + 1;
+            children.splice(insertAt, 0, leaf);
+            sizes.splice(idx, 1, half, half); // split the target's slot in two
+            // splice above replaced 1 with 2 at idx; the new leaf takes `before`/after
+            if (before) {
+                // children: [..., leaf, target, ...]; sizes already [half(leaf), half(target)]
+            }
+            else {
+                // we inserted leaf AFTER target but sizes are [half, half] at idx/idx+1 - correct
+            }
+            return { ...node, children, sizes: normalizeSizes(sizes, children.length) };
+        }
+        return { ...node, children: node.children.map(transform) };
+    };
+    return normalize(transform(root)) ?? root;
+}
+/** Pull a whole tabs leaf out of the tree (for auto-hide). Returns the tidied
+ *  tree (or null) plus the extracted leaf. */
+export function removeLeaf(root, tabsId) {
+    let taken = null;
+    const strip = (node) => {
+        if (node.type === 'tabs') {
+            if (node.id === tabsId) {
+                taken = node;
+                return null;
+            }
+            return node;
+        }
+        const kids = [];
+        const sizes = [];
+        node.children.forEach((c, i) => {
+            const n = strip(c);
+            if (n) {
+                kids.push(n);
+                sizes.push(node.sizes[i] ?? 1);
+            }
+        });
+        if (kids.length === 0)
+            return null;
+        return { ...node, children: kids, sizes: normalizeSizes(sizes, kids.length) };
+    };
+    const stripped = strip(root);
+    return { root: stripped ? normalize(stripped) : null, leaf: taken };
+}
+/** Dock a whole leaf against an EDGE of the entire tree (for pinning an
+ *  auto-hidden panel back in). Wraps the root in a new group as needed; the
+ *  pinned leaf takes `fraction` of that axis (clamped 0.1..0.6), the rest keeps
+ *  the existing content. */
+export function dockLeafToEdge(root, leaf, side, genId, fraction = 0.25) {
+    if (!root)
+        return leaf;
+    const dir = side === 'left' || side === 'right' ? 'row' : 'column';
+    const before = side === 'left' || side === 'top';
+    const f = Math.min(0.6, Math.max(0.1, fraction));
+    const kids = before ? [leaf, root] : [root, leaf];
+    const sizes = before ? [f, 1 - f] : [1 - f, f];
+    return normalize(group(genId, dir, kids, sizes)) ?? leaf;
+}
+/** Move an existing pane to a new dock position (remove then dock). */
+export function movePane(root, paneId, targetTabsId, zone, genId) {
+    const { root: without, pane: moved } = removePane(root, paneId);
+    if (!without || !moved)
+        return root;
+    // If removing the pane dissolved the target leaf (it was the pane's own
+    // single-pane leaf), there is nothing to dock against - leave the tree as-is.
+    if (!containsTabs(without, targetTabsId))
+        return root;
+    return dockInto(without, targetTabsId, moved, zone, genId);
+}
+function containsTabs(node, tabsId) {
+    if (node.type === 'tabs')
+        return node.id === tabsId;
+    return node.children.some((c) => containsTabs(c, tabsId));
+}
+// ---- internal -------------------------------------------------------------
+/** Map over every node, replacing where `fn` returns a new object. */
+function mapNodes(node, fn) {
+    const mapped = fn(node);
+    if (mapped.type === 'group') {
+        return { ...mapped, children: mapped.children.map((c) => mapNodes(c, fn)) };
+    }
+    return mapped;
+}
+// ---- consumer builders (auto ids) -----------------------------------------
+// Ergonomic constructors for building an initial layout without threading an
+// id generator. Node ids only need to be unique; a running counter suffices.
+let AUTO = 0;
+const autoId = () => `d${AUTO++}`;
+/** A pane (tab). Alias of `pane`, named for the public builder set. */
+export function dockPane(id, title, opts) {
+    const o = typeof opts === 'boolean' ? { closable: opts } : (opts ?? {});
+    return { id, title, closable: o.closable ?? true, ...(o.minSize != null ? { minSize: o.minSize } : {}) };
+}
+/** A tab-leaf holding one or more panes. */
+export function dockTabs(panes, active = 0) {
+    return tabs(autoId, panes, active);
+}
+/** A row (side-by-side) or column (stacked) of children. */
+export function dockGroup(direction, children, sizes) {
+    return group(autoId, direction, children, sizes);
+}

package/dist/dock-popout.d.ts

@@ -0,0 +1,30 @@
+/**
+ * dock-popout - open a real browser window and render a dock pane's content
+ * inside it (Golden-Layout-style pop-out). Runtime-only: an OS window handle is
+ * not serializable, so the manager tracks popped panes separately and pops them
+ * back into the layout when the window closes.
+ *
+ * The popped nodes are created by the main document and adopted into the popup,
+ * so they stay driven by the main window's reactivity - the pop-out shows the
+ * same live content as the docked view. Stylesheets + `--sg-*` theme tokens are
+ * copied across so it looks identical.
+ */
+import { type Snippet } from 'svelte';
+import type { DockPane } from './dock-model';
+export type Popout = {
+    pane: DockPane;
+    win: Window;
+    destroy: () => void;
+};
+export type OpenPopoutOptions = {
+    pane: DockPane;
+    paneSnippet: Snippet<[DockPane]>;
+    /** Element whose resolved `--sg-*` tokens theme the popup. */
+    themeSource: HTMLElement;
+    width?: number;
+    height?: number;
+    /** Called (once) when the popup closes, to pop the pane back in. */
+    onClose: (paneId: string) => void;
+};
+/** Open a pop-out window for a pane. Returns null if the browser blocked it. */
+export declare function openPopout(opts: OpenPopoutOptions): Popout | null;

package/dist/dock-popout.js

@@ -0,0 +1,81 @@
+/**
+ * dock-popout - open a real browser window and render a dock pane's content
+ * inside it (Golden-Layout-style pop-out). Runtime-only: an OS window handle is
+ * not serializable, so the manager tracks popped panes separately and pops them
+ * back into the layout when the window closes.
+ *
+ * The popped nodes are created by the main document and adopted into the popup,
+ * so they stay driven by the main window's reactivity - the pop-out shows the
+ * same live content as the docked view. Stylesheets + `--sg-*` theme tokens are
+ * copied across so it looks identical.
+ */
+import { mount, unmount } from 'svelte';
+import DockPopoutHost from './DockPopoutHost.svelte';
+import { PANEL_THEME_VARS } from './popover';
+/** Open a pop-out window for a pane. Returns null if the browser blocked it. */
+export function openPopout(opts) {
+    const win = window.open('', '', `width=${opts.width ?? 480},height=${opts.height ?? 360}`);
+    if (!win)
+        return null;
+    const doc = win.document;
+    doc.title = opts.pane.title;
+    // Copy every stylesheet so the popped content is styled identically.
+    for (const sheet of Array.from(document.styleSheets)) {
+        try {
+            const css = Array.from(sheet.cssRules).map((r) => r.cssText).join('\n');
+            const style = doc.createElement('style');
+            style.textContent = css;
+            doc.head.appendChild(style);
+        }
+        catch {
+            // Cross-origin sheet: re-link it instead of reading its rules.
+            if (sheet.href) {
+                const link = doc.createElement('link');
+                link.rel = 'stylesheet';
+                link.href = sheet.href;
+                doc.head.appendChild(link);
+            }
+        }
+    }
+    // Carry the theme tokens + base look across.
+    const cs = getComputedStyle(opts.themeSource);
+    for (const v of PANEL_THEME_VARS) {
+        const val = cs.getPropertyValue(v).trim();
+        if (val)
+            doc.documentElement.style.setProperty(v, val);
+    }
+    doc.body.style.margin = '0';
+    doc.body.style.background = cs.getPropertyValue('--sg-bg').trim() || '#fff';
+    doc.body.style.color = cs.getPropertyValue('--sg-fg').trim() || '#0f172a';
+    doc.body.style.font = cs.font;
+    const app = mount(DockPopoutHost, {
+        target: doc.body,
+        props: { pane: opts.paneSnippet, paneData: opts.pane },
+    });
+    let done = false;
+    const finish = (popBackIn) => {
+        if (done)
+            return;
+        done = true;
+        clearInterval(poll);
+        try {
+            unmount(app);
+        }
+        catch { /* window already tearing down */ }
+        if (popBackIn)
+            opts.onClose(opts.pane.id);
+    };
+    // The user closed the OS window -> pop the pane back into the layout.
+    win.addEventListener('beforeunload', () => finish(true));
+    const poll = setInterval(() => { if (win.closed)
+        finish(true); }, 400);
+    return {
+        pane: opts.pane,
+        win,
+        // Programmatic teardown (dock-back / manager unmount): don't re-pop-in.
+        destroy: () => { finish(false); try {
+            win.close();
+        }
+        catch { /* noop */ } },
+    };
+}

package/dist/editor-contract.d.ts

@@ -41,6 +41,8 @@ export type SvEditorProps = {
     id?: string;
     /** Accessible name when there is no visible `label`. */
     ariaLabel?: string;
+    /** Busy state - shows a spinner (e.g. while an async value/validation resolves). */
+    loading?: boolean;
 };
 /**
  * The interaction surface an editor exposes when embedded as a grid cell editor.

package/dist/filter-operators.d.ts

@@ -1,6 +1,12 @@
 import type { Column, RowData } from "./index";
 import type { FilterOperator, FilterOption } from "./SvGrid.types";
 export declare const filterOperatorOptions: Array<FilterOption>;
+/** Operators whose predicate is a set-membership test over a token list.
+ *  The filter row renders a multi-value chip input for these instead of a
+ *  single text box. */
+export declare const SET_OPERATORS: ReadonlyArray<FilterOperator>;
+/** Operators that need no value input - they act on emptiness alone. */
+export declare const VALUELESS_OPERATORS: ReadonlyArray<FilterOperator>;
 /** Which operators make sense for each column editor type. */
 export declare const TEXT_OPERATORS: Array<FilterOperator>;
 export declare const NUMBER_OPERATORS: Array<FilterOperator>;

package/dist/filter-operators.js

@@ -1,34 +1,67 @@
 export const filterOperatorOptions = [
     { value: "contains", label: "Contains", iconName: "op-contains" },
+    { value: "notContains", label: "Not contains", iconName: "op-notContains" },
     { value: "equals", label: "Equals", iconName: "op-equals" },
+    { value: "notEquals", label: "Not equals", iconName: "op-notEquals" },
     { value: "startsWith", label: "Starts with", iconName: "op-startsWith" },
+    { value: "endsWith", label: "Ends with", iconName: "op-endsWith" },
+    { value: "regex", label: "Regex", iconName: "op-regex" },
+    { value: "in", label: "In", iconName: "op-in" },
+    { value: "notIn", label: "Not in", iconName: "op-notIn" },
     { value: "greaterThan", label: "Greater than", iconName: "op-greaterThan" },
     { value: "lessThan", label: "Less than", iconName: "op-lessThan" },
     { value: "between", label: "Between", iconName: "op-between" },
-    { value: "isBlank", label: "Is blank", iconName: "op-isBlank" },
+    { value: "isBlank", label: "Blank", iconName: "op-isBlank" },
+    { value: "isNotBlank", label: "Not blank", iconName: "op-isNotBlank" },
+];
+/** Operators whose predicate is a set-membership test over a token list.
+ *  The filter row renders a multi-value chip input for these instead of a
+ *  single text box. */
+export const SET_OPERATORS = ["in", "notIn"];
+/** Operators that need no value input - they act on emptiness alone. */
+export const VALUELESS_OPERATORS = [
+    "isBlank",
+    "isNotBlank",
 ];
 /** Which operators make sense for each column editor type. */
 export const TEXT_OPERATORS = [
     "contains",
+    "notContains",
     "equals",
+    "notEquals",
     "startsWith",
+    "endsWith",
+    "regex",
+    "in",
+    "notIn",
     "isBlank",
+    "isNotBlank",
 ];
 export const NUMBER_OPERATORS = [
     "equals",
+    "notEquals",
     "greaterThan",
     "lessThan",
     "between",
+    "in",
+    "notIn",
     "isBlank",
+    "isNotBlank",
 ];
 export const DATE_OPERATORS = [
     "equals",
+    "notEquals",
     "lessThan",
     "greaterThan",
     "between",
     "isBlank",
+    "isNotBlank",
+];
+export const CHECKBOX_OPERATORS = [
+    "equals",
+    "isBlank",
+    "isNotBlank",
 ];
-export const CHECKBOX_OPERATORS = ["equals", "isBlank"];
 export const fallbackOperatorOption = {
     value: "contains",
     label: "Contains",

package/dist/filtering/excel-filters.d.ts

@@ -1,4 +1,4 @@
-export type ExcelFilterOperator = 'contains' | 'equals' | 'startsWith' | 'greaterThan' | 'lessThan' | 'between' | 'isBlank';
+export type ExcelFilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'regex' | 'in' | 'notIn' | 'greaterThan' | 'lessThan' | 'between' | 'isBlank' | 'isNotBlank';
 export type ExcelFilter = {
     id: string;
     operator: ExcelFilterOperator;
@@ -23,4 +23,21 @@ export type ExcelFilterOptions = {
  *  lowercase. The locale-aware lowercasing handles Turkish dotted-I /
  *  dotless-i correctly when the consumer threads `"tr"` through. */
 export declare function normalizeForFilter(s: string, locale?: string | ReadonlyArray<string>): string;
+/**
+ * Delimiter used to serialise the `in` / `notIn` value list into the single
+ * `value` string that the filter model carries. A newline is used because it
+ * (unlike a comma) practically never appears inside a typed token, so tokens
+ * survive the round-trip unescaped. The chip input in the filter row reads and
+ * writes with the same separator via {@link splitInTokens} / {@link joinInTokens}.
+ */
+export declare const IN_TOKEN_SEP = "\n";
+/**
+ * Split a serialised `in` / `notIn` value into its individual tokens. Accepts
+ * both the newline separator the chip input writes and a plain comma-separated
+ * string (what a raw text field, e.g. the tool-panel filter, produces), so the
+ * same value round-trips through either UI.
+ */
+export declare function splitInTokens(value: unknown): string[];
+/** Serialise a list of tokens back into the single `in` / `notIn` value. */
+export declare function joinInTokens(tokens: ReadonlyArray<string>): string;
 export declare function applyExcelFilter(cellValue: unknown, filter: ExcelFilter, options?: ExcelFilterOptions): boolean;