@object-ui/core 3.0.3 → 3.1.0

package/dist/adapters/ValueDataSource.js

@@ -17,6 +17,64 @@ function getRecordId(record, idField) {
         return record[idField];
     return record._id ?? record.id;
 }
+/**
+ * Evaluate an AST-format filter node against a record.
+ * Supports conditions like ['field', 'op', value] and logical
+ * combinations like ['and', ...conditions] or ['or', ...conditions].
+ */
+function matchesASTFilter(record, filterNode) {
+    if (!filterNode || filterNode.length === 0)
+        return true;
+    const head = filterNode[0];
+    // Logical operators: ['and', ...conditions] or ['or', ...conditions]
+    if (head === 'and') {
+        return filterNode.slice(1).every((sub) => matchesASTFilter(record, sub));
+    }
+    if (head === 'or') {
+        return filterNode.slice(1).some((sub) => matchesASTFilter(record, sub));
+    }
+    // Condition node: [field, operator, value]
+    if (filterNode.length === 3 && typeof head === 'string') {
+        const [field, operator, target] = filterNode;
+        const value = record[field];
+        switch (operator) {
+            case '=':
+                return value === target;
+            case '!=':
+                return value !== target;
+            case '>':
+                return value > target;
+            case '>=':
+                return value >= target;
+            case '<':
+                return value < target;
+            case '<=':
+                return value <= target;
+            case 'in':
+                return Array.isArray(target) && target.includes(value);
+            case 'not in':
+            case 'notin': // alias used by convertFiltersToAST
+                return Array.isArray(target) && !target.includes(value);
+            case 'contains': {
+                const lv = typeof value === 'string' ? value.toLowerCase() : '';
+                return typeof value === 'string' && lv.includes(String(target).toLowerCase());
+            }
+            case 'notcontains': {
+                const lv = typeof value === 'string' ? value.toLowerCase() : '';
+                return typeof value === 'string' && !lv.includes(String(target).toLowerCase());
+            }
+            case 'startswith': {
+                const lv = typeof value === 'string' ? value.toLowerCase() : '';
+                return typeof value === 'string' && lv.startsWith(String(target).toLowerCase());
+            }
+            case 'between':
+                return Array.isArray(target) && target.length === 2 && value >= target[0] && value <= target[1];
+            default:
+                return true;
+        }
+    }
+    return true;
+}
 /**
  * Simple in-memory filter evaluation.
  * Supports flat key-value equality and basic operators ($gt, $gte, $lt, $lte, $ne, $in).
@@ -168,9 +226,14 @@ export class ValueDataSource {
     // -----------------------------------------------------------------------
     async find(_resource, params) {
         let result = [...this.items];
-        // Filter
-        if (params?.$filter && Object.keys(params.$filter).length > 0) {
-            result = result.filter((r) => matchesFilter(r, params.$filter));
+        // Filter — support both MongoDB-style objects and AST-format arrays
+        if (params?.$filter) {
+            if (Array.isArray(params.$filter) && params.$filter.length > 0) {
+                result = result.filter((r) => matchesASTFilter(r, params.$filter));
+            }
+            else if (!Array.isArray(params.$filter) && Object.keys(params.$filter).length > 0) {
+                result = result.filter((r) => matchesFilter(r, params.$filter));
+            }
         }
         // Search (simple text search across all string fields)
         if (params?.$search) {
@@ -273,6 +336,39 @@ export class ValueDataSource {
     async getApp(_appId) {
         return null;
     }
+    async aggregate(_resource, params) {
+        const { field, function: aggFn, groupBy } = params;
+        const groups = {};
+        for (const record of this.items) {
+            const key = String(record[groupBy] ?? 'Unknown');
+            if (!groups[key])
+                groups[key] = [];
+            groups[key].push(record);
+        }
+        return Object.entries(groups).map(([key, group]) => {
+            const values = group.map(r => Number(r[field]) || 0);
+            let result;
+            switch (aggFn) {
+                case 'count':
+                    result = group.length;
+                    break;
+                case 'avg':
+                    result = values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+                    break;
+                case 'min':
+                    result = values.length > 0 ? Math.min(...values) : 0;
+                    break;
+                case 'max':
+                    result = values.length > 0 ? Math.max(...values) : 0;
+                    break;
+                case 'sum':
+                default:
+                    result = values.reduce((a, b) => a + b, 0);
+                    break;
+            }
+            return { [groupBy]: key, [field]: result };
+        });
+    }
     // -----------------------------------------------------------------------
     // Extra utilities
     // -----------------------------------------------------------------------

package/dist/data-scope/ViewDataProvider.d.ts

@@ -0,0 +1,143 @@
+/**
+ * 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.
+ */
+/**
+ * @object-ui/core - View Data Provider
+ *
+ * Resolves @objectstack/spec ViewData discriminated union into
+ * a unified data access interface. Supports three data modes:
+ *
+ * 1. 'object' — Metadata-driven via ObjectStack API (object name → fields/records)
+ * 2. 'api' — Custom REST API endpoints (read/write URLs)
+ * 3. 'value' — Static data (pre-loaded items array)
+ *
+ * @module data-scope
+ * @packageDocumentation
+ */
+/** ViewData union — matches @objectstack/spec ViewDataSchema */
+export type ViewDataConfig = {
+    provider: 'object';
+    object: string;
+} | {
+    provider: 'api';
+    read: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+    };
+    write?: {
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+    };
+} | {
+    provider: 'value';
+    items: any[];
+};
+/** Element-level data source — matches @objectstack/spec ElementDataSourceSchema */
+export interface ElementDataSourceConfig {
+    object: string;
+    view?: string;
+    filter?: Record<string, any>;
+    sort?: Array<{
+        field: string;
+        order: 'asc' | 'desc';
+    }>;
+    limit?: number;
+}
+/** Fetcher interface — consumers provide the actual fetch implementation */
+export interface DataFetcher {
+    /** Fetch records for an object */
+    fetchRecords(object: string, options?: {
+        filter?: Record<string, any>;
+        sort?: Array<{
+            field: string;
+            order: 'asc' | 'desc';
+        }>;
+        limit?: number;
+        offset?: number;
+        fields?: string[];
+    }): Promise<{
+        records: any[];
+        total: number;
+    }>;
+    /** Fetch object metadata (fields, etc.) */
+    fetchMetadata?(object: string): Promise<{
+        name: string;
+        label?: string;
+        fields: Array<{
+            name: string;
+            label?: string;
+            type: string;
+            required?: boolean;
+        }>;
+    }>;
+    /** Fetch from a custom API URL */
+    fetchUrl?(url: string, options?: {
+        method?: string;
+        headers?: Record<string, string>;
+        body?: any;
+    }): Promise<any>;
+}
+/** Resolved data result */
+export interface ResolvedData {
+    /** Data records */
+    records: any[];
+    /** Total record count (for pagination) */
+    total: number;
+    /** Object metadata (if available) */
+    metadata?: {
+        name: string;
+        label?: string;
+        fields: Array<{
+            name: string;
+            label?: string;
+            type: string;
+            required?: boolean;
+        }>;
+    };
+    /** Provider type */
+    provider: 'object' | 'api' | 'value';
+    /** Loading state */
+    loading: boolean;
+    /** Error */
+    error?: string;
+}
+/**
+ * Resolves ViewData configuration into actual data via a pluggable fetcher.
+ *
+ * @example
+ * ```ts
+ * const provider = new ViewDataProvider(myFetcher);
+ * const data = await provider.resolve({ provider: 'object', object: 'Account' });
+ * ```
+ */
+export declare class ViewDataProvider {
+    private fetcher;
+    constructor(fetcher?: DataFetcher);
+    /** Set the data fetcher implementation */
+    setFetcher(fetcher: DataFetcher): void;
+    /** Resolve ViewData config into actual data */
+    resolve(config: ViewDataConfig, options?: {
+        filter?: Record<string, any>;
+        sort?: Array<{
+            field: string;
+            order: 'asc' | 'desc';
+        }>;
+        limit?: number;
+        offset?: number;
+        fields?: string[];
+    }): Promise<ResolvedData>;
+    /** Resolve static value data */
+    private resolveValue;
+    /** Resolve API-based data */
+    private resolveApi;
+    /** Resolve object-based data (metadata-driven) */
+    private resolveObject;
+    /** Resolve element-level data source */
+    resolveElementDataSource(config: ElementDataSourceConfig): Promise<ResolvedData>;
+}

