@svgrid/enterprise 2.5.3 → 2.6.1

package/dist/smart-shim.d.ts

@@ -0,0 +1,62 @@
+type SmartGlobal = {
+    Utilities: {
+        Assign(name: string, cls: unknown): void;
+        Core: {
+            toDash(input: string): string;
+        };
+        DataExporter?: new (options: Record<string, unknown>, groupBy?: ReadonlyArray<string>, filterBy?: Record<string, unknown>, conditionalFormatting?: unknown) => SmartDataExporterInstance;
+        [key: string]: unknown;
+    };
+};
+/**
+ * Shape of the image object Smart's xlsx writer expects from
+ * `addImageToCell(...).image`. `base64` may be a full data URL; the
+ * exporter strips the prefix.
+ */
+export type SmartImageDescriptor = {
+    id: string;
+    base64: string;
+    imageType: string;
+    width: number;
+    height: number;
+};
+export type SmartDataExporterInstance = {
+    /**
+     * Smart looks for these on the INSTANCE (not the constructor opts) at
+     * exportData() time. The wrapper sets them after `new DataExporter(...)`.
+     */
+    headerContent?: Array<{
+        cells: Record<string, unknown>;
+        style?: Record<string, unknown>;
+    }>;
+    footerContent?: Array<{
+        cells: Record<string, unknown>;
+        style?: Record<string, unknown>;
+    }>;
+    addImageToCell?: (rowIndex: number, dataField: string, value: unknown, rawValue: unknown, row: Record<string, unknown>, arrIndex: number) => {
+        image: SmartImageDescriptor;
+        value?: unknown;
+    } | null;
+    spreadsheets?: ReadonlyArray<{
+        label: string;
+        dataSource: ReadonlyArray<Record<string, unknown>>;
+        /** `format` is an optional Smart/Excel number-format token consumed by
+         *  the xlsx writer's `getXLSXFormat` to keep a column's cells typed. */
+        columns: ReadonlyArray<{
+            dataField: string;
+            label: string;
+            format?: string;
+            width?: number;
+        }>;
+        dataFields: ReadonlyArray<string>;
+        style?: unknown;
+    }>;
+    exportData(data: ReadonlyArray<Record<string, unknown>>, format: string, filename?: string, callback?: (result: unknown) => void): unknown;
+};
+declare global {
+    interface Window {
+        Smart?: SmartGlobal;
+    }
+}
+export declare function installSmartShim(): void;
+export {};

package/dist/smart-shim.js

@@ -0,0 +1,34 @@
+// Minimal globalThis.Smart shim so the vendored smart.export.js IIFE can
+// register Smart.Utilities.DataExporter without dragging in the rest of the
+// Smart UI runtime. DataExporter calls into Smart.Utilities.{Assign, Core.toDash}
+// at registration; the other namespaces (DateTime, NumberRenderer, Draw,
+// BigNumber, Complex) are guarded by `if (!Smart.Utilities.X) return e;` paths
+// inside the exporter and degrade gracefully when missing.
+//
+// We export a function instead of relying on import-side-effects so callers
+// can deterministically install the shim before the smart.export.js module
+// runs its IIFE.
+let installed = false;
+export function installSmartShim() {
+    if (installed)
+        return;
+    if (typeof window === 'undefined') {
+        throw new Error('@svgrid/enterprise: installSmartShim() requires a browser environment');
+    }
+    const existing = window.Smart;
+    const shim = existing ?? ({ Utilities: {} });
+    shim.Utilities = shim.Utilities ?? {};
+    if (typeof shim.Utilities.Assign !== 'function') {
+        shim.Utilities.Assign = (name, cls) => {
+            ;
+            shim.Utilities[name] = cls;
+        };
+    }
+    if (!shim.Utilities.Core || typeof shim.Utilities.Core.toDash !== 'function') {
+        shim.Utilities.Core = {
+            toDash: (s) => s.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase()),
+        };
+    }
+    window.Smart = shim;
+    installed = true;
+}

