@object-ui/core 6.2.2 → 7.0.0

package/dist/styling/scoped-styles.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Scoped style-object → CSS compiler (framework ADR-0065).
+ *
+ * The SDUI styling primitive: a metadata node carries a `responsiveStyles`
+ * object (per-breakpoint CSS-property maps); at render time it compiles to
+ * **id-scoped CSS** injected as a `<style>` tag. This is build-independent
+ * (arbitrary values + design tokens pass through verbatim — no Tailwind JIT
+ * needed), collision-free (scoped to one node's class — two independently-built
+ * stylesheets cannot fight), and responsive-correct (model breakpoint maps →
+ * generated `@media`, never author-written `md:` variant classes).
+ *
+ * Mirrors Builder.io's SDK (`createCssClass` / `responsiveStyles`). Desktop-first:
+ * `large` is the unconditional base; `medium`/`small`/`xsmall` are `max-width`
+ * overrides.
+ */
+export type StyleMap = Record<string, string | number>;
+export interface ResponsiveStyles {
+    /** Unconditional base (desktop-first). */
+    large?: StyleMap;
+    medium?: StyleMap;
+    small?: StyleMap;
+    xsmall?: StyleMap;
+}
+/** max-width breakpoints (px), mirroring Builder.io's default device sizes. */
+export declare const STYLE_BREAKPOINTS: Record<'medium' | 'small' | 'xsmall', number>;
+/** True when a node actually carries responsive styles worth compiling. */
+export declare function hasResponsiveStyles(rs: unknown): rs is ResponsiveStyles;
+/** Deterministic, CSS-safe scope class for a node id. */
+export declare function scopeClassFor(id: string): string;
+/**
+ * Compile a node's responsive styles to CSS scoped to `selector`.
+ * Returns '' when there is nothing to emit. No unscoped/global rule is ever
+ * produced — that scoping is what makes per-node styles collision-free.
+ */
+export declare function compileScopedStyles(selector: string, rs: ResponsiveStyles): string;

package/dist/styling/scoped-styles.js

@@ -0,0 +1,68 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * Scoped style-object → CSS compiler (framework ADR-0065).
+ *
+ * The SDUI styling primitive: a metadata node carries a `responsiveStyles`
+ * object (per-breakpoint CSS-property maps); at render time it compiles to
+ * **id-scoped CSS** injected as a `<style>` tag. This is build-independent
+ * (arbitrary values + design tokens pass through verbatim — no Tailwind JIT
+ * needed), collision-free (scoped to one node's class — two independently-built
+ * stylesheets cannot fight), and responsive-correct (model breakpoint maps →
+ * generated `@media`, never author-written `md:` variant classes).
+ *
+ * Mirrors Builder.io's SDK (`createCssClass` / `responsiveStyles`). Desktop-first:
+ * `large` is the unconditional base; `medium`/`small`/`xsmall` are `max-width`
+ * overrides.
+ */
+/** max-width breakpoints (px), mirroring Builder.io's default device sizes. */
+export const STYLE_BREAKPOINTS = {
+    medium: 991,
+    small: 640,
+    xsmall: 479,
+};
+const camelToKebab = (k) => k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+/** Style-map → `prop: value;` declarations. Values pass through **verbatim** —
+ * that is the whole point: arbitrary values (`13px`, `#1a2b3c`) and design
+ * tokens (`var(--space-6)`) work with zero build step. */
+const declarations = (m) => Object.entries(m)
+    .filter(([, v]) => v != null && v !== '')
+    .map(([k, v]) => `${camelToKebab(k)}: ${typeof v === 'number' ? String(v) : v};`)
+    .join(' ');
+/** True when a node actually carries responsive styles worth compiling. */
+export function hasResponsiveStyles(rs) {
+    if (!rs || typeof rs !== 'object')
+        return false;
+    const r = rs;
+    return Boolean(r.large || r.medium || r.small || r.xsmall);
+}
+/** Deterministic, CSS-safe scope class for a node id. */
+export function scopeClassFor(id) {
+    return `os-s-${String(id).replace(/[^a-zA-Z0-9_-]/g, '-')}`;
+}
+/**
+ * Compile a node's responsive styles to CSS scoped to `selector`.
+ * Returns '' when there is nothing to emit. No unscoped/global rule is ever
+ * produced — that scoping is what makes per-node styles collision-free.
+ */
+export function compileScopedStyles(selector, rs) {
+    const rules = [];
+    if (rs.large) {
+        const base = declarations(rs.large);
+        if (base)
+            rules.push(`${selector} { ${base} }`);
+    }
+    for (const size of ['medium', 'small', 'xsmall']) {
+        const s = rs[size];
+        if (!s)
+            continue;
+        const d = declarations(s);
+        if (d)
+            rules.push(`@media (max-width: ${STYLE_BREAKPOINTS[size]}px) { ${selector} { ${d} } }`);
+    }
+    return rules.join('\n');
+}

package/dist/utils/chart-series.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * chart-series — shape a semantic-layer `queryDataset` result into the
+ * `{ data, xAxisKey, series }` triple a chart renderer consumes (ADR-0021, #1759).
+ *
+ * Shared by `ObjectChart` (plugin-charts) and `DatasetWidget` (plugin-dashboard)
+ * so multi-dimension charts visualise identically across surfaces.
+ *
+ * Rules:
+ *  - **2+ dimensions, single measure** → pivot the SECOND dimension into one
+ *    series per distinct value (grouped/coloured bars). `xAxisKey` = first
+ *    dimension; each output row is one first-dimension bucket with a column per
+ *    second-dimension value holding the measure. This makes the second dimension
+ *    visible instead of just repeating the x-axis label.
+ *  - **otherwise** (single dimension, or multiple measures) → first dimension is
+ *    the x-axis and each measure is its own series (long format passes through).
+ */
+export interface ChartResultField {
+    name: string;
+    label?: string;
+    format?: string;
+}
+export interface ChartSeries {
+    dataKey: string;
+    label: string;
+}
+export interface ChartSeriesResult {
+    data: Array<Record<string, unknown>>;
+    xAxisKey: string | undefined;
+    series: ChartSeries[];
+}
+export declare function buildChartSeries(rows: Array<Record<string, unknown>> | null | undefined, dimensions: string[] | null | undefined, values: string[] | null | undefined, fields?: ChartResultField[] | null): ChartSeriesResult;
+/**
+ * Inverse of {@link buildChartSeries}: map a clicked chart segment back to the
+ * index of its source dataset row, so a chart click can drill through to the
+ * same records a table/pivot row would.
+ *
+ * Mirrors `buildChartSeries`' pivot rule:
+ *  - **2+ dimensions, single measure** (second dim pivoted into series) → match
+ *    BOTH the x-axis dimension (`category`) and the series dimension (`seriesKey`).
+ *  - **otherwise** → match the x-axis (first) dimension only.
+ *
+ * Comparison is string-wise on the rows' display values (which is what the chart
+ * surfaces as `category` / series key). Returns `-1` when nothing matches.
+ */
+export declare function findChartSeriesRow(rows: Array<Record<string, unknown>> | null | undefined, dimensions: string[] | null | undefined, values: string[] | null | undefined, category: string | undefined, seriesKey?: string): number;

package/dist/utils/chart-series.js

@@ -0,0 +1,72 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export function buildChartSeries(rows, dimensions, values, fields) {
+    const dims = (dimensions ?? []).filter(Boolean);
+    const vals = (values ?? []).filter(Boolean);
+    const safeRows = Array.isArray(rows) ? rows : [];
+    const labelOf = (name) => (fields ?? []).find((f) => f.name === name)?.label ?? name;
+    // Multi-dimension, single-measure → pivot the second dimension into series.
+    if (dims.length >= 2 && vals.length === 1) {
+        const xKey = dims[0];
+        const groupKey = dims[1];
+        const measure = vals[0];
+        const seriesKeys = [];
+        const byX = new Map();
+        for (const row of safeRows) {
+            const xRaw = row[xKey];
+            const xId = String(xRaw ?? '');
+            if (!byX.has(xId))
+                byX.set(xId, { [xKey]: xRaw });
+            const gId = String(row[groupKey] ?? '');
+            if (gId !== '' && !seriesKeys.includes(gId))
+                seriesKeys.push(gId);
+            byX.get(xId)[gId] = row[measure];
+        }
+        return {
+            data: Array.from(byX.values()),
+            xAxisKey: xKey,
+            // Series labels are the second-dimension values themselves (already
+            // server-resolved to display labels by queryDataset).
+            series: seriesKeys.map((k) => ({ dataKey: k, label: k })),
+        };
+    }
+    // Default: first dimension on the x-axis, one series per measure.
+    return {
+        data: safeRows,
+        xAxisKey: dims[0],
+        series: vals.map((v) => ({ dataKey: v, label: labelOf(v) })),
+    };
+}
+/**
+ * Inverse of {@link buildChartSeries}: map a clicked chart segment back to the
+ * index of its source dataset row, so a chart click can drill through to the
+ * same records a table/pivot row would.
+ *
+ * Mirrors `buildChartSeries`' pivot rule:
+ *  - **2+ dimensions, single measure** (second dim pivoted into series) → match
+ *    BOTH the x-axis dimension (`category`) and the series dimension (`seriesKey`).
+ *  - **otherwise** → match the x-axis (first) dimension only.
+ *
+ * Comparison is string-wise on the rows' display values (which is what the chart
+ * surfaces as `category` / series key). Returns `-1` when nothing matches.
+ */
+export function findChartSeriesRow(rows, dimensions, values, category, seriesKey) {
+    const dims = (dimensions ?? []).filter(Boolean);
+    const vals = (values ?? []).filter(Boolean);
+    const safeRows = Array.isArray(rows) ? rows : [];
+    const xDim = dims[0];
+    if (!xDim)
+        return -1;
+    const c = String(category ?? '');
+    if (dims.length >= 2 && vals.length === 1) {
+        const gDim = dims[1];
+        const s = String(seriesKey ?? '');
+        return safeRows.findIndex((r) => String(r[xDim] ?? '') === c && String(r[gDim] ?? '') === s);
+    }
+    return safeRows.findIndex((r) => String(r[xDim] ?? '') === c);
+}

package/dist/utils/dataset-format.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * dataset-format — shared value formatting for semantic-layer `queryDataset`
+ * results (ADR-0021). Used by every dataset-bound surface (dashboard widgets,
+ * reports, the dataset preview) so a measure renders identically everywhere:
+ * a currency amount carries its declared currency symbol, a plain number stays
+ * a plain number, and a dimension label passes through untouched.
+ *
+ * Pure (no React / i18n) so it can live in `@object-ui/core` and be imported
+ * by both `@object-ui/plugin-dashboard` and `@object-ui/plugin-report`.
+ */
+/**
+ * Column metadata the analytics server returns alongside the rows: a display
+ * `label` for both dimensions and measures, plus a measure's numeral `format`
+ * and declared `currency`. A superset of {@link ChartResultField} (which only
+ * needs name/label/format).
+ */
+export interface DatasetResultField {
+    name: string;
+    type?: string;
+    label?: string;
+    format?: string;
+    currency?: string;
+}
+/**
+ * Scale a stored `percent`-field value to its DISPLAY magnitude.
+ *
+ * Percent fields store a FRACTION (0–1) by convention — a stored `0.75` means
+ * 75% (see the percent edit widget `PercentField`, which divides input by 100).
+ * A value already in whole-percent form (magnitude ≥ 1, e.g. a `progress` /
+ * `completion` field storing `57`) is passed through unchanged. This is the
+ * SINGLE source of truth for percent display scaling, shared by the list-view
+ * percent cell renderer (`formatPercent` in `@object-ui/fields`) and the dataset
+ * measure formatter ({@link formatMeasure}) so a percent renders identically as
+ * a row value and as an aggregated metric — the two surfaces can never drift.
+ */
+export declare function percentDisplayValue(value: number): number;
+/**
+ * Format a MEASURE value. Currency comes from the field's declared `currency`
+ * (locale-correct symbol via `Intl`), NOT from a "$" baked into the format
+ * string — an amount with no declared currency must render as a plain number,
+ * never a misleading "$". The numeral `format` hint (e.g. "0,0", "0.0%")
+ * controls grouping / decimals / percent; it can't be baked into the row value
+ * server-side (the same number feeds charts), so it is applied here.
+ */
+export declare function formatMeasure(v: unknown, format?: string, currency?: string): string;
+/**
+ * Format a non-measure (dimension / label) value — the server already resolves
+ * dimension display labels, so this only tidies numbers and nulls.
+ */
+export declare function formatDimensionValue(v: unknown): string;
+/**
+ * Resolve a column header / measure helper pair for one result set.
+ * `headerLabel` maps a dimension/measure NAME to its display label — the
+ * server-enriched field `label`, then (when `fieldLabel` is supplied) through
+ * the i18n field-label convention so a translated label wins, then the raw name
+ * as a last resort. `measureField` exposes a field's `format`/`currency`.
+ *
+ * `fieldLabel` is injected (rather than imported) so this stays React/i18n-free;
+ * callers pass `useSafeFieldLabel().fieldLabel`.
+ */
+export declare function buildDatasetFieldHelpers(fields: DatasetResultField[] | undefined, object: string | undefined, fieldLabel?: (objectName: string, fieldName: string, fallback: string) => string): {
+    measureField: (name: string) => DatasetResultField | undefined;
+    headerLabel: (name: string) => string;
+};
+/**
+ * Build the record-list filter for a drilled dataset bucket (ADR-0021 D2).
+ *
+ * Each drillable dimension maps to its underlying object field, filtered by the
+ * dimension's RAW grouped value (from the server's parallel `drillRawRows`, NOT
+ * the visible row which carries the display LABEL — a select/lookup label would
+ * mis-filter). An empty/undefined raw value normalizes to `null` (an explicit
+ * "is empty" filter). The render-time `runtimeFilter` is ANDed in so the drilled
+ * list stays within the same slice the aggregate was computed over.
+ *
+ * Shared by the dashboard `DatasetWidget` and the report renderer so a drill
+ * filters identically (and correctly, including lookups) on both surfaces.
+ */
+export declare function buildDatasetDrillFilter(rawRow: Record<string, unknown> | undefined, drillDims: string[], dimensionFields: Record<string, string>, runtimeFilter?: Record<string, unknown>): Record<string, unknown>;

package/dist/utils/dataset-format.js

@@ -0,0 +1,117 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Scale a stored `percent`-field value to its DISPLAY magnitude.
+ *
+ * Percent fields store a FRACTION (0–1) by convention — a stored `0.75` means
+ * 75% (see the percent edit widget `PercentField`, which divides input by 100).
+ * A value already in whole-percent form (magnitude ≥ 1, e.g. a `progress` /
+ * `completion` field storing `57`) is passed through unchanged. This is the
+ * SINGLE source of truth for percent display scaling, shared by the list-view
+ * percent cell renderer (`formatPercent` in `@object-ui/fields`) and the dataset
+ * measure formatter ({@link formatMeasure}) so a percent renders identically as
+ * a row value and as an aggregated metric — the two surfaces can never drift.
+ */
+export function percentDisplayValue(value) {
+    return value > -1 && value < 1 ? value * 100 : value;
+}
+/**
+ * Format a MEASURE value. Currency comes from the field's declared `currency`
+ * (locale-correct symbol via `Intl`), NOT from a "$" baked into the format
+ * string — an amount with no declared currency must render as a plain number,
+ * never a misleading "$". The numeral `format` hint (e.g. "0,0", "0.0%")
+ * controls grouping / decimals / percent; it can't be baked into the row value
+ * server-side (the same number feeds charts), so it is applied here.
+ */
+export function formatMeasure(v, format, currency) {
+    if (v == null)
+        return '—';
+    if (typeof v !== 'number')
+        return String(v);
+    const decimals = format ? (format.split('.')[1]?.match(/0/g)?.length ?? 0) : undefined;
+    if (currency) {
+        try {
+            return new Intl.NumberFormat(undefined, {
+                style: 'currency',
+                currency,
+                minimumFractionDigits: decimals ?? 0,
+                maximumFractionDigits: decimals ?? 2,
+            }).format(v);
+        }
+        catch {
+            // Unknown currency code → fall through to plain number formatting.
+        }
+    }
+    if (!format) {
+        // No format hint → preserve the plain rendering (integers verbatim).
+        return Number.isInteger(v) ? String(v) : v.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    }
+    const isPercent = format.includes('%');
+    // A legacy "$" literal in the format string is still honored (explicit author
+    // choice) — but it is NOT how a real currency field gets its symbol.
+    const legacyDollar = format.includes('$') ? '$' : '';
+    // numeral's "0.0%" multiplies by 100, and a percent field stores a FRACTION
+    // (0.75 ⇒ 75%). Scale to display magnitude the SAME way the list-view cell
+    // renderer does — otherwise an avg of 0.608 renders as "0.6%" instead of
+    // "60.8%", disagreeing with the per-row "75%" the list already shows.
+    const display = isPercent ? percentDisplayValue(v) : v;
+    const body = display.toLocaleString(undefined, { minimumFractionDigits: decimals ?? 0, maximumFractionDigits: decimals ?? 0 });
+    return `${legacyDollar}${body}${isPercent ? '%' : ''}`;
+}
+/**
+ * Format a non-measure (dimension / label) value — the server already resolves
+ * dimension display labels, so this only tidies numbers and nulls.
+ */
+export function formatDimensionValue(v) {
+    if (v == null)
+        return '—';
+    if (typeof v === 'number') {
+        return Number.isInteger(v) ? String(v) : v.toLocaleString(undefined, { maximumFractionDigits: 2 });
+    }
+    return String(v);
+}
+/**
+ * Resolve a column header / measure helper pair for one result set.
+ * `headerLabel` maps a dimension/measure NAME to its display label — the
+ * server-enriched field `label`, then (when `fieldLabel` is supplied) through
+ * the i18n field-label convention so a translated label wins, then the raw name
+ * as a last resort. `measureField` exposes a field's `format`/`currency`.
+ *
+ * `fieldLabel` is injected (rather than imported) so this stays React/i18n-free;
+ * callers pass `useSafeFieldLabel().fieldLabel`.
+ */
+export function buildDatasetFieldHelpers(fields, object, fieldLabel) {
+    const fieldByName = new Map((fields ?? []).map((f) => [f.name, f]));
+    const measureField = (name) => fieldByName.get(name);
+    const headerLabel = (name) => {
+        const fallback = measureField(name)?.label ?? name;
+        return object && fieldLabel ? fieldLabel(object, name, fallback) : fallback;
+    };
+    return { measureField, headerLabel };
+}
+/**
+ * Build the record-list filter for a drilled dataset bucket (ADR-0021 D2).
+ *
+ * Each drillable dimension maps to its underlying object field, filtered by the
+ * dimension's RAW grouped value (from the server's parallel `drillRawRows`, NOT
+ * the visible row which carries the display LABEL — a select/lookup label would
+ * mis-filter). An empty/undefined raw value normalizes to `null` (an explicit
+ * "is empty" filter). The render-time `runtimeFilter` is ANDed in so the drilled
+ * list stays within the same slice the aggregate was computed over.
+ *
+ * Shared by the dashboard `DatasetWidget` and the report renderer so a drill
+ * filters identically (and correctly, including lookups) on both surfaces.
+ */
+export function buildDatasetDrillFilter(rawRow, drillDims, dimensionFields, runtimeFilter) {
+    const drillFilter = {};
+    for (const d of drillDims) {
+        const raw = rawRow?.[d];
+        drillFilter[dimensionFields[d]] = raw === '' || raw === undefined ? null : raw;
+    }
+    return runtimeFilter ? { ...runtimeFilter, ...drillFilter } : drillFilter;
+}

package/dist/validation/validators/object-validation-engine.js

@@ -290,29 +290,28 @@ export class ObjectValidationEngine {
      * Validate state machine transitions
      */
     validateStateMachine(rule, context) {
-        const currentState = context.record[rule.stateField];
-        const previousState = context.oldRecord?.[rule.stateField];
-        // If no previous state (insert), allow any state
-        if (!previousState) {
+        // ADR-0020 flat FSM: a `field` plus a `{ from: [allowedTo] }` map.
+        // Semantics mirror the server-side rule-validator:
+        //   - insert / no prior state           → allow (initial assignment)
+        //   - field unchanged (from === to)      → allow (no transition)
+        //   - `from` not declared in the map      → lenient allow (unconstrained)
+        //   - `to` ∉ transitions[from]           → reject
+        const currentState = context.record[rule.field];
+        const previousState = context.oldRecord?.[rule.field];
+        // No prior state (insert) — any initial value is allowed.
+        if (previousState === undefined || previousState === null) {
             return { valid: true };
         }
-        // Check if transition is allowed
-        for (const transition of rule.transitions) {
-            const fromStates = Array.isArray(transition.from) ? transition.from : [transition.from];
-            if (!fromStates.includes(previousState)) {
-                continue;
-            }
-            if (transition.to !== currentState) {
-                continue;
-            }
-            // Check condition if specified
-            if (transition.condition) {
-                const conditionMet = this.expressionEvaluator.evaluate(transition.condition, context.record);
-                if (!conditionMet) {
-                    continue;
-                }
-            }
-            // Valid transition found
+        // The state field wasn't part of this change — nothing to police.
+        if (previousState === currentState) {
+            return { valid: true };
+        }
+        const allowed = rule.transitions[previousState];
+        // `from` state not declared — leave it unconstrained (lenient).
+        if (allowed === undefined) {
+            return { valid: true };
+        }
+        if (allowed.includes(currentState)) {
             return { valid: true };
         }
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/core",
-  "version": "6.2.2",
+  "version": "7.0.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -25,14 +25,15 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^6.7.1",
+    "@objectstack/formula": "^10.0.0",
+    "@objectstack/spec": "^10.0.0",
     "lodash": "^4.18.1",
     "zod": "^4.4.3",
-    "@object-ui/types": "6.2.2"
+    "@object-ui/types": "7.0.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.9"
   },
   "keywords": [
     "objectui",

package/dist/utils/normalize-quick-filter.d.ts

@@ -1,29 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * QuickFilter Normalization Utility
- *
- * Adapter layer that converts between two QuickFilter formats:
- * - Spec format:     { field, operator, value }
- * - ObjectUI format: { id, label, filters[], icon?, defaultActive? }
- *
- * Both formats are accepted; spec-format items are auto-converted to ObjectUI format.
- */
-import type { QuickFilterItem, ObjectUIQuickFilterItem } from '@object-ui/types';
-/** Normalized ObjectUI QuickFilter shape (output of normalizeQuickFilter) */
-export type NormalizedQuickFilter = ObjectUIQuickFilterItem;
-/**
- * Normalize a single QuickFilter item.
- * - If it's already in ObjectUI format (has id + label + filters), return as-is.
- * - If it's in Spec format (has field + operator), convert to ObjectUI format.
- */
-export declare function normalizeQuickFilter(item: QuickFilterItem): NormalizedQuickFilter;
-/**
- * Normalize an array of QuickFilter items (mixed formats accepted).
- */
-export declare function normalizeQuickFilters(items: QuickFilterItem[] | undefined): NormalizedQuickFilter[] | undefined;

package/dist/utils/normalize-quick-filter.js

@@ -1,66 +0,0 @@
-/**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/**
- * Map a human-readable / spec operator to the ObjectStack AST operator.
- */
-function mapSpecOperator(op) {
-    switch (op) {
-        case 'equals':
-        case 'eq': return '=';
-        case 'notEquals':
-        case 'ne':
-        case 'neq': return '!=';
-        case 'contains': return 'contains';
-        case 'notContains': return 'notcontains';
-        case 'greaterThan':
-        case 'gt': return '>';
-        case 'greaterOrEqual':
-        case 'gte': return '>=';
-        case 'lessThan':
-        case 'lt': return '<';
-        case 'lessOrEqual':
-        case 'lte': return '<=';
-        case 'in': return 'in';
-        case 'notIn': return 'not in';
-        case 'before': return '<';
-        case 'after': return '>';
-        default: return op;
-    }
-}
-/**
- * Normalize a single QuickFilter item.
- * - If it's already in ObjectUI format (has id + label + filters), return as-is.
- * - If it's in Spec format (has field + operator), convert to ObjectUI format.
- */
-export function normalizeQuickFilter(item) {
-    // Already in ObjectUI format
-    if ('id' in item && 'filters' in item && item.label && Array.isArray(item.filters)) {
-        return item;
-    }
-    // Spec format: { field, operator, value }
-    if ('field' in item && 'operator' in item) {
-        const op = mapSpecOperator(item.operator);
-        return {
-            id: `${item.field}-${item.operator}-${String(item.value ?? '')}`,
-            label: item.label || `${item.field} ${item.operator} ${String(item.value ?? '')}`,
-            filters: [[item.field, op, item.value]],
-            icon: item.icon,
-            defaultActive: item.defaultActive,
-        };
-    }
-    // Unknown format — return as-is
-    return item;
-}
-/**
- * Normalize an array of QuickFilter items (mixed formats accepted).
- */
-export function normalizeQuickFilters(items) {
-    if (!items || items.length === 0)
-        return undefined;
-    return items.map(normalizeQuickFilter);
-}