@lavalogic/scoria 0.37.44 → 0.37.46

package/dist/Components/Table/ColumnFactory.svelte.js

@@ -1,19 +1,17 @@
 /**
- * Runtime for the typed column builder closure consumers pass to
+ * Runtime for the typed column builder closure passed to
  * `createTable({ columns: (col) => [...] })`. Each method on the returned
- * `ColumnFactory<TRow>` wraps the matching existing `<Name>Def` constructor
- * and returns a `ColumnSpec<TRow, Kind>` whose internal payload (the
- * underlying `ColumnDef<TRow>` plus any per-column edit handler / reactive
- * dependencies) is hidden behind a symbol-keyed property.
+ * `ColumnFactory<TRow>` wraps the matching internal `<Name>Def` constructor
+ * and returns a `ColumnSpec<TRow, Kind>` whose underlying `ColumnDef` plus
+ * any per-column edit handler / reactive dependencies are hidden behind a
+ * symbol-keyed property (`InternalSpecPayload`).
  *
- * Phase 1 implementation note: this file is a thin facade. It maps the
- * consumer-friendly option shapes (with `accessor` instead of `accessorFn`,
- * `minWidth` instead of `minSize`, etc.) to the internal `<Name>Def` props
- * by spreading a `commonProps(...)` helper that returns the non-id common
- * fields, with `id` passed explicitly at each call site so its narrowed
- * type survives the spread.
+ * This file is a thin facade: it maps the consumer-friendly option names
+ * (`accessor`, `minWidth`, …) onto the internal Def field names (`accessorFn`,
+ * `minSize`, …) via the `commonProps(...)` helper. `id` is passed explicitly
+ * at each call site so its narrowed literal type survives the object spread.
  */
-import { generateUUID, syntheticColumnId } from '../../Helpers/Helpers.svelte.js';
+import { formatDateTime, generateUUID, syntheticColumnId } from '../../Helpers/Helpers.svelte.js';
 import { CheckboxDef } from './Types/Columns/Definitions/Accessors/CheckboxDef.svelte.js';
 import { DateInputDef } from './Types/Columns/Definitions/Accessors/DateInputDef.svelte.js';
 import { NumberInputDef } from './Types/Columns/Definitions/Accessors/NumberInputDef.svelte.js';
@@ -54,6 +52,10 @@ export function unwrapColumnSpec(spec) {
  *  `Object.keys` or JSON serialisation, while still being reachable via
  *  `unwrapColumnSpec(...)`. */
 function makeSpec(kind, def, internals = {}) {
+    // Tag the def with its public-API kind. Drives the kind→filter map in
+    // `TableContext.setupDefaultColumnDefs` so the long instanceof cascade
+    // can be replaced by a single registry lookup.
+    def.kind = kind;
     const spec = {
         kind,
         id: def.id,
@@ -67,24 +69,20 @@ function makeSpec(kind, def, internals = {}) {
     });
     return Object.freeze(spec);
 }
-/** Sensible per-kind default widths so a freshly-built table without explicit
- *  per-column `width` overrides ends up visually differentiated (rather than
- *  every column collapsing to the shared `minSize` fallback of 48px and then
- *  taking equal `1fr` shares of any remaining track space). Numbers chosen
- *  to roughly match what the legacy `<table>` element produced via the
- *  browser auto-layout algorithm for typical FloWMS column content. */
+/** Sensible per-kind default widths so a freshly-built table without
+ *  explicit per-column `width` overrides ends up visually differentiated
+ *  (rather than every column collapsing to the shared `minSize` floor and
+ *  taking equal `1fr` shares of leftover track space). Numbers roughly
+ *  match what the legacy `<table>` auto-layout produced for typical
+ *  FloWMS column content.
+ *
+ *  - `number: 120` — fits 7-8 digit IDs alongside sort/filter affordances.
+ *  - `date: 180` — fits the "DD/MM/YYYY HH:mm" format used across FloWMS;
+ *    narrower widths truncated the time portion. */
 const KIND_DEFAULT_WIDTHS = {
     text: 180,
-    // Bumped from 100 → 120 so 7-8 digit IDs / quantities (e.g. shipment
-    // IDs, order IDs) fit cleanly alongside the sort / filter affordances
-    // without forcing the value to truncate or wrap.
     number: 120,
     checkbox: 80,
-    // Bumped from 140 → 180 so the formatted "DD/MM/YYYY HH:mm" string
-    // fits inside the cell. The legacy 140px floor cut off the time
-    // portion for the typical date format used across FloWMS pages and
-    // forced every consumer to set a per-column `width` override (see
-    // OrderManagement, which had to pin date columns at 210).
     date: 180,
     select: 160,
     query: 160,
@@ -108,22 +106,19 @@ function commonProps(opts, kind) {
     const defaultWidth = KIND_DEFAULT_WIDTHS[kind];
     return {
         header: opts.header,
-        // Set minSize from the per-kind default too so
-        // `TableContext.registerDefs` does NOT run the canvas-based
-        // `measureHeaderWidth` fallback. That fallback floors every
-        // accessor column to ~130px when quick-filtering is enabled
-        // (it returns max(headerWidth, "Lorem Ipsum Dolor" width)),
-        // which equalises every accessor column width and erases the
-        // per-kind differentiation the factory just put in place.
+        // `minSize` mirrors the per-kind default so `TableContext.registerDefs`
+        // does NOT fall back to the canvas-based `measureHeaderWidth`, which
+        // floors every accessor column at ~130px when quick-filtering is
+        // enabled (it returns max(headerWidth, "Lorem Ipsum Dolor" width))
+        // and erases the per-kind differentiation.
         minSize: opts.minWidth ?? defaultWidth,
         width: opts.width ?? defaultWidth,
         maxWidth: opts.maxWidth,
         wrapValue: opts.wrapValue,
-        // `widthIsFixed` is true only when the caller passed an explicit
-        // `width`. The grid template uses this to render the track as
-        // fixed `${W}px` for explicit widths, leaving the per-kind-default
-        // columns on `minmax(W, 1fr)` so they absorb any horizontal space
-        // the fixed columns leave behind.
+        // `widthIsFixed` is true only when the caller supplied an explicit
+        // `width`. The grid template renders those tracks as `${W}px` and
+        // leaves per-kind-default columns on `minmax(W, 1fr)` so they
+        // absorb any horizontal space the fixed columns leave behind.
         widthIsFixed: opts.width != null,
         allowSorting: opts.allowSorting,
         allowFiltering: opts.allowFiltering,
@@ -135,37 +130,28 @@ function commonProps(opts, kind) {
         filterGroup: opts.filterGroup,
     };
 }
-/** Generate a column id for a kind whose option type does not require
- *  an `id` from the caller.
+/** Generate a column id for a kind whose option type does not require an
+ *  `id` from the caller.
  *
- *  - When `hint` is provided, use it as the id verbatim. This is the
- *    server-side-filtering contract: callers who pass an `idHint` are
- *    indicating that the column maps to a real backend field (so the
- *    filter row's `id` flows through `createRemoteRowSource` as the
- *    query-string key the server expects). Adding a synthetic prefix
- *    here would mean every `col.display({ idHint: 'outboundType_id' })`
- *    serialised as `display-outboundType_id` and the server rejected
- *    the request with "field does not exist".
- *  - When no `hint` is provided, fall back to `${prefix}-${UUID}` so
- *    the id is still unique within the table. Such columns cannot
- *    participate in server-driven filtering anyway (the server would
- *    not know the random suffix). */
+ *  - With `hint`: used verbatim. `idHint` is the server-side-filtering
+ *    contract; the column id flows through `createRemoteRowSource` as
+ *    the query-string key the server expects, so a synthetic prefix
+ *    would make every server reject the field as unknown.
+ *  - Without `hint`: fall back to `${prefix}-${UUID}` so the id is unique
+ *    within the table. Such columns cannot participate in server-driven
+ *    filtering (the server has no way to know the random suffix). */
 function mintSyntheticId(prefix, hint) {
     if (hint != null) {
         return syntheticColumnId(hint);
     }
     return syntheticColumnId(`${prefix}-${generateUUID()}`);
 }
-/** Resolve an `options` field that may be a static array or an async
- *  loader into the always-loader form the Def expects. Mutable arrays are
- *  required by the Def's signature; we spread to drop readonly. */
+/** Resolve an `options` field that may be a static array or an async loader
+ *  into the always-loader form the Def expects. The spread drops the
+ *  readonly modifier the Def's signature lacks. Loaders may return either
+ *  a Promise or a plain array; `Promise.resolve` accepts both. */
 function normaliseOptionsLoader(options) {
     if (typeof options === 'function') {
-        // `options()` may return either a Promise or a plain array - some
-        // project helpers (e.g. flowms `ColumnDefRepository.getAccounts()`
-        // vs. `getOutboundStatuses()`) settle on different conventions per
-        // data source. `Promise.resolve` accepts both so the loader hands
-        // the consumer a uniform Promise either way.
         return () => Promise.resolve(options()).then((res) => [...res]);
     }
     const snapshot = [...options];
@@ -186,29 +172,17 @@ function normaliseOptionsLoader(options) {
  * tests can exercise individual factory methods without round-tripping
  * through a full `createTable(...)` call.
  */
-/** Format a Date or ISO-8601 date string for display using the browser
- *  locale. Returns null / empty input unchanged. Used by `col.display` when
- *  the column declares `filterValueType: 'Date'` so backend timestamps
- *  surface as a properly localised date+time string instead of the raw
- *  ISO payload (`2026-04-16T09:44:11+01:00`). */
+/** Format a Date / ISO-8601 string / epoch number for display. Used by
+ *  `col.display` when the column declares `filterValueType: 'Date'`, so
+ *  raw backend timestamps render as a localised date+time rather than the
+ *  ISO payload. Delegates to the exported `formatDateTime` helper so table
+ *  cells and non-table date surfaces format identically. Anything that is
+ *  not a date-like value (the column was mis-declared) yields `''`. */
 function formatLocaleDate(value) {
-    if (value == null || value === '') {
-        return value;
-    }
-    let d;
-    if (value instanceof Date) {
-        d = value;
-    }
-    else if (typeof value === 'string' || typeof value === 'number') {
-        const parsed = new Date(value);
-        if (!Number.isNaN(parsed.getTime())) {
-            d = parsed;
-        }
+    if (value instanceof Date || typeof value === 'string' || typeof value === 'number') {
+        return formatDateTime(value);
     }
-    if (d == null) {
-        return value;
-    }
-    return d.toLocaleString();
+    return '';
 }
 export function createColumnFactory() {
     const factory = {
@@ -327,12 +301,11 @@ export function createColumnFactory() {
                 ? normaliseOptionsLoader(opts.getOptions)
                 : undefined;
             // Display columns have no intrinsic kind (the value comes from an
-            // arbitrary `value: (row) => ...` thunk) so the generic 'display'
-            // default (150px) is the fallback. When the consumer DOES pass a
-            // `filterValueType`, treat it as a hint about the rendered shape
-            // of the column and pick the matching per-kind default so a table
-            // full of `col.display` columns ends up visually differentiated
-            // instead of every column collapsing to the same 150px floor.
+            // arbitrary `value: (row) => ...` thunk). When the consumer passes
+            // a `filterValueType`, treat it as a hint about the rendered shape
+            // and pick the matching per-kind default width; otherwise fall
+            // back to the generic 'display' default so columns are visually
+            // differentiated instead of all collapsing to the same floor.
             const inferredKind = opts.filterValueType === 'Number'
                 ? 'number'
                 : opts.filterValueType === 'Date'
@@ -344,26 +317,19 @@ export function createColumnFactory() {
                             : opts.filterValueType === 'String'
                                 ? 'text'
                                 : 'display';
-            // For Date-typed display columns, leave the accessor returning
-            // the raw Date / ISO string (filter / sort logic still operates
-            // on the raw value) and surface the formatted local-time
-            // string via `getDisplayValue`. The cell renders
-            // `getDisplayValue` for visible text and reads the raw value
-            // from `accessorFn` to compose the hover tooltip showing both
-            // the local-time and UTC representations.
+            // For Date-typed display columns, the accessor returns the raw
+            // Date / ISO string (filter/sort operates on the raw value) and
+            // `getDisplayValue` surfaces the formatted local-time string.
+            // The cell renders `getDisplayValue` for visible text and uses
+            // the raw value to compose the hover tooltip (local + UTC).
             const rawValue = opts.value;
             const valueAccessor = rawValue;
             const dateDisplayValue = opts.filterValueType === 'Date'
                 ? (row, index) => {
                     const v = rawValue(row, index);
-                    if (v instanceof Promise) {
-                        return v.then((resolved) => {
-                            const formatted = formatLocaleDate(resolved);
-                            return formatted == null ? null : String(formatted);
-                        });
-                    }
-                    const formatted = formatLocaleDate(v);
-                    return formatted == null ? null : String(formatted);
+                    return v instanceof Promise
+                        ? v.then((resolved) => formatLocaleDate(resolved))
+                        : formatLocaleDate(v);
                 }
                 : undefined;
             const def = new DisplayDef({
@@ -372,27 +338,20 @@ export function createColumnFactory() {
                 accessorFn: valueAccessor,
                 getDisplayValue: dateDisplayValue,
                 modal: opts.modal,
-                // Display columns have no implicit filter type (unlike the
-                // typed kinds where the factory pins one based on the
-                // column kind). Consumers opt in by passing the type they
-                // want the filter input rendered as.
-                // Default to string-typed filter when the caller did not specify
-                // one, so a display column with no explicit `filterValueType`
-                // still appears in the filter UI (matches the `DisplayDef →
-                // stringFilter (undefined case)` mapping in
+                // Display columns have no implicit filter type. Consumers opt
+                // in by passing `filterValueType`; default to String so a
+                // column without one still appears in the filter UI (matches
+                // the `DisplayDef → stringFilter` mapping in
                 // `setupDefaultColumnDefs`).
                 filterValueType: opts.filterValueType ?? FilterValueType.String,
                 getSortingFn: opts.getSortingFn,
                 getOptions: normalisedOptions,
-                // Forward reactiveDependencies onto the def so
-                // `makeRow.getValue` can read them synchronously before
-                // calling the (possibly async) accessor. Without this,
-                // reactive reads that happen only after `await` inside
-                // the consumer's `value` callback are not tracked by the
-                // cell's `$derived`, and downstream display cells never
-                // refresh when a sibling field is edited (visible on the
-                // Receipt pod table: Title / UoM did not reload after the
-                // SKU select changed `item.receiptLineId`).
+                // `reactiveDependencies` is forwarded onto the def so that
+                // `makeRow.getValue` can read it synchronously before invoking
+                // a (possibly async) accessor. Without this, reads that only
+                // happen after `await` inside the consumer's `value` callback
+                // are not tracked by the cell's `$derived`, and downstream
+                // cells never refresh when a sibling field is edited.
                 reactiveDependencies: opts.reactiveDependencies,
             });
             return makeSpec('display', def);
@@ -407,12 +366,18 @@ export function createColumnFactory() {
                 ...commonProps(opts, 'bubble'),
                 accessorFn: opts.value,
                 maxBubbles: opts.maxBubbles,
+                // `opts.colour` is typed `(row, index, value: TValue) => ...`
+                // but `BubbleDef.getColour` expects `value: string` (one bubble's
+                // rendered text). The bridge from `TValue` to `string` happens
+                // at render time inside the bubble renderer (each value coerces
+                // to a string via `String(...)` for display). The cast is
+                // load-bearing because TS cannot prove `TValue` is `string`-
+                // compatible at this layer.
                 getColour: opts.colour,
-                // Default to a string-typed filter so bubble columns appear in
-                // the quick-filter row and advanced filter panel by default
-                // (matches the `BubbleDef → stringFilter` mapping in
-                // `setupDefaultColumnDefs`). Caller can override to any other
-                // `filterValueType`, or pass `allowFiltering: false` to opt out.
+                // Default to String so bubble columns appear in the filter UI
+                // (matches `BubbleDef → stringFilter` in setupDefaultColumnDefs).
+                // Caller can override with another `filterValueType` or pass
+                // `allowFiltering: false` to opt out.
                 filterValueType: opts.filterValueType ?? FilterValueType.String,
                 getOptions: normalisedOptions,
             });
@@ -443,9 +408,9 @@ export function createColumnFactory() {
                 ...commonProps(opts, 'progress'),
                 accessorFn: tupleAccessor,
                 getColour,
-                // Default to number-typed filter so progress columns appear in
-                // the filter UI by default (matches `ProgressBarDef →
-                // numberFilter` in `setupDefaultColumnDefs`).
+                // Default to Number so progress columns appear in the filter
+                // UI (matches `ProgressBarDef → numberFilter` in
+                // setupDefaultColumnDefs).
                 filterValueType: opts.filterValueType ?? FilterValueType.Number,
                 getOptions: progressOptions,
             });
@@ -473,9 +438,9 @@ export function createColumnFactory() {
             const def = new RowSelectionDef({
                 isSelectable: opts?.isSelectable ?? (() => true),
             });
-            // RowSelection has no public width option - apply the per-kind
-            // default so the column does not collapse to the 48px ColumnDef
-            // fallback and share equal `1fr` track space with wider columns.
+            // RowSelection has no public width option — apply the per-kind
+            // default so the column does not fall back to the 48px ColumnDef
+            // floor and share equal `1fr` track space with wider columns.
             def.width = KIND_DEFAULT_WIDTHS.rowSelection;
             def.minSize = KIND_DEFAULT_WIDTHS.rowSelection;
             def.widthIsFixed = true;
@@ -484,8 +449,7 @@ export function createColumnFactory() {
         actions(opts) {
             const wrapped = opts.actions.map((action) => {
                 // `label` may be a literal string or a `(row) => string |
-                // Promise<string>` function. The internal Def expects a
-                // `getLabel(item, index)` so wrap accordingly.
+                // Promise<string>` function; the Def needs the function form.
                 const labelOption = action.label;
                 const getLabel = typeof labelOption === 'function' ? (item) => labelOption(item) : () => labelOption;
                 return {
@@ -501,17 +465,16 @@ export function createColumnFactory() {
                 actions: wrapped,
                 isEnabled: isEnabledFn ? (item) => isEnabledFn(item) : undefined,
             });
-            // Actions has no public width option - apply the per-kind default.
+            // Actions has no public width option — apply the per-kind default.
             def.width = KIND_DEFAULT_WIDTHS.actions;
             def.widthIsFixed = true;
             return makeSpec('actions', def);
         },
         expand(opts) {
-            // `childRowId` may be either a function or a key string;
-            // the inner `TableContext` expects a function form for
+            // `childRowId` may be a function or a key string; the inner
+            // `TableContext` expects the function form for
             // `selectionExtractor`. Normalise here so the nested table
-            // never sees the raw string and `SelectionState.cachedKey`
-            // can safely invoke the extractor.
+            // always receives a callable.
             const childRowIdFn = typeof opts.childRowId === 'function'
                 ? opts.childRowId
                 : (inner) => inner[opts.childRowId];
@@ -524,11 +487,9 @@ export function createColumnFactory() {
                 headerIcon: opts.headerIcon ?? 'chevron-down',
                 innerTableName: scoriaStorageKey(opts.name),
                 getInnerColumnDefs: (row, index) => {
-                    // `childColumns` receives the outer row + index so the
-                    // inner column set may branch per row (pick-wave-subtype
-                    // drill-downs, for example). Outer-row args are optional
-                    // at the consumer site, so closures that ignore them
-                    // continue working unchanged.
+                    // `childColumns` receives the outer row + index so the inner
+                    // column set may branch per row (e.g. pick-wave-subtype
+                    // drill-downs). Both args are optional at the consumer site.
                     const innerFactory = createColumnFactory();
                     const innerSpecs = opts.childColumns(innerFactory, row, index);
                     const innerDefs = innerSpecs.map((spec) => unwrapColumnSpec(spec).def);
@@ -546,7 +507,7 @@ export function createColumnFactory() {
                     allowCopy: opts.inner?.allowCopy,
                 },
             });
-            // Expand has no public width option - apply the per-kind default.
+            // Expand has no public width option — apply the per-kind default.
             def.width = KIND_DEFAULT_WIDTHS.expand;
             def.minSize = KIND_DEFAULT_WIDTHS.expand;
             def.widthIsFixed = true;
@@ -554,6 +515,12 @@ export function createColumnFactory() {
         },
         filterOnly(opts) {
             const def = new FilterOnlyDef({
+                // `opts.id` is `K extends string`, which allows free-form
+                // dotted-path / camelCase ids (the public surface flowms
+                // relies on). The Def's `id` field is the branded
+                // `ColumnId<TRow>`; the brand is structural and the cast is
+                // safe because `FilterOnlyDef` never narrows back to
+                // `keyof TRow` at runtime.
                 id: opts.id,
                 header: opts.header,
                 allowSorting: false,

package/dist/Components/Table/ColumnKindRegistry.d.ts

@@ -0,0 +1,112 @@
+import type { ColumnDef } from './Types/Columns/Definitions/ColumnDef.svelte.js';
+/**
+ * Shape of the per-type filter function set `TableContext` owns. Each
+ * concrete `FilterFn<T, ValueType>` narrows its second generic to the
+ * value-type it accepts; the registry stays decoupled from that detail
+ * by reaching for these via a name lookup and returning `unknown` to the
+ * call site, which casts back to `ColumnDef.filterFn` at assignment.
+ */
+export interface LocalFilterFns {
+    stringFilter: unknown;
+    numberFilter: unknown;
+    selectFilter: unknown;
+    boolFilter: unknown;
+    dateFilter: unknown;
+}
+/**
+ * Categorisation used by `setupDefaultColumnDefs`:
+ *
+ * - `accessor` — column has its own data accessor; the kind dictates the
+ *   filter (text→string, number→number, etc.). MinSize falls back to the
+ *   measured header width.
+ * - `display` — column has no accessor; the consumer's `filterValueType`
+ *   on the def picks the filter at runtime via `resolveDisplayFilter`.
+ * - `structural` — row-selection / actions / expand / filterOnly etc. No
+ *   default filter wiring.
+ */
+export type ColumnKindCategory = 'accessor' | 'display' | 'structural';
+export interface ColumnKindEntry {
+    readonly category: ColumnKindCategory;
+    /**
+     * For `accessor`-category kinds: the name of the filter function on
+     * `LocalFilterFns` that this kind defaults to.
+     *
+     * For `display`-category kinds whose filter is fixed (e.g. `bubble`
+     * always uses `stringFilter`, `progress` always uses `numberFilter`):
+     * same lookup.
+     *
+     * `undefined` for `structural` kinds and for `display` kinds whose
+     * filter follows `def.filterValueType` (handled by
+     * `resolveDisplayFilter` instead).
+     */
+    readonly defaultFilter?: keyof LocalFilterFns;
+}
+/** Registry literal. Kept in sync with the `ColumnKind` type by the
+ *  `satisfies Record<ColumnKind, ColumnKindEntry>` check below. */
+export declare const COLUMN_KIND_REGISTRY: {
+    readonly text: {
+        readonly category: "accessor";
+        readonly defaultFilter: "stringFilter";
+    };
+    readonly number: {
+        readonly category: "accessor";
+        readonly defaultFilter: "numberFilter";
+    };
+    readonly checkbox: {
+        readonly category: "accessor";
+        readonly defaultFilter: "boolFilter";
+    };
+    readonly date: {
+        readonly category: "accessor";
+        readonly defaultFilter: "dateFilter";
+    };
+    readonly select: {
+        readonly category: "accessor";
+        readonly defaultFilter: "selectFilter";
+    };
+    readonly query: {
+        readonly category: "accessor";
+        readonly defaultFilter: "stringFilter";
+    };
+    readonly display: {
+        readonly category: "display";
+    };
+    readonly bubble: {
+        readonly category: "display";
+        readonly defaultFilter: "stringFilter";
+    };
+    readonly progress: {
+        readonly category: "display";
+        readonly defaultFilter: "numberFilter";
+    };
+    readonly validity: {
+        readonly category: "structural";
+    };
+    readonly actions: {
+        readonly category: "structural";
+    };
+    readonly rowSelection: {
+        readonly category: "structural";
+    };
+    readonly expand: {
+        readonly category: "structural";
+    };
+    readonly filterOnly: {
+        readonly category: "structural";
+    };
+};
+/**
+ * Resolve a `display`-category def's filter from its `filterValueType`.
+ * Returns `undefined` when the value-type is unrecognised, so callers may
+ * fall through to a no-op or default.
+ */
+export declare function resolveDisplayFilter<T extends object>(def: ColumnDef<T>, filters: LocalFilterFns): unknown;
+/**
+ * Resolve the default filter function for a column given its `kind`.
+ * Returns `unknown` (the call site casts back to the def's local
+ * `FilterFn<T, ValueType>` shape on assignment). Returns `undefined`
+ * when the kind is structural, when the kind is unknown (e.g. a
+ * hand-constructed `ColumnDef` outside the factory), or when a
+ * `display` column has no recognised `filterValueType`.
+ */
+export declare function resolveDefaultFilter<T extends object>(def: ColumnDef<T>, filters: LocalFilterFns): unknown;

package/dist/Components/Table/ColumnKindRegistry.js

@@ -0,0 +1,63 @@
+/** Registry literal. Kept in sync with the `ColumnKind` type by the
+ *  `satisfies Record<ColumnKind, ColumnKindEntry>` check below. */
+export const COLUMN_KIND_REGISTRY = {
+    text: { category: 'accessor', defaultFilter: 'stringFilter' },
+    number: { category: 'accessor', defaultFilter: 'numberFilter' },
+    checkbox: { category: 'accessor', defaultFilter: 'boolFilter' },
+    date: { category: 'accessor', defaultFilter: 'dateFilter' },
+    select: { category: 'accessor', defaultFilter: 'selectFilter' },
+    query: { category: 'accessor', defaultFilter: 'stringFilter' },
+    display: { category: 'display' },
+    bubble: { category: 'display', defaultFilter: 'stringFilter' },
+    progress: { category: 'display', defaultFilter: 'numberFilter' },
+    validity: { category: 'structural' },
+    actions: { category: 'structural' },
+    rowSelection: { category: 'structural' },
+    expand: { category: 'structural' },
+    filterOnly: { category: 'structural' },
+};
+/**
+ * Resolve a `display`-category def's filter from its `filterValueType`.
+ * Returns `undefined` when the value-type is unrecognised, so callers may
+ * fall through to a no-op or default.
+ */
+export function resolveDisplayFilter(def, filters) {
+    switch (def.filterValueType) {
+        case undefined:
+        case 'String':
+            return filters.stringFilter;
+        case 'Bool':
+            return filters.boolFilter;
+        case 'Date':
+            return filters.dateFilter;
+        case 'Number':
+            return filters.numberFilter;
+        case 'Select':
+            return filters.selectFilter;
+    }
+}
+/**
+ * Resolve the default filter function for a column given its `kind`.
+ * Returns `unknown` (the call site casts back to the def's local
+ * `FilterFn<T, ValueType>` shape on assignment). Returns `undefined`
+ * when the kind is structural, when the kind is unknown (e.g. a
+ * hand-constructed `ColumnDef` outside the factory), or when a
+ * `display` column has no recognised `filterValueType`.
+ */
+export function resolveDefaultFilter(def, filters) {
+    if (def.kind == null) {
+        return undefined;
+    }
+    const entry = COLUMN_KIND_REGISTRY[def.kind];
+    if (entry.category === 'structural') {
+        return undefined;
+    }
+    if (entry.defaultFilter !== undefined) {
+        return filters[entry.defaultFilter];
+    }
+    // Plain `col.display` — filter follows the consumer's filterValueType.
+    if (entry.category === 'display') {
+        return resolveDisplayFilter(def, filters);
+    }
+    return undefined;
+}