package/dist/sources/aggregate.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Aggregation for charts / dashboards: group rows by a dimension and reduce a
+ * measure into `{ category, value }` buckets. `aggregateRows` does it in memory;
+ * data sources can implement `getAggregate` to push the same shape down to the
+ * database (a `GROUP BY`) so it scales past what a page can hold. `SvSchemaChart`
+ * consumes either.
+ */
+import type { RowData, ServerFilterModel } from '@svgrid/grid';
+import type { EntitySchema } from '../schema';
+export type AggregateReduce = 'sum' | 'avg' | 'count' | 'min' | 'max';
+export type AggregateRequest = {
+    /**
+     * Field to group by (the chart's category axis). Omit it for a single grand
+     * total (a KPI) - the result is one bucket with an empty `category`.
+     */
+    dimension?: string;
+    /** Field to reduce. Ignored for `count`. */
+    measure?: string;
+    reduce: AggregateReduce;
+    /** Optional filter, same shape the grid emits. */
+    filterModel?: ServerFilterModel;
+};
+export type AggregateBucket = {
+    category: string;
+    value: number;
+};
+/** A data source that can aggregate server-side (e.g. a SQL `GROUP BY`). */
+export type AggregateSource = {
+    getAggregate(request: AggregateRequest): Promise<AggregateBucket[]>;
+};
+/** Group `rows` by `dimension` and reduce `measure`; sorted by value desc. */
+export declare function aggregateRows<T extends RowData>(rows: ReadonlyArray<T>, request: AggregateRequest): AggregateBucket[];
+/**
+ * Pick chart-able fields from a schema: **dimensions** to group by (enum /
+ * boolean / text, non-key) and **measures** to reduce (number). Defaults favor a
+ * low-cardinality dimension (enum, then boolean) and the first numeric measure.
+ */
+export declare function chartFieldsFromSchema(schema: EntitySchema): {
+    dimensions: string[];
+    measures: string[];
+    defaultDimension: string | null;
+    defaultMeasure: string | null;
+};

package/dist/sources/aggregate.js

@@ -0,0 +1,60 @@
+const num = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : 0;
+};
+/** Group `rows` by `dimension` and reduce `measure`; sorted by value desc. */
+export function aggregateRows(rows, request) {
+    const { dimension, measure, reduce } = request;
+    const sum = new Map();
+    const count = new Map();
+    const ext = new Map(); // running min/max
+    for (const row of rows) {
+        // No dimension -> a single grand-total bucket (KPI).
+        const category = dimension ? String(row[dimension] ?? '') : '';
+        count.set(category, (count.get(category) ?? 0) + 1);
+        if (reduce !== 'count') {
+            const v = num(measure ? row[measure] : 0);
+            sum.set(category, (sum.get(category) ?? 0) + v);
+            if (reduce === 'min')
+                ext.set(category, Math.min(ext.get(category) ?? Infinity, v));
+            if (reduce === 'max')
+                ext.set(category, Math.max(ext.get(category) ?? -Infinity, v));
+        }
+    }
+    const buckets = [...count.keys()].map((category) => {
+        const c = count.get(category);
+        let value;
+        if (reduce === 'count')
+            value = c;
+        else if (reduce === 'avg')
+            value = c ? (sum.get(category) ?? 0) / c : 0;
+        else if (reduce === 'min' || reduce === 'max')
+            value = ext.get(category) ?? 0;
+        else
+            value = sum.get(category) ?? 0;
+        return { category, value };
+    });
+    return buckets.sort((a, b) => b.value - a.value);
+}
+/**
+ * Pick chart-able fields from a schema: **dimensions** to group by (enum /
+ * boolean / text, non-key) and **measures** to reduce (number). Defaults favor a
+ * low-cardinality dimension (enum, then boolean) and the first numeric measure.
+ */
+export function chartFieldsFromSchema(schema) {
+    const nonKey = schema.fields.filter((f) => !f.primaryKey);
+    const dimensions = nonKey
+        .filter((f) => f.type === 'enum' || f.type === 'boolean' || f.type === 'text')
+        .map((f) => f.field);
+    const measures = nonKey.filter((f) => f.type === 'number').map((f) => f.field);
+    const preferred = nonKey.find((f) => f.type === 'enum')?.field ??
+        nonKey.find((f) => f.type === 'boolean')?.field ??
+        dimensions[0] ??
+        null;
+    return {
+        dimensions,
+        measures,
+        defaultDimension: preferred,
+        defaultMeasure: measures[0] ?? null,
+    };
+}