package/dist/data-scope/ViewDataProvider.js

@@ -0,0 +1,153 @@
+/**
+ * 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.
+ */
+/** Extract records array from various common API response shapes */
+function extractRecords(data) {
+    if (Array.isArray(data))
+        return data;
+    if (Array.isArray(data?.records))
+        return data.records;
+    if (Array.isArray(data?.data))
+        return data.data;
+    if (Array.isArray(data?.items))
+        return data.items;
+    return [];
+}
+/**
+ * Resolves ViewData configuration into actual data via a pluggable fetcher.
+ *
+ * @example
+ * ```ts
+ * const provider = new ViewDataProvider(myFetcher);
+ * const data = await provider.resolve({ provider: 'object', object: 'Account' });
+ * ```
+ */
+export class ViewDataProvider {
+    constructor(fetcher) {
+        Object.defineProperty(this, "fetcher", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.fetcher = fetcher ?? null;
+    }
+    /** Set the data fetcher implementation */
+    setFetcher(fetcher) {
+        this.fetcher = fetcher;
+    }
+    /** Resolve ViewData config into actual data */
+    async resolve(config, options) {
+        switch (config.provider) {
+            case 'value':
+                return this.resolveValue(config);
+            case 'api':
+                return this.resolveApi(config);
+            case 'object':
+                return this.resolveObject(config, options);
+            default:
+                return {
+                    records: [],
+                    total: 0,
+                    provider: 'value',
+                    loading: false,
+                    error: `Unknown data provider: ${config.provider}`,
+                };
+        }
+    }
+    /** Resolve static value data */
+    resolveValue(config) {
+        const items = Array.isArray(config.items) ? config.items : [];
+        return {
+            records: items,
+            total: items.length,
+            provider: 'value',
+            loading: false,
+        };
+    }
+    /** Resolve API-based data */
+    async resolveApi(config) {
+        if (!this.fetcher?.fetchUrl) {
+            return {
+                records: [],
+                total: 0,
+                provider: 'api',
+                loading: false,
+                error: 'No fetchUrl implementation available for API data provider',
+            };
+        }
+        try {
+            const data = await this.fetcher.fetchUrl(config.read.url, {
+                method: config.read.method,
+                headers: config.read.headers,
+            });
+            // Handle common response shapes
+            const records = extractRecords(data);
+            const total = data?.total ?? data?.count ?? records.length;
+            return {
+                records,
+                total,
+                provider: 'api',
+                loading: false,
+            };
+        }
+        catch (error) {
+            return {
+                records: [],
+                total: 0,
+                provider: 'api',
+                loading: false,
+                error: error.message,
+            };
+        }
+    }
+    /** Resolve object-based data (metadata-driven) */
+    async resolveObject(config, options) {
+        if (!this.fetcher) {
+            return {
+                records: [],
+                total: 0,
+                provider: 'object',
+                loading: false,
+                error: 'No data fetcher configured for object data provider',
+            };
+        }
+        try {
+            // Fetch metadata if available
+            let metadata;
+            if (this.fetcher.fetchMetadata) {
+                metadata = await this.fetcher.fetchMetadata(config.object);
+            }
+            // Fetch records
+            const result = await this.fetcher.fetchRecords(config.object, options);
+            return {
+                records: result.records,
+                total: result.total,
+                metadata,
+                provider: 'object',
+                loading: false,
+            };
+        }
+        catch (error) {
+            return {
+                records: [],
+                total: 0,
+                provider: 'object',
+                loading: false,
+                error: error.message,
+            };
+        }
+    }
+    /** Resolve element-level data source */
+    async resolveElementDataSource(config) {
+        return this.resolve({ provider: 'object', object: config.object }, {
+            filter: config.filter,
+            sort: config.sort,
+            limit: config.limit,
+        });
+    }
+}

package/dist/data-scope/index.d.ts

@@ -8,3 +8,4 @@
  * @packageDocumentation
  */
 export { DataScopeManager, defaultDataScopeManager, type RowLevelFilter, type DataScopeConfig, } from './DataScopeManager.js';
+export { ViewDataProvider, type ViewDataConfig, type ElementDataSourceConfig, type DataFetcher, type ResolvedData, } from './ViewDataProvider.js';

package/dist/data-scope/index.js

@@ -8,3 +8,4 @@
  * @packageDocumentation
  */
 export { DataScopeManager, defaultDataScopeManager, } from './DataScopeManager.js';
+export { ViewDataProvider, } from './ViewDataProvider.js';

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -125,3 +125,10 @@ export declare function evaluateExpression(expression: string | boolean | number
  * Convenience function to evaluate a condition
  */
 export declare function evaluateCondition(condition: string | boolean | undefined, context?: Record<string, any>): boolean;
+/**
+ * Convenience function to evaluate a plain condition string against a data record.
+ * Supports both template expressions (e.g., '${data.amount > 1000}') and
+ * plain expressions (e.g., "status == 'overdue'").
+ * Record fields are available both directly (status) and namespaced (data.status).
+ */
+export declare function evaluatePlainCondition(condition: string, record: Record<string, any>): boolean;

package/dist/evaluator/ExpressionEvaluator.js

@@ -242,3 +242,22 @@ export function evaluateCondition(condition, context = {}) {
     const evaluator = new ExpressionEvaluator(context, globalCache, globalFormulas);
     return evaluator.evaluateCondition(condition);
 }
+/**
+ * Convenience function to evaluate a plain condition string against a data record.
+ * Supports both template expressions (e.g., '${data.amount > 1000}') and
+ * plain expressions (e.g., "status == 'overdue'").
+ * Record fields are available both directly (status) and namespaced (data.status).
+ */
+export function evaluatePlainCondition(condition, record) {
+    const evaluator = new ExpressionEvaluator({ ...record, data: record }, globalCache, globalFormulas);
+    try {
+        const isTemplate = /\$\{/.test(condition);
+        const result = isTemplate
+            ? evaluator.evaluate(condition, { throwOnError: true })
+            : evaluator.evaluateExpression(condition);
+        return result === true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -13,6 +13,9 @@ export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
 export * from './utils/filter-converter.js';
+export * from './utils/normalize-quick-filter.js';
+export * from './utils/extract-records.js';
+export * from './utils/expand-fields.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -21,3 +24,5 @@ export * from './theme/index.js';
 export * from './data-scope/index.js';
 export * from './errors/index.js';
 export * from './utils/debug.js';
+export * from './utils/debug-collector.js';
+export * from './protocols/index.js';

package/dist/index.js

@@ -12,6 +12,9 @@ export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
 export * from './utils/filter-converter.js';
+export * from './utils/normalize-quick-filter.js';
+export * from './utils/extract-records.js';
+export * from './utils/expand-fields.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -20,3 +23,5 @@ export * from './theme/index.js';
 export * from './data-scope/index.js';
 export * from './errors/index.js';
 export * from './utils/debug.js';
+export * from './utils/debug-collector.js';
+export * from './protocols/index.js';

package/dist/protocols/DndProtocol.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ */
+/**
+ * @object-ui/core - DnD Protocol Bridge
+ *
+ * Converts spec-aligned DnD configuration schemas into runtime-usable
+ * component props and CSS constraint styles for drag-and-drop interactions.
+ *
+ * @module protocols/DndProtocol
+ * @packageDocumentation
+ */
+import type { DndConfig, DragItem, DropZone, DragConstraint } from '@object-ui/types';
+/** Fully resolved DnD configuration with all defaults applied. */
+export interface ResolvedDndConfig {
+    enabled: boolean;
+    sortable: boolean;
+    autoScroll: boolean;
+    touchDelay: number;
+    dragItem?: DragItem;
+    dropZone?: DropZone;
+}
+/** Component props for a draggable element. */
+export interface DragItemProps {
+    draggable: boolean;
+    'aria-roledescription': string;
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+    role: string;
+    'data-drag-type': string;
+    'data-drag-handle': string;
+    'data-drag-disabled': string;
+}
+/** Component props for a droppable area. */
+export interface DropZoneProps {
+    'aria-dropeffect': string;
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+    role: string;
+    'data-drop-accept': string;
+    'data-drop-max-items'?: number;
+    'data-drop-highlight': string;
+}
+/** CSS constraint styles for drag movement. */
+export interface DragConstraintStyles {
+    position: string;
+    touchAction: string;
+    [key: string]: string | number | undefined;
+}
+/**
+ * Resolve a DnD configuration by applying spec defaults to missing fields.
+ *
+ * @param config - Partial DnD configuration from the spec
+ * @returns Fully resolved DnD configuration
+ */
+export declare function resolveDndConfig(config: DndConfig): ResolvedDndConfig;
+/**
+ * Convert a spec DragItem to component props suitable for a draggable element.
+ * Produces `draggable`, ARIA attributes, and data attributes for DnD libraries.
+ *
+ * @param item - DragItem configuration from the spec
+ * @returns Component props object for a draggable element
+ */
+export declare function createDragItemProps(item: DragItem): DragItemProps;
+/**
+ * Convert a spec DropZone to component props suitable for a droppable area.
+ * Produces ARIA attributes and data attributes for DnD libraries.
+ *
+ * @param zone - DropZone configuration from the spec
+ * @returns Component props object for a droppable area
+ */
+export declare function createDropZoneProps(zone: DropZone): DropZoneProps;
+/**
+ * Resolve a DragConstraint into CSS style properties that restrict
+ * drag movement along an axis or within bounds.
+ *
+ * @param constraint - DragConstraint configuration from the spec
+ * @returns CSS styles object for constraining drag movement
+ */
+export declare function resolveDragConstraints(constraint: DragConstraint): DragConstraintStyles;