@marinoscar/platform-web 0.1.0-next.3 → 0.1.0-next.5

package/dist/datatable/headless/filter/filterUrl.d.ts

@@ -0,0 +1,114 @@
+/**
+ * DataTable — URL serialization for the filter model and quick search.
+ *
+ * Offered as a HELPER, never wired in automatically. A page that already owns a
+ * `useSearchParams` (the admin users and allowlist pages) opts in with two
+ * calls;
+ * a page that doesn't isn't forced to grow a router dependency to render a
+ * table. That is the same posture the rest of the contract takes with
+ * pagination and sort.
+ *
+ * ## Wire format
+ *
+ * One repeated `filter` param per filter:
+ *
+ * ```
+ * ?filter=status:is:failed
+ * &filter=lastError:contains:rate%2520limited
+ * &filter=attempts:between:1,5
+ * &filter=lastError:isEmpty
+ * &q=tagging
+ * ```
+ *
+ * `columnId:operator[:value]`, with each value segment `encodeURIComponent`-ed
+ * so a value containing `:` or `,` survives, and multi-value operands joined
+ * with `,`. The double-encoding you see above (`%2520`) is
+ * `URLSearchParams.toString()` re-encoding our `%20`; it is symmetric, so a
+ * `toString()` → `new URLSearchParams()` round trip is lossless.
+ *
+ * ## Why arity, not a type tag, decides the shape on the way back
+ *
+ * Nothing in the wire format says "this is an array". It doesn't need to: the
+ * operator already determines the operand's shape (`between` → a pair,
+ * `isAnyOf` → a set, everything else → a scalar), so the encoding stays short
+ * and human-editable in an address bar.
+ *
+ * Scalar TYPE is a different question, and the one thing a URL genuinely cannot
+ * carry: `attempts:equals:3` is indistinguishable from a text `'3'`. Pass the
+ * table's `columns` to {@link readDataTableUrlState} and each value is coerced
+ * by its column's `filterType`; omit them and every scalar comes back a string.
+ * Always pass them when you have them.
+ */
+import type { DataTableColumn, DataTableFilter, DataTableFilterModel } from '../types.js';
+/**
+ * Repeated param carrying one encoded filter each.
+ *
+ * @stability experimental
+ */
+export declare const DATATABLE_FILTER_PARAM = "filter";
+/**
+ * Param carrying the global quick-search term.
+ *
+ * @stability experimental
+ */
+export declare const DATATABLE_SEARCH_PARAM = "q";
+/**
+ * The filter and quick-search state read from, or written to, URL query parameters.
+ *
+ * @stability experimental
+ */
+export interface DataTableUrlState {
+    /** The filters read from the URL. */
+    filters: DataTableFilterModel;
+    /** The quick-search term read from the URL. */
+    search: string;
+}
+/**
+ * Names of the query parameters {@link readDataTableUrlState} and {@link writeDataTableUrlState} use.
+ *
+ * @stability experimental
+ */
+export interface DataTableUrlOptions<Row = unknown> {
+    /** Override the repeated filter param name. Default `'filter'`. */
+    filterParam?: string;
+    /** Override the quick-search param name. Default `'q'`. */
+    searchParam?: string;
+    /**
+     * The table's columns. Supplying them lets scalar operands be coerced back to
+     * `number` / `boolean` by each column's `filterType`. Without them every
+     * scalar decodes as a `string`.
+     */
+    columns?: DataTableColumn<Row>[];
+}
+/**
+ * Encode a single filter as a `columnId:operator[:value]` param value.
+ *
+ * @stability experimental
+ */
+export declare function encodeFilter(filter: DataTableFilter): string;
+/**
+ * Decode one param value. Returns `null` for anything malformed — a hand-edited
+ * or stale URL should drop the offending filter, never throw on render.
+ *
+ * @stability experimental
+ */
+export declare function decodeFilter<Row>(encoded: string, columns?: DataTableColumn<Row>[]): DataTableFilter | null;
+/**
+ * Read the filter model and quick-search term out of a `URLSearchParams`.
+ * Unknown / malformed filter params are dropped silently.
+ *
+ * @stability experimental
+ */
+export declare function readDataTableUrlState<Row>(params: URLSearchParams, options?: DataTableUrlOptions<Row>): DataTableUrlState;
+/**
+ * Write the filter model and quick-search term into a COPY of `params`, leaving
+ * every unrelated param (page, sort, tab, …) untouched. Returns the copy — the
+ * caller decides whether that becomes a push or a replace.
+ *
+ * An empty model / empty search removes its param entirely rather than leaving
+ * `?filter=&q=` behind, so a cleared table produces a clean URL.
+ *
+ * @stability experimental
+ */
+export declare function writeDataTableUrlState<Row>(params: URLSearchParams, state: Partial<DataTableUrlState>, options?: DataTableUrlOptions<Row>): URLSearchParams;
+//# sourceMappingURL=filterUrl.d.ts.map

package/dist/datatable/headless/filter/filterUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterUrl.d.ts","sourceRoot":"","sources":["../../../../src/datatable/headless/filter/filterUrl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,oBAAoB,EAGrB,MAAM,aAAa,CAAC;AAIrB;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAC/C;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,qCAAqC;IACrC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB,CAAC,GAAG,GAAG,OAAO;IAChD,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAC;CAClC;AAUD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAQ5D;AAOD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAC9B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,GAC/B,eAAe,GAAG,IAAI,CAqCxB;AAgBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EACvC,MAAM,EAAE,eAAe,EACvB,OAAO,GAAE,mBAAmB,CAAC,GAAG,CAAM,GACrC,iBAAiB,CAUnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EACxC,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,OAAO,CAAC,iBAAiB,CAAC,EACjC,OAAO,GAAE,mBAAmB,CAAC,GAAG,CAAM,GACrC,eAAe,CAgBjB"}

package/dist/datatable/headless/filter/filterUrl.js

@@ -0,0 +1,176 @@
+/**
+ * DataTable — URL serialization for the filter model and quick search.
+ *
+ * Offered as a HELPER, never wired in automatically. A page that already owns a
+ * `useSearchParams` (the admin users and allowlist pages) opts in with two
+ * calls;
+ * a page that doesn't isn't forced to grow a router dependency to render a
+ * table. That is the same posture the rest of the contract takes with
+ * pagination and sort.
+ *
+ * ## Wire format
+ *
+ * One repeated `filter` param per filter:
+ *
+ * ```
+ * ?filter=status:is:failed
+ * &filter=lastError:contains:rate%2520limited
+ * &filter=attempts:between:1,5
+ * &filter=lastError:isEmpty
+ * &q=tagging
+ * ```
+ *
+ * `columnId:operator[:value]`, with each value segment `encodeURIComponent`-ed
+ * so a value containing `:` or `,` survives, and multi-value operands joined
+ * with `,`. The double-encoding you see above (`%2520`) is
+ * `URLSearchParams.toString()` re-encoding our `%20`; it is symmetric, so a
+ * `toString()` → `new URLSearchParams()` round trip is lossless.
+ *
+ * ## Why arity, not a type tag, decides the shape on the way back
+ *
+ * Nothing in the wire format says "this is an array". It doesn't need to: the
+ * operator already determines the operand's shape (`between` → a pair,
+ * `isAnyOf` → a set, everything else → a scalar), so the encoding stays short
+ * and human-editable in an address bar.
+ *
+ * Scalar TYPE is a different question, and the one thing a URL genuinely cannot
+ * carry: `attempts:equals:3` is indistinguishable from a text `'3'`. Pass the
+ * table's `columns` to {@link readDataTableUrlState} and each value is coerced
+ * by its column's `filterType`; omit them and every scalar comes back a string.
+ * Always pass them when you have them.
+ */
+import { getDataTableFilterType, learnColumnOperators } from './filterTypes.js';
+import { filterTypeOf, operatorArity } from './operators.js';
+/**
+ * Repeated param carrying one encoded filter each.
+ *
+ * @stability experimental
+ */
+export const DATATABLE_FILTER_PARAM = 'filter';
+/**
+ * Param carrying the global quick-search term.
+ *
+ * @stability experimental
+ */
+export const DATATABLE_SEARCH_PARAM = 'q';
+// ---------------------------------------------------------------------------
+// One filter <-> one param value
+// ---------------------------------------------------------------------------
+function encodeSegment(raw) {
+    return encodeURIComponent(String(raw));
+}
+/**
+ * Encode a single filter as a `columnId:operator[:value]` param value.
+ *
+ * @stability experimental
+ */
+export function encodeFilter(filter) {
+    const head = `${encodeSegment(filter.columnId)}:${encodeSegment(filter.operator)}`;
+    const arity = operatorArity(filter.operator);
+    if (arity === 0 || filter.value === null)
+        return head;
+    const body = Array.isArray(filter.value)
+        ? filter.value.map(encodeSegment).join(',')
+        : encodeSegment(filter.value);
+    return `${head}:${body}`;
+}
+function coerceScalar(raw, filterType) {
+    const coerce = filterType === undefined ? undefined : getDataTableFilterType(filterType)?.coerce;
+    return coerce ? coerce(raw) : raw;
+}
+/**
+ * Decode one param value. Returns `null` for anything malformed — a hand-edited
+ * or stale URL should drop the offending filter, never throw on render.
+ *
+ * @stability experimental
+ */
+export function decodeFilter(encoded, columns) {
+    // Only the FIRST two colons are delimiters; the value segment may itself be
+    // an encoded string, and splitting greedily would truncate it.
+    const first = encoded.indexOf(':');
+    if (first <= 0)
+        return null;
+    const second = encoded.indexOf(':', first + 1);
+    for (const entry of columns ?? [])
+        learnColumnOperators(entry.filter?.operators);
+    const columnId = safeDecode(encoded.slice(0, first));
+    const operator = safeDecode(second === -1 ? encoded.slice(first + 1) : encoded.slice(first + 1, second));
+    if (!columnId || !operator)
+        return null;
+    const rawValue = second === -1 ? null : encoded.slice(second + 1);
+    const arity = operatorArity(operator);
+    const filterType = columns
+        ? (() => {
+            const column = columns.find((entry) => entry.id === columnId);
+            return column ? filterTypeOf(column) : undefined;
+        })()
+        : undefined;
+    let value;
+    if (arity === 0 || rawValue === null) {
+        value = null;
+    }
+    else if (arity === 2 || arity === 'many') {
+        const parts = rawValue === '' ? [] : rawValue.split(',');
+        value = parts.map((part) => coerceScalar(safeDecode(part), filterType));
+    }
+    else {
+        value = coerceScalar(safeDecode(rawValue), filterType);
+    }
+    return { columnId, operator, value };
+}
+function safeDecode(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        // A stray `%` in a hand-typed URL throws in decodeURIComponent; the literal
+        // text is a better answer than losing the whole filter.
+        return raw;
+    }
+}
+// ---------------------------------------------------------------------------
+// Whole-state read / write
+// ---------------------------------------------------------------------------
+/**
+ * Read the filter model and quick-search term out of a `URLSearchParams`.
+ * Unknown / malformed filter params are dropped silently.
+ *
+ * @stability experimental
+ */
+export function readDataTableUrlState(params, options = {}) {
+    const filterParam = options.filterParam ?? DATATABLE_FILTER_PARAM;
+    const searchParam = options.searchParam ?? DATATABLE_SEARCH_PARAM;
+    const filters = params
+        .getAll(filterParam)
+        .map((encoded) => decodeFilter(encoded, options.columns))
+        .filter((filter) => filter !== null);
+    return { filters, search: params.get(searchParam) ?? '' };
+}
+/**
+ * Write the filter model and quick-search term into a COPY of `params`, leaving
+ * every unrelated param (page, sort, tab, …) untouched. Returns the copy — the
+ * caller decides whether that becomes a push or a replace.
+ *
+ * An empty model / empty search removes its param entirely rather than leaving
+ * `?filter=&q=` behind, so a cleared table produces a clean URL.
+ *
+ * @stability experimental
+ */
+export function writeDataTableUrlState(params, state, options = {}) {
+    const filterParam = options.filterParam ?? DATATABLE_FILTER_PARAM;
+    const searchParam = options.searchParam ?? DATATABLE_SEARCH_PARAM;
+    const next = new URLSearchParams(params);
+    if (state.filters !== undefined) {
+        next.delete(filterParam);
+        for (const filter of state.filters)
+            next.append(filterParam, encodeFilter(filter));
+    }
+    if (state.search !== undefined) {
+        if (state.search.trim() === '')
+            next.delete(searchParam);
+        else
+            next.set(searchParam, state.search);
+    }
+    return next;
+}
+//# sourceMappingURL=filterUrl.js.map

package/dist/datatable/headless/filter/filterUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterUrl.js","sourceRoot":"","sources":["../../../../src/datatable/headless/filter/filterUrl.ts"],"names":[],"mappings":"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"}

package/dist/datatable/headless/filter/operators.d.ts

@@ -0,0 +1,115 @@
+/**
+ * DataTable — the operator catalog.
+ *
+ * One table maps a column's {@link DataTableFilterType} onto the operators the
+ * filter UI offers for it, and one function decides how many operands each
+ * operator takes. Everything else in `filter/` reads from here, so adding an
+ * operator is a single-file change.
+ *
+ * ## Why a declared type, not an inferred one
+ *
+ * The operator set could have been inferred from the first row's value. It
+ * isn't, because inference is unstable in exactly the cases that matter: an
+ * empty page has nothing to infer from, and a nullable column whose first page
+ * happens to be all nulls would silently offer text operators for a number.
+ * A column declares `filterType` once and the UI is deterministic forever.
+ *
+ * ## Why the defaults are narrow
+ *
+ * The default sets are the ones issue #254 specifies, and they are short on
+ * purpose — six operators on a text column is a menu nobody reads. A column
+ * that genuinely needs more pins them explicitly:
+ * `filterable: ['contains', 'endsWith', 'isNotEmpty']`.
+ */
+import type { BuiltinDataTableFilterType, DataTableColumn, DataTableFilterType, FilterOperator, OperatorArity } from '../types.js';
+export type { OperatorArity } from '../types.js';
+/**
+ * Assumed when a filterable column declares no `filterType`.
+ *
+ * @stability experimental
+ */
+export declare const DEFAULT_FILTER_TYPE: DataTableFilterType;
+/**
+ * The default operator set per BUILT-IN value type — issue #254's catalog,
+ * verbatim. Order is the order the operator picker lists them in, so the first
+ * entry is also the default operator for a fresh filter on that type. A type an
+ * app registered (`registerDataTableFilterType`) is not listed here; ask
+ * {@link operatorsForColumn}.
+ *
+ * @stability experimental
+ */
+export declare const OPERATORS_BY_FILTER_TYPE: Record<BuiltinDataTableFilterType, FilterOperator[]>;
+/**
+ * Display label for an operator, in the context of a value type: the type's
+ * own word for it when it lists the operator, else the platform's.
+ *
+ * @stability experimental
+ */
+export declare function operatorLabel(operator: FilterOperator, filterType?: DataTableFilterType): string;
+/**
+ * The label of an operator as one COLUMN offers it: its own inline definition
+ * (`filter.operators`) wins, then the column's type, then the platform's.
+ *
+ * @stability experimental
+ */
+export declare function columnOperatorLabel<Row>(column: DataTableColumn<Row>, operator: FilterOperator): string;
+/**
+ * How many values an operator takes (see {@link OperatorArity}). Knows the
+ * platform's operators and every one a registered filter type or a column
+ * declared; an id nobody declared takes one.
+ *
+ * @param operator - the filter operator.
+ * @returns its arity.
+ *
+ * @stability experimental
+ */
+export declare function operatorArity(operator: FilterOperator): OperatorArity;
+/**
+ * The value type a column filters as: `filter.type`, else `filterType`, else
+ * `text`.
+ *
+ * @stability experimental
+ */
+export declare function filterTypeOf<Row>(column: DataTableColumn<Row>): DataTableFilterType;
+/**
+ * Whether a column offers filtering at all.
+ *
+ * A column is filterable when `filterable` is `true` or a non-empty operator
+ * list, or when it declares a `filter` (unless `filterable` is `false`), AND
+ * its type is registered. An `enum` column with no `enumValues` is treated as
+ * NOT filterable: the operand picker would have nothing to list, and an
+ * operator you cannot supply a value for is exactly the "looks live, does
+ * nothing" affordance the contract refuses elsewhere (see `sortable`'s opt-in
+ * rationale). A column naming a type nobody registered is not filterable
+ * either, and says so once on the console.
+ *
+ * @stability experimental
+ */
+export declare function isFilterableColumn<Row>(column: DataTableColumn<Row>): boolean;
+/**
+ * Every filterable column, in declaration order.
+ *
+ * @stability experimental
+ */
+export declare function filterableColumns<Row>(columns: DataTableColumn<Row>[]): DataTableColumn<Row>[];
+/**
+ * The operators offered for a column: the explicit `filterable` array when one
+ * is declared, else the column's inline `filter.operators`, else the default
+ * set of its value type.
+ *
+ * @stability experimental
+ */
+export declare function operatorsForColumn<Row>(column: DataTableColumn<Row>): FilterOperator[];
+/**
+ * The operator a fresh filter on this column starts with.
+ *
+ * @stability experimental
+ */
+export declare function defaultOperatorForColumn<Row>(column: DataTableColumn<Row>): FilterOperator;
+/**
+ * Every column marked `searchable`, in declaration order.
+ *
+ * @stability experimental
+ */
+export declare function searchableColumns<Row>(columns: DataTableColumn<Row>[]): DataTableColumn<Row>[];
+//# sourceMappingURL=operators.d.ts.map

package/dist/datatable/headless/filter/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../../src/datatable/headless/filter/operators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EACV,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EACnB,cAAc,EAEd,aAAa,EACd,MAAM,aAAa,CAAC;AAQrB,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAA4B,CAAC;AAQ/D;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,0BAA0B,EAAE,cAAc,EAAE,CAEjC,CAAC;AAe1D;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,cAAc,EACxB,UAAU,GAAE,mBAAyC,GACpD,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,cAAc,GAAG,MAAM,CAGvG;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,cAAc,GAAG,aAAa,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,GAAG,mBAAmB,CAEnF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,GAAG,OAAO,CAc7E;AASD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EACnC,OAAO,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,GAC9B,eAAe,CAAC,GAAG,CAAC,EAAE,CAExB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,GAAG,cAAc,EAAE,CAWtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC,GAAG,cAAc,CAE1F;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EACnC,OAAO,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,GAC9B,eAAe,CAAC,GAAG,CAAC,EAAE,CAExB"}

package/dist/datatable/headless/filter/operators.js

@@ -0,0 +1,183 @@
+/**
+ * DataTable — the operator catalog.
+ *
+ * One table maps a column's {@link DataTableFilterType} onto the operators the
+ * filter UI offers for it, and one function decides how many operands each
+ * operator takes. Everything else in `filter/` reads from here, so adding an
+ * operator is a single-file change.
+ *
+ * ## Why a declared type, not an inferred one
+ *
+ * The operator set could have been inferred from the first row's value. It
+ * isn't, because inference is unstable in exactly the cases that matter: an
+ * empty page has nothing to infer from, and a nullable column whose first page
+ * happens to be all nulls would silently offer text operators for a number.
+ * A column declares `filterType` once and the UI is deterministic forever.
+ *
+ * ## Why the defaults are narrow
+ *
+ * The default sets are the ones issue #254 specifies, and they are short on
+ * purpose — six operators on a text column is a menu nobody reads. A column
+ * that genuinely needs more pins them explicitly:
+ * `filterable: ['contains', 'endsWith', 'isNotEmpty']`.
+ */
+import { BUILTIN_OPERATORS, getDataTableFilterType, knownOperatorArity, learnColumnOperators, } from './filterTypes.js';
+/**
+ * Assumed when a filterable column declares no `filterType`.
+ *
+ * @stability experimental
+ */
+export const DEFAULT_FILTER_TYPE = 'text';
+const BUILTIN_TYPE_IDS = ['text', 'number', 'date', 'enum', 'boolean'];
+function defaultsOf(type) {
+    return getDataTableFilterType(type).operators.map((operator) => operator.id);
+}
+/**
+ * The default operator set per BUILT-IN value type — issue #254's catalog,
+ * verbatim. Order is the order the operator picker lists them in, so the first
+ * entry is also the default operator for a fresh filter on that type. A type an
+ * app registered (`registerDataTableFilterType`) is not listed here; ask
+ * {@link operatorsForColumn}.
+ *
+ * @stability experimental
+ */
+export const OPERATORS_BY_FILTER_TYPE = Object.fromEntries(BUILTIN_TYPE_IDS.map((type) => [type, defaultsOf(type)]));
+/**
+ * Number columns read `=`, `>`, `<` rather than "equals / is greater than / is
+ * less than", which is how anyone scanning a numeric filter actually thinks
+ * about it. Covers the pinned-only `gte` / `lte` too.
+ */
+const NUMBER_OPERATOR_LABELS = {
+    equals: '=',
+    gt: '>',
+    lt: '<',
+    gte: '≥',
+    lte: '≤',
+};
+/**
+ * Display label for an operator, in the context of a value type: the type's
+ * own word for it when it lists the operator, else the platform's.
+ *
+ * @stability experimental
+ */
+export function operatorLabel(operator, filterType = DEFAULT_FILTER_TYPE) {
+    const listed = getDataTableFilterType(filterType)?.operators.find((def) => def.id === operator);
+    if (listed)
+        return listed.label;
+    if (filterType === 'number' && NUMBER_OPERATOR_LABELS[operator])
+        return NUMBER_OPERATOR_LABELS[operator];
+    return BUILTIN_OPERATORS[operator]?.label ?? operator;
+}
+/**
+ * The label of an operator as one COLUMN offers it: its own inline definition
+ * (`filter.operators`) wins, then the column's type, then the platform's.
+ *
+ * @stability experimental
+ */
+export function columnOperatorLabel(column, operator) {
+    const inline = column.filter?.operators?.find((def) => def.id === operator);
+    return inline ? inline.label : operatorLabel(operator, filterTypeOf(column));
+}
+/**
+ * How many values an operator takes (see {@link OperatorArity}). Knows the
+ * platform's operators and every one a registered filter type or a column
+ * declared; an id nobody declared takes one.
+ *
+ * @param operator - the filter operator.
+ * @returns its arity.
+ *
+ * @stability experimental
+ */
+export function operatorArity(operator) {
+    return knownOperatorArity(operator);
+}
+/**
+ * The value type a column filters as: `filter.type`, else `filterType`, else
+ * `text`.
+ *
+ * @stability experimental
+ */
+export function filterTypeOf(column) {
+    return column.filter?.type ?? column.filterType ?? DEFAULT_FILTER_TYPE;
+}
+/**
+ * Whether a column offers filtering at all.
+ *
+ * A column is filterable when `filterable` is `true` or a non-empty operator
+ * list, or when it declares a `filter` (unless `filterable` is `false`), AND
+ * its type is registered. An `enum` column with no `enumValues` is treated as
+ * NOT filterable: the operand picker would have nothing to list, and an
+ * operator you cannot supply a value for is exactly the "looks live, does
+ * nothing" affordance the contract refuses elsewhere (see `sortable`'s opt-in
+ * rationale). A column naming a type nobody registered is not filterable
+ * either, and says so once on the console.
+ *
+ * @stability experimental
+ */
+export function isFilterableColumn(column) {
+    const declared = column.filterable === true ||
+        (Array.isArray(column.filterable) && column.filterable.length > 0) ||
+        (column.filter !== undefined && column.filterable !== false);
+    if (!declared)
+        return false;
+    learnColumnOperators(column.filter?.operators);
+    const type = filterTypeOf(column);
+    if (!getDataTableFilterType(type)) {
+        warnUnknownType(type, column.id);
+        return false;
+    }
+    if (type === 'enum')
+        return (column.enumValues?.length ?? 0) > 0;
+    return true;
+}
+const warnedTypes = new Set();
+function warnUnknownType(type, columnId) {
+    if (warnedTypes.has(type))
+        return;
+    warnedTypes.add(type);
+    console.warn(`DataTable column "${columnId}" filters as "${type}", which is not registered (registerDataTableFilterType); it is not filterable.`);
+}
+/**
+ * Every filterable column, in declaration order.
+ *
+ * @stability experimental
+ */
+export function filterableColumns(columns) {
+    return columns.filter(isFilterableColumn);
+}
+/**
+ * The operators offered for a column: the explicit `filterable` array when one
+ * is declared, else the column's inline `filter.operators`, else the default
+ * set of its value type.
+ *
+ * @stability experimental
+ */
+export function operatorsForColumn(column) {
+    if (Array.isArray(column.filterable) && column.filterable.length > 0) {
+        learnColumnOperators(column.filter?.operators);
+        return column.filterable;
+    }
+    if (column.filter?.operators && column.filter.operators.length > 0) {
+        learnColumnOperators(column.filter.operators);
+        return column.filter.operators.map((operator) => operator.id);
+    }
+    const type = getDataTableFilterType(filterTypeOf(column));
+    return type ? type.operators.map((operator) => operator.id) : [];
+}
+/**
+ * The operator a fresh filter on this column starts with.
+ *
+ * @stability experimental
+ */
+export function defaultOperatorForColumn(column) {
+    return operatorsForColumn(column)[0];
+}
+/**
+ * Every column marked `searchable`, in declaration order.
+ *
+ * @stability experimental
+ */
+export function searchableColumns(columns) {
+    return columns.filter((column) => column.searchable === true);
+}
+//# sourceMappingURL=operators.js.map

package/dist/datatable/headless/filter/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sourceRoot":"","sources":["../../../../src/datatable/headless/filter/operators.ts"],"names":[],"mappings":"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"}

package/dist/datatable/headless/index.d.ts

@@ -0,0 +1,22 @@
+export { extractColumnValue, formatColumnValue, rowAccessibleName } from './columns.js';
+export { BUILTIN_OPERATORS, FILTER_TYPE_ID_PATTERN, getDataTableFilterType, knownOperatorArity, learnColumnOperators, listDataTableFilterTypes, registerDataTableFilterType, } from './filter/filterTypes.js';
+export type { DataTableFilterTypeDef } from './filter/filterTypes.js';
+export { matchesFilterValue, matchesFilters } from './filter/filterMatch.js';
+export { OPERATORS_BY_FILTER_TYPE, DEFAULT_FILTER_TYPE, columnOperatorLabel, operatorLabel, operatorArity, operatorsForColumn, defaultOperatorForColumn, filterTypeOf, isFilterableColumn, filterableColumns, searchableColumns, } from './filter/operators.js';
+export { addFilter, removeFilterAt, replaceFilterAt, containsFilter, sameFilter, filterKey, filterChipLabel, describeFilterValue, isFilterComplete, draftFilterFor, blankValueFor, columnForFilter, } from './filter/filterModel.js';
+export { readDataTableUrlState, writeDataTableUrlState, encodeFilter, decodeFilter, DATATABLE_FILTER_PARAM, DATATABLE_SEARCH_PARAM, } from './filter/filterUrl.js';
+export type { DataTableUrlState, DataTableUrlOptions } from './filter/filterUrl.js';
+export { useDataTableLayoutPrefs } from './layout/useDataTableLayoutPrefs.js';
+export type { DataTableLayoutPrefs, UseDataTableLayoutPrefsOptions, } from './layout/useDataTableLayoutPrefs.js';
+export { CARD_DENSITY, DATA_TABLE_ENTRY_MAX_BYTES, DATA_TABLE_EXTRA_MAX_BYTES, DATA_TABLE_EXTRA_MAX_DEPTH, DATA_TABLE_EXTRA_MAX_KEYS, DATA_TABLE_MAX_ID_LENGTH, DATA_TABLE_MAX_SAVED_VIEWS, DATA_TABLE_MAX_VISIBLE_COLUMNS, DATA_TABLE_PERSIST_DEBOUNCE_MS, DATA_TABLE_VIEW_NAME_MAX_LENGTH, DEFAULT_DENSITY, DENSITY_LABELS, DENSITY_OPTIONS, HIDDEN_COLUMN_PREFIX, cardDensityMetrics, decodeVisibility, encodeVisibility, isDensity, isEmptyStoredLayout, isHideable, isValidStoredExtra, jsonByteLength, layoutHidesColumn, pickerColumns, resolveStoredSort, resolveUserVisibleColumnIds, resolveVisibleColumnIds, sanitizeStoredLayout, } from './layout/layoutModel.js';
+export type { CardDensityMetrics, DataTablesSettings, DataTableSavedView, DataTableStoredLayout, DataTableStoredSort, DataTableViewLayout, DecodedVisibility, } from './layout/layoutModel.js';
+export { CSV_BOM, CSV_FIELD_SEPARATOR, CSV_FORMULA_ESCAPE, CSV_FORMULA_PREFIXES, CSV_ROW_SEPARATOR, escapeCsvField, isFormulaText, neutralizeFormula, toCsv, toCsvFile, toCsvRow, } from './export/csv.js';
+export { DATA_TABLE_EXPORT_FETCH_PAGE_SIZE, DATA_TABLE_EXPORT_MAX_ROWS, ExportCancelledError, buildCsvForRows, buildExportMatrix, collectAllRows, downloadCsv, exportColumns, exportFilename, isExportableColumn, slugifyExportName, } from './export/exportModel.js';
+export type { CollectAllRowsOptions, CollectAllRowsResult, ExportMatrix, } from './export/exportModel.js';
+export { GRID_CHROME_HEIGHT, GRID_ROW_HEIGHT, GRID_VIRTUALIZATION_ROW_THRESHOLD, GRID_VIRTUALIZED_VISIBLE_ROWS, planGridVirtualization, virtualizedViewportHeight, } from './virtualization/gridVirtualization.js';
+export type { GridVirtualizationInput, GridVirtualizationPlan, } from './virtualization/gridVirtualization.js';
+export { CARD_FALLBACK_INTRINSIC_HEIGHT, CARD_VIRTUALIZATION_MIN_ROWS, containIntrinsicSize, shouldVirtualizeCards, useLazyImages, useMeasuredCardHeight, } from './virtualization/cardVirtualization.js';
+export type { DataTableColumn, DataTableColumnPriority, DataTableAlign, DataTableDensity, DataTableSortDirection, DataTableSortState, DataTableSortConfig, DataTablePaginationConfig, DataTableSelectionConfig, DataTableRowAction, DataTableBulkAction, DataTableConfirmOptions, DataTableProps, DataTableRendererProps, DataTableRendererMode, DataTableLayout, DataTableRendererKind, BuiltinDataTableFilterType, BuiltinFilterOperator, DataTableBulkBarSlotProps, DataTableColumnFilter, DataTableSlots, DataTableToolbarSlotProps, FilterOperator, FilterOperatorDef, FilterValueEditorProps, OperatorArity, DataTableFilterType, DataTableEnumValue, DataTableFilter, DataTableFilterModel, DataTableFilterValue, DataTableQuickSearchConfig, DataTableExportConfig, DataTableExportFetchPage, } from './types.js';
+export { DataTablePreferencesProvider, createUserSettingsPreferencesPort, useDataTablePreferencesPort, } from './layout/preferences.js';
+export type { DataTablePreferencesPort } from './layout/preferences.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/datatable/headless/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/datatable/headless/index.ts"],"names":[],"mappings":"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"}