package/dist/sources/auth-supabase.d.ts

@@ -0,0 +1,69 @@
+export type AuthUser = {
+    id: string;
+    email?: string;
+};
+export type AuthState = {
+    /** The signed-in user, or null. */
+    user: AuthUser | null;
+    /** True during the initial session check or an in-flight auth call. */
+    loading: boolean;
+    /** Last auth error message, or null. */
+    error: string | null;
+};
+type Session = {
+    user: {
+        id: string;
+        email?: string;
+    };
+} | null;
+/** The slice of a `supabase-js` client's `auth` this needs. */
+export type SupabaseAuthClientLike = {
+    auth: {
+        getSession(): Promise<{
+            data: {
+                session: Session;
+            };
+        }>;
+        onAuthStateChange(cb: (event: string, session: Session) => void): {
+            data: {
+                subscription: {
+                    unsubscribe(): void;
+                };
+            };
+        };
+        signInWithPassword(c: {
+            email: string;
+            password: string;
+        }): Promise<{
+            error: {
+                message: string;
+            } | null;
+        }>;
+        signUp(c: {
+            email: string;
+            password: string;
+        }): Promise<{
+            error: {
+                message: string;
+            } | null;
+        }>;
+        signOut(): Promise<{
+            error: {
+                message: string;
+            } | null;
+        }>;
+    };
+};
+export type SupabaseAuthConfig = {
+    client: SupabaseAuthClientLike;
+    onChange: (state: AuthState) => void;
+};
+export type SupabaseAuthController = {
+    signIn(email: string, password: string): Promise<void>;
+    signUp(email: string, password: string): Promise<void>;
+    signOut(): Promise<void>;
+    getState(): AuthState;
+    dispose(): void;
+};
+export declare function createSupabaseAuth(config: SupabaseAuthConfig): SupabaseAuthController;
+export {};

package/dist/sources/auth-supabase.js

@@ -0,0 +1,39 @@
+/**
+ * createSupabaseAuth - a tiny reactive controller over Supabase Auth, so a
+ * Studio screen can require a signed-in user. You bring the `supabase-js` client
+ * (BYO, no dependency); this tracks the session and exposes sign in / up / out.
+ * Pair it with `SvAuthGate` to gate the UI, and with Row-Level Security to scope
+ * data per user - auth establishes *who*, RLS enforces *what they can see*.
+ *
+ *     const auth = createSupabaseAuth({ client, onChange: (s) => (authState = s) })
+ *     await auth.signIn(email, password)
+ *     // ... auth.signOut(); auth.dispose() on unmount
+ */
+import { nudgeEnterprise } from '../license';
+const userOf = (session) => session?.user ? { id: session.user.id, email: session.user.email } : null;
+export function createSupabaseAuth(config) {
+    nudgeEnterprise('Studio'); // soft-gate; never blocks
+    let state = { user: null, loading: true, error: null };
+    const emit = () => config.onChange({ ...state });
+    const set = (patch) => {
+        state = { ...state, ...patch };
+        emit();
+    };
+    emit(); // initial loading state
+    // Resolve the current session, then keep it in sync.
+    config.client.auth.getSession().then(({ data }) => set({ user: userOf(data.session), loading: false }));
+    const sub = config.client.auth.onAuthStateChange((_event, session) => set({ user: userOf(session), loading: false }));
+    const run = async (op) => {
+        set({ loading: true, error: null });
+        const { error } = await op();
+        // On success the user arrives via onAuthStateChange; just clear loading.
+        set(error ? { loading: false, error: error.message } : { loading: false });
+    };
+    return {
+        signIn: (email, password) => run(() => config.client.auth.signInWithPassword({ email, password })),
+        signUp: (email, password) => run(() => config.client.auth.signUp({ email, password })),
+        signOut: () => run(() => config.client.auth.signOut()),
+        getState: () => ({ ...state }),
+        dispose: () => sub.data.subscription.unsubscribe(),
+    };
+}

package/dist/sources/dashboard.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Dashboard model - a declarative, schema-driven set of widgets (KPI tiles +
+ * charts) over an entity. This is a *data view*, not a page builder: the spec is
+ * plain data, `SvSchemaDashboard` renders it, and `dashboardFromSchema` proposes
+ * a sensible default from the schema's chart-able fields. KPI tiles reduce a
+ * measure to a single number; charts reuse `SvSchemaChart` (and its `aggregateRows`
+ * / `getAggregate` seam), so nothing here re-implements aggregation.
+ */
+import type { RowData } from '@svgrid/grid';
+import type { EntitySchema } from '../schema';
+import { type AggregateReduce } from './aggregate';
+import type { ChartType } from '@svgrid/grid';
+/** A single-number tile: reduce `measure` over the rows (count ignores measure). */
+export type KpiWidget = {
+    kind: 'kpi';
+    label: string;
+    measure?: string;
+    reduce: AggregateReduce;
+    /** Format the number for display (e.g. currency). */
+    format?: (value: number) => string;
+};
+/** A chart tile bound to a fixed dimension / measure / reduce / type. */
+export type ChartWidget = {
+    kind: 'chart';
+    label?: string;
+    dimension: string;
+    measure?: string;
+    reduce: AggregateReduce;
+    type: ChartType;
+    /** Columns spanned in the dashboard grid. Default 1. */
+    span?: 1 | 2 | 3;
+};
+export type DashboardWidget = KpiWidget | ChartWidget;
+export type DashboardSpec = {
+    widgets: DashboardWidget[];
+};
+/**
+ * Reduce a measure over rows into a single KPI number. `count` returns the row
+ * count; `sum`/`avg`/`min`/`max` fold the measure. An empty set is 0.
+ */
+export declare function reduceValue<T extends RowData>(rows: ReadonlyArray<T>, request: {
+    measure?: string;
+    reduce: AggregateReduce;
+}): number;
+/**
+ * Group rows by `trendField` (sorted, so ISO dates / ordered categories line up)
+ * and reduce `measure` per bucket - the series behind a KPI card's sparkline.
+ */
+export declare function kpiSeries<T extends RowData>(rows: ReadonlyArray<T>, opts: {
+    trendField: string;
+    measure?: string;
+    reduce: AggregateReduce;
+}): number[];
+/** SVG polyline points for a sparkline in a `w` x `h` box (y grows downward). */
+export declare function sparklinePoints(values: number[], w?: number, h?: number, pad?: number): string;
+/** Percent change from the first non-zero point to the last (null when < 2 points). */
+export declare function seriesDelta(values: number[]): number | null;
+/** Format a KPI number: currency (`$`), percent (`%`), compact (`1.2k`), or grouped. */
+export declare function formatKpiValue(value: number, format?: 'number' | 'currency' | 'percent' | 'compact'): string;
+/**
+ * Propose a default dashboard from a schema: a total-count KPI, a sum/avg KPI on
+ * the first numeric measure (when there is one), and a bar chart on the default
+ * dimension / measure. Built from `chartFieldsFromSchema`.
+ */
+export declare function dashboardFromSchema(schema: EntitySchema): DashboardSpec;

package/dist/sources/dashboard.js

@@ -0,0 +1,95 @@
+import { chartFieldsFromSchema } from './aggregate';
+const num = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : 0;
+};
+/**
+ * Reduce a measure over rows into a single KPI number. `count` returns the row
+ * count; `sum`/`avg`/`min`/`max` fold the measure. An empty set is 0.
+ */
+export function reduceValue(rows, request) {
+    const { measure, reduce } = request;
+    if (reduce === 'count' || !measure)
+        return rows.length;
+    if (rows.length === 0)
+        return 0;
+    const values = rows.map((r) => num(r[measure]));
+    if (reduce === 'sum')
+        return values.reduce((a, b) => a + b, 0);
+    if (reduce === 'avg')
+        return values.reduce((a, b) => a + b, 0) / values.length;
+    if (reduce === 'min')
+        return Math.min(...values);
+    return Math.max(...values); // 'max'
+}
+/**
+ * Group rows by `trendField` (sorted, so ISO dates / ordered categories line up)
+ * and reduce `measure` per bucket - the series behind a KPI card's sparkline.
+ */
+export function kpiSeries(rows, opts) {
+    const groups = new Map();
+    for (const r of rows) {
+        const k = String(r[opts.trendField] ?? '');
+        if (k === '')
+            continue;
+        (groups.get(k) ?? groups.set(k, []).get(k)).push(r);
+    }
+    return [...groups.keys()].sort().map((k) => reduceValue(groups.get(k), { measure: opts.measure, reduce: opts.reduce }));
+}
+/** SVG polyline points for a sparkline in a `w` x `h` box (y grows downward). */
+export function sparklinePoints(values, w = 120, h = 30, pad = 2) {
+    if (values.length === 0)
+        return '';
+    const min = Math.min(...values);
+    const range = Math.max(...values) - min || 1;
+    const dx = values.length > 1 ? (w - pad * 2) / (values.length - 1) : 0;
+    return values
+        .map((v, i) => `${(pad + i * dx).toFixed(1)},${(pad + (h - pad * 2) * (1 - (v - min) / range)).toFixed(1)}`)
+        .join(' ');
+}
+/** Percent change from the first non-zero point to the last (null when < 2 points). */
+export function seriesDelta(values) {
+    if (values.length < 2)
+        return null;
+    const first = values.find((v) => v !== 0);
+    const last = values[values.length - 1];
+    if (first == null || first === 0)
+        return null;
+    return ((last - first) / Math.abs(first)) * 100;
+}
+/** Format a KPI number: currency (`$`), percent (`%`), compact (`1.2k`), or grouped. */
+export function formatKpiValue(value, format) {
+    if (format === 'currency')
+        return '$' + value.toLocaleString(undefined, { maximumFractionDigits: 0 });
+    if (format === 'percent')
+        return value.toLocaleString(undefined, { maximumFractionDigits: 1 }) + '%';
+    if (format === 'compact')
+        return new Intl.NumberFormat(undefined, { notation: 'compact', maximumFractionDigits: 1 }).format(value);
+    return value.toLocaleString(undefined, { maximumFractionDigits: 1 });
+}
+/**
+ * Propose a default dashboard from a schema: a total-count KPI, a sum/avg KPI on
+ * the first numeric measure (when there is one), and a bar chart on the default
+ * dimension / measure. Built from `chartFieldsFromSchema`.
+ */
+export function dashboardFromSchema(schema) {
+    const { defaultDimension, defaultMeasure } = chartFieldsFromSchema(schema);
+    const label = schema.label ?? schema.name;
+    const widgets = [{ kind: 'kpi', label: `Total ${label}`, reduce: 'count' }];
+    if (defaultMeasure) {
+        widgets.push({ kind: 'kpi', label: `Total ${defaultMeasure}`, measure: defaultMeasure, reduce: 'sum' });
+        widgets.push({ kind: 'kpi', label: `Avg ${defaultMeasure}`, measure: defaultMeasure, reduce: 'avg' });
+    }
+    if (defaultDimension) {
+        widgets.push({
+            kind: 'chart',
+            label: defaultMeasure ? `${defaultMeasure} by ${defaultDimension}` : `Count by ${defaultDimension}`,
+            dimension: defaultDimension,
+            measure: defaultMeasure ?? undefined,
+            reduce: defaultMeasure ? 'sum' : 'count',
+            type: 'bar',
+            span: 2,
+        });
+    }
+    return { widgets };
+}

package/dist/sources/field-inference.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Infer a richer form editor for an introspected field from its name + type, so
+ * a database connected through Studio produces the same rich forms as the curated
+ * sample apps (a `phone` column becomes a phone input, `rating` a star rating,
+ * `email` an email field, `ssn` a masked input) instead of a wall of text boxes.
+ *
+ * DELIBERATELY CONSERVATIVE: it only refines on a clear name match, never touches
+ * a primary key / relation / enum field, and never adds range validation that
+ * could reject rows already in the user's database. Pure + node-safe. Applied by
+ * the shared `buildEntitySchema` (Drizzle / Prisma / PostgREST / sample row) and
+ * by the SQL-catalog path (`introspectDatabase`).
+ */
+import type { RowData } from '@svgrid/grid';
+import type { EntityField } from '../schema.js';
+/**
+ * Return a copy of `field` with an inferred `format` / `input.editorType` when the
+ * name (and type) clearly imply one; otherwise return it unchanged.
+ */
+export declare function refineField<T extends RowData = RowData>(field: EntityField<T>): EntityField<T>;
+/** Refine every field of a schema's field list (leaves keys/relations/enums alone). */
+export declare function refineFields<T extends {
+    fields: EntityField[];
+}>(schema: T): T;

package/dist/sources/field-inference.js

@@ -0,0 +1,52 @@
+/** Masked-code patterns keyed by a field-name test. `#`=digit, `A`=letter, `*`=alnum. */
+const MASKS = [
+    [/(^|_)ssn$|social.?security/, '###-##-####'],
+    [/(^|_)vin$/, '*****************'],
+    [/plate|registration/, 'AAA-####'],
+    [/isbn/, '###-#-#####-###-#'],
+    [/zip|postal/, '#####'],
+    [/(^|_)ein$|tax.?id|vat/, '##-#######'],
+];
+/**
+ * Return a copy of `field` with an inferred `format` / `input.editorType` when the
+ * name (and type) clearly imply one; otherwise return it unchanged.
+ */
+export function refineField(field) {
+    // Never override an explicit editor, a key, a relation, or an enum.
+    if (field.primaryKey || field.readonly || field.type === 'relation' || field.options?.length || field.input?.editorType) {
+        return field;
+    }
+    const name = String(field.field).toLowerCase();
+    const withEditor = (editorType, extra = {}) => ({ ...field, input: { ...(field.input ?? {}), editorType, ...extra } });
+    if (field.type === 'text') {
+        if (field.format == null) {
+            if (/e-?mail/.test(name))
+                return { ...field, format: 'email' };
+            if (/url|website|link|homepage|domain/.test(name))
+                return { ...field, format: 'url' };
+        }
+        if (/phone|mobile|(^|_)fax$|(^|_)tel(ephone)?$/.test(name))
+            return withEditor('phone');
+        if (/(^|_)country$|nationality/.test(name))
+            return withEditor('country');
+        if (/password|passwd|(^|_)pwd$/.test(name))
+            return { ...withEditor('password'), hidden: { grid: true } };
+        if (/colou?r$/.test(name))
+            return withEditor('color');
+        for (const [re, mask] of MASKS)
+            if (re.test(name))
+                return withEditor('mask', { mask });
+    }
+    if (field.type === 'number') {
+        // Star rating (panel defaults max 5) or a 0-100 slider (panel defaults max 100).
+        if (/(^|_)(rating|score|stars|satisfaction|csat)$/.test(name))
+            return withEditor('rating');
+        if (/percent|progress|probability|completion|utili[sz]ation|occupancy|fuel.?level/.test(name))
+            return withEditor('slider');
+    }
+    return field;
+}
+/** Refine every field of a schema's field list (leaves keys/relations/enums alone). */
+export function refineFields(schema) {
+    return { ...schema, fields: schema.fields.map(refineField) };
+}

package/dist/sources/filters.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared filter normalization for data-source adapters. The grid emits a
+ * `ServerFilterModel` (per-column `{ operator, value, valueTo, selectedValues }`
+ * plus a global search string); every backend then has to translate that into
+ * its own query language. This turns the grid's model into one small, uniform
+ * list of predicates so each adapter (Supabase, REST, ...) maps a handful of
+ * clear cases instead of re-parsing the raw model.
+ */
+import type { ServerFilterModel } from '@svgrid/grid';
+/** A backend-neutral predicate over a single column. */
+export type NormalizedPredicate = {
+    column: string;
+    op: 'in';
+    values: string[];
+} | {
+    column: string;
+    op: 'isNull';
+} | {
+    column: string;
+    op: 'contains' | 'startsWith' | 'eq' | 'gt' | 'lt';
+    value: string;
+} | {
+    column: string;
+    op: 'between';
+    value: string;
+    valueTo: string;
+};
+export type NormalizedFilter = {
+    /** Column predicates, empty ones dropped. */
+    predicates: NormalizedPredicate[];
+    /** Free-text global search term (trimmed), if any. */
+    search?: string;
+};
+/** Map the grid's per-column filter model into neutral predicates. */
+export declare function normalizeFilters(model: ServerFilterModel | undefined): NormalizedFilter;

package/dist/sources/filters.js

@@ -0,0 +1,52 @@
+/** Map the grid's per-column filter model into neutral predicates. */
+export function normalizeFilters(model) {
+    const predicates = [];
+    for (const [column, f] of Object.entries(model?.columns ?? {})) {
+        // Set / checklist filter takes precedence when present.
+        if (f.selectedValues?.length) {
+            predicates.push({ column, op: 'in', values: f.selectedValues });
+            continue;
+        }
+        const value = (f.value ?? '').trim();
+        switch (f.operator) {
+            case 'isBlank':
+                predicates.push({ column, op: 'isNull' });
+                break;
+            case 'between': {
+                const valueTo = (f.valueTo ?? '').trim();
+                if (value || valueTo)
+                    predicates.push({ column, op: 'between', value, valueTo: valueTo || value });
+                break;
+            }
+            case 'startsWith':
+                if (value)
+                    predicates.push({ column, op: 'startsWith', value });
+                break;
+            case 'equals':
+                if (value)
+                    predicates.push({ column, op: 'eq', value });
+                break;
+            case 'greaterThan':
+                if (value)
+                    predicates.push({ column, op: 'gt', value });
+                break;
+            case 'lessThan':
+                if (value)
+                    predicates.push({ column, op: 'lt', value });
+                break;
+            // The grid's client-side filter row supports a wider operator set
+            // (notContains, notEquals, endsWith, regex, in, notIn, isNotBlank).
+            // Server data sources don't translate those yet - they fall through to
+            // `contains` below so a backend query stays valid and predictable
+            // rather than silently dropping the predicate. Widen this switch when
+            // per-backend support for the extra operators lands.
+            case 'contains':
+            default:
+                if (value)
+                    predicates.push({ column, op: 'contains', value });
+                break;
+        }
+    }
+    const search = model?.global?.trim();
+    return { predicates, search: search ? search : undefined };
+}

package/dist/sources/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Data-source adapters + introspection. Each adapter implements the grid's
+ * `ServerDataSource` over a specific backend, so the grid, edit form, sorting,
+ * filtering, and paging work identically regardless of where the data lives.
+ */
+export { normalizeFilters, type NormalizedFilter, type NormalizedPredicate } from './filters';
+export { buildEntitySchema, pickLabelField, linkRelationLabels, type IntrospectedColumn, type ColumnReference, } from './schema-from-columns';
+export { createSupabaseDataSource, type SupabaseDataSourceConfig, type SupabaseClientLike } from './supabase';
+export { createRestDataSource, type RestDataSourceConfig } from './rest';
+export { offsetLimitAdapter, dummyJsonAdapter, jsonServerAdapter, type RestAdapter, type OffsetLimitOptions, } from './rest-adapters';
+export { introspectSupabaseTable, listSupabaseTables, type IntrospectSupabaseOptions } from './introspect-supabase';
+export { createSupabaseRealtime, type SupabaseRealtimeConfig, type SupabaseRealtimeClientLike, type SupabaseRealtimeHandle, type RealtimeChannelLike, type RealtimeChange, } from './realtime-supabase';
+export { createRelationLookup, type RelationLookup, type RelationLookupConfig, type RelationOption, } from './relation-lookup';
+export { createSupabaseAuth, type SupabaseAuthConfig, type SupabaseAuthController, type SupabaseAuthClientLike, type AuthState, type AuthUser, } from './auth-supabase';
+export { aggregateRows, chartFieldsFromSchema, type AggregateReduce, type AggregateRequest, type AggregateBucket, type AggregateSource, } from './aggregate';
+export { withEntityRules } from './with-entity-rules';
+export { withRelationLabels, type RelationLabelConfig } from './with-relation-labels';
+export { reduceValue, kpiSeries, sparklinePoints, seriesDelta, formatKpiValue, dashboardFromSchema, type DashboardSpec, type DashboardWidget, type KpiWidget, type ChartWidget, } from './dashboard';