@object-ui/core 0.5.0 → 2.0.0

package/dist/adapters/resolveDataSource.js

@@ -0,0 +1,59 @@
+/**
+ * ObjectUI — resolveDataSource
+ * 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.
+ *
+ * Factory function to create the right DataSource from a ViewData config.
+ */
+import { ApiDataSource } from './ApiDataSource.js';
+import { ValueDataSource } from './ValueDataSource.js';
+/**
+ * Resolve a ViewData configuration into a concrete DataSource instance.
+ *
+ * - `provider: 'object'` → returns `fallback` (the context DataSource — typically ObjectStackAdapter)
+ * - `provider: 'api'`    → returns a new `ApiDataSource`
+ * - `provider: 'value'`  → returns a new `ValueDataSource`
+ *
+ * @param viewData - The ViewData configuration from the schema
+ * @param fallback - The default DataSource from context (for `provider: 'object'`)
+ * @param options  - Additional options for adapter construction
+ * @returns A DataSource instance, or null if neither viewData nor fallback is available
+ *
+ * @example
+ * ```ts
+ * const ds = resolveDataSource(
+ *   { provider: 'api', read: { url: '/api/users' } },
+ *   contextDataSource,
+ * );
+ * const result = await ds.find('users');
+ * ```
+ */
+export function resolveDataSource(viewData, fallback, options) {
+    if (!viewData) {
+        return fallback ?? null;
+    }
+    switch (viewData.provider) {
+        case 'object':
+            // Delegate to the context DataSource (ObjectStackAdapter, etc.)
+            return fallback ?? null;
+        case 'api': {
+            const config = {
+                read: viewData.read,
+                write: viewData.write,
+                fetch: options?.fetch,
+                defaultHeaders: options?.defaultHeaders,
+            };
+            return new ApiDataSource(config);
+        }
+        case 'value':
+            return new ValueDataSource({
+                items: (viewData.items ?? []),
+                idField: options?.idField,
+            });
+        default:
+            // Unknown provider — fall back to context
+            return fallback ?? null;
+    }
+}

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

@@ -0,0 +1,127 @@
+/**
+ * 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 - DataScope Manager
+ *
+ * Runtime implementation of the DataContext interface for managing
+ * named data scopes. Provides row-level data access control and
+ * reactive data state management within the UI component tree.
+ *
+ * @module data-scope
+ * @packageDocumentation
+ */
+import type { DataScope, DataContext, DataSource } from '@object-ui/types';
+/**
+ * Row-level filter for restricting data access within a scope
+ */
+export interface RowLevelFilter {
+    /** Field to filter on */
+    field: string;
+    /** Filter operator */
+    operator: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'in' | 'nin' | 'contains';
+    /** Filter value */
+    value: any;
+}
+/**
+ * Configuration for creating a data scope
+ */
+export interface DataScopeConfig {
+    /** Data source instance */
+    dataSource?: DataSource;
+    /** Initial data */
+    data?: any;
+    /** Row-level filters to apply */
+    filters?: RowLevelFilter[];
+    /** Whether this scope is read-only */
+    readOnly?: boolean;
+}
+/**
+ * DataScopeManager — Runtime implementation of DataContext.
+ *
+ * Manages named data scopes for the component tree, providing:
+ * - Scope registration and lookup
+ * - Row-level security via filters
+ * - Data state management (data, loading, error)
+ *
+ * @example
+ * ```ts
+ * const manager = new DataScopeManager();
+ * manager.registerScope('contacts', {
+ *   dataSource: myDataSource,
+ *   data: [],
+ * });
+ * const scope = manager.getScope('contacts');
+ * ```
+ */
+export declare class DataScopeManager implements DataContext {
+    scopes: Record<string, DataScope>;
+    private filters;
+    private readOnlyScopes;
+    private listeners;
+    /**
+     * Register a data scope
+     */
+    registerScope(name: string, scope: DataScope): void;
+    /**
+     * Register a data scope with configuration
+     */
+    registerScopeWithConfig(name: string, config: DataScopeConfig): void;
+    /**
+     * Get a data scope by name
+     */
+    getScope(name: string): DataScope | undefined;
+    /**
+     * Remove a data scope
+     */
+    removeScope(name: string): void;
+    /**
+     * Check if a scope is read-only
+     */
+    isReadOnly(name: string): boolean;
+    /**
+     * Get row-level filters for a scope
+     */
+    getFilters(name: string): RowLevelFilter[];
+    /**
+     * Set row-level filters for a scope
+     */
+    setFilters(name: string, filters: RowLevelFilter[]): void;
+    /**
+     * Apply row-level filters to a dataset
+     */
+    applyFilters(name: string, data: any[]): any[];
+    /**
+     * Update data in a scope
+     */
+    updateScopeData(name: string, data: any): void;
+    /**
+     * Update loading state for a scope
+     */
+    updateScopeLoading(name: string, loading: boolean): void;
+    /**
+     * Update error state for a scope
+     */
+    updateScopeError(name: string, error: Error | string | null): void;
+    /**
+     * Subscribe to scope changes
+     */
+    onScopeChange(name: string, listener: (scope: DataScope) => void): () => void;
+    /**
+     * Get all registered scope names
+     */
+    getScopeNames(): string[];
+    /**
+     * Clear all scopes
+     */
+    clear(): void;
+    private notifyListeners;
+}
+/**
+ * Default DataScopeManager instance
+ */
+export declare const defaultDataScopeManager: DataScopeManager;

package/dist/data-scope/DataScopeManager.js

@@ -0,0 +1,229 @@
+/**
+ * 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.
+ */
+/**
+ * DataScopeManager — Runtime implementation of DataContext.
+ *
+ * Manages named data scopes for the component tree, providing:
+ * - Scope registration and lookup
+ * - Row-level security via filters
+ * - Data state management (data, loading, error)
+ *
+ * @example
+ * ```ts
+ * const manager = new DataScopeManager();
+ * manager.registerScope('contacts', {
+ *   dataSource: myDataSource,
+ *   data: [],
+ * });
+ * const scope = manager.getScope('contacts');
+ * ```
+ */
+export class DataScopeManager {
+    constructor() {
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "filters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "readOnlyScopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Register a data scope
+     */
+    registerScope(name, scope) {
+        this.scopes[name] = scope;
+        this.notifyListeners(name, scope);
+    }
+    /**
+     * Register a data scope with configuration
+     */
+    registerScopeWithConfig(name, config) {
+        const scope = {
+            dataSource: config.dataSource,
+            data: config.data,
+            loading: false,
+            error: null,
+        };
+        if (config.filters) {
+            this.filters[name] = config.filters;
+        }
+        if (config.readOnly) {
+            this.readOnlyScopes.add(name);
+        }
+        this.scopes[name] = scope;
+        this.notifyListeners(name, scope);
+    }
+    /**
+     * Get a data scope by name
+     */
+    getScope(name) {
+        return this.scopes[name];
+    }
+    /**
+     * Remove a data scope
+     */
+    removeScope(name) {
+        delete this.scopes[name];
+        delete this.filters[name];
+        this.readOnlyScopes.delete(name);
+        this.listeners.delete(name);
+    }
+    /**
+     * Check if a scope is read-only
+     */
+    isReadOnly(name) {
+        return this.readOnlyScopes.has(name);
+    }
+    /**
+     * Get row-level filters for a scope
+     */
+    getFilters(name) {
+        return this.filters[name] || [];
+    }
+    /**
+     * Set row-level filters for a scope
+     */
+    setFilters(name, filters) {
+        this.filters[name] = filters;
+    }
+    /**
+     * Apply row-level filters to a dataset
+     */
+    applyFilters(name, data) {
+        const scopeFilters = this.filters[name];
+        if (!scopeFilters || scopeFilters.length === 0) {
+            return data;
+        }
+        return data.filter(row => {
+            return scopeFilters.every(filter => {
+                const fieldValue = row[filter.field];
+                return evaluateFilter(fieldValue, filter.operator, filter.value);
+            });
+        });
+    }
+    /**
+     * Update data in a scope
+     */
+    updateScopeData(name, data) {
+        const scope = this.scopes[name];
+        if (!scope)
+            return;
+        if (this.readOnlyScopes.has(name)) {
+            throw new Error(`Cannot update read-only scope: ${name}`);
+        }
+        scope.data = data;
+        this.notifyListeners(name, scope);
+    }
+    /**
+     * Update loading state for a scope
+     */
+    updateScopeLoading(name, loading) {
+        const scope = this.scopes[name];
+        if (!scope)
+            return;
+        scope.loading = loading;
+        this.notifyListeners(name, scope);
+    }
+    /**
+     * Update error state for a scope
+     */
+    updateScopeError(name, error) {
+        const scope = this.scopes[name];
+        if (!scope)
+            return;
+        scope.error = error;
+        this.notifyListeners(name, scope);
+    }
+    /**
+     * Subscribe to scope changes
+     */
+    onScopeChange(name, listener) {
+        if (!this.listeners.has(name)) {
+            this.listeners.set(name, []);
+        }
+        this.listeners.get(name).push(listener);
+        return () => {
+            const arr = this.listeners.get(name);
+            if (arr) {
+                const idx = arr.indexOf(listener);
+                if (idx >= 0)
+                    arr.splice(idx, 1);
+            }
+        };
+    }
+    /**
+     * Get all registered scope names
+     */
+    getScopeNames() {
+        return Object.keys(this.scopes);
+    }
+    /**
+     * Clear all scopes
+     */
+    clear() {
+        this.scopes = {};
+        this.filters = {};
+        this.readOnlyScopes.clear();
+        this.listeners.clear();
+    }
+    notifyListeners(name, scope) {
+        const arr = this.listeners.get(name);
+        if (arr) {
+            arr.forEach(listener => listener(scope));
+        }
+    }
+}
+/**
+ * Evaluate a single filter condition against a field value
+ */
+function evaluateFilter(fieldValue, operator, filterValue) {
+    switch (operator) {
+        case 'eq':
+            return fieldValue === filterValue;
+        case 'ne':
+            return fieldValue !== filterValue;
+        case 'gt':
+            return fieldValue > filterValue;
+        case 'lt':
+            return fieldValue < filterValue;
+        case 'gte':
+            return fieldValue >= filterValue;
+        case 'lte':
+            return fieldValue <= filterValue;
+        case 'in':
+            return Array.isArray(filterValue) && filterValue.includes(fieldValue);
+        case 'nin':
+            return Array.isArray(filterValue) && !filterValue.includes(fieldValue);
+        case 'contains':
+            return typeof fieldValue === 'string' && fieldValue.includes(String(filterValue));
+        default:
+            return true;
+    }
+}
+/**
+ * Default DataScopeManager instance
+ */
+export const defaultDataScopeManager = new DataScopeManager();

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

@@ -0,0 +1,10 @@
+/**
+ * @object-ui/core - DataScope Module
+ *
+ * Runtime data scope management for row-level security and
+ * reactive data state within the UI component tree.
+ *
+ * @module data-scope
+ * @packageDocumentation
+ */
+export { DataScopeManager, defaultDataScopeManager, type RowLevelFilter, type DataScopeConfig, } from './DataScopeManager.js';

package/dist/data-scope/index.js

@@ -0,0 +1,10 @@
+/**
+ * @object-ui/core - DataScope Module
+ *
+ * Runtime data scope management for row-level security and
+ * reactive data state within the UI component tree.
+ *
+ * @module data-scope
+ * @packageDocumentation
+ */
+export { DataScopeManager, defaultDataScopeManager, } from './DataScopeManager.js';

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -16,6 +16,7 @@
  */
 import { ExpressionContext } from './ExpressionContext.js';
 import { ExpressionCache } from './ExpressionCache.js';
+import { FormulaFunctions } from './FormulaFunctions.js';
 /**
  * Options for expression evaluation
  */
@@ -41,7 +42,8 @@ export interface EvaluationOptions {
 export declare class ExpressionEvaluator {
     private context;
     private cache;
-    constructor(context?: ExpressionContext | Record<string, any>, cache?: ExpressionCache);
+    private formulas;
+    constructor(context?: ExpressionContext | Record<string, any>, cache?: ExpressionCache, formulas?: FormulaFunctions);
     /**
      * Evaluate a string that may contain template expressions like ${...}
      *
@@ -106,6 +108,14 @@ export declare class ExpressionEvaluator {
      * Clear the expression cache
      */
     clearCache(): void;
+    /**
+     * Get the formula functions registry
+     */
+    getFormulas(): FormulaFunctions;
+    /**
+     * Register a custom formula function
+     */
+    registerFunction(name: string, fn: (...args: any[]) => any): void;
 }
 /**
  * Convenience function to quickly evaluate an expression

package/dist/evaluator/ExpressionEvaluator.js

@@ -16,11 +16,12 @@
  */
 import { ExpressionContext } from './ExpressionContext.js';
 import { ExpressionCache } from './ExpressionCache.js';
+import { FormulaFunctions } from './FormulaFunctions.js';
 /**
  * Expression evaluator for dynamic UI expressions
  */
 export class ExpressionEvaluator {
-    constructor(context, cache) {
+    constructor(context, cache, formulas) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
@@ -33,6 +34,12 @@ export class ExpressionEvaluator {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "formulas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         if (context instanceof ExpressionContext) {
             this.context = context;
         }
@@ -41,6 +48,7 @@ export class ExpressionEvaluator {
         }
         // Use provided cache or create a new one
         this.cache = cache || new ExpressionCache();
+        this.formulas = formulas || new FormulaFunctions();
     }
     /**
      * Evaluate a string that may contain template expressions like ${...}
@@ -114,9 +122,12 @@ export class ExpressionEvaluator {
         try {
             // Create a safe evaluation function
             const contextObj = this.context.toObject();
+            // Inject formula functions into the evaluation context
+            const formulaObj = this.formulas.toObject();
+            const mergedContext = { ...formulaObj, ...contextObj };
             // Build safe function with context variables
-            const varNames = Object.keys(contextObj);
-            const varValues = Object.values(contextObj);
+            const varNames = Object.keys(mergedContext);
+            const varValues = Object.values(mergedContext);
             // Use cached compilation
             const compiled = this.cache.compile(expression, varNames);
             // Execute with context values
@@ -184,8 +195,8 @@ export class ExpressionEvaluator {
      * Create a new evaluator with additional context data
      */
     withContext(data) {
-        // Share the cache with the new evaluator for maximum efficiency
-        return new ExpressionEvaluator(this.context.createChild(data), this.cache);
+        // Share the cache and formulas with the new evaluator for maximum efficiency
+        return new ExpressionEvaluator(this.context.createChild(data), this.cache, this.formulas);
     }
     /**
      * Get cache statistics (useful for debugging and optimization)
@@ -199,22 +210,35 @@ export class ExpressionEvaluator {
     clearCache() {
         this.cache.clear();
     }
+    /**
+     * Get the formula functions registry
+     */
+    getFormulas() {
+        return this.formulas;
+    }
+    /**
+     * Register a custom formula function
+     */
+    registerFunction(name, fn) {
+        this.formulas.register(name, fn);
+    }
 }
 /**
- * Shared global cache for convenience functions
+ * Shared global cache and formulas for convenience functions
  */
 const globalCache = new ExpressionCache();
+const globalFormulas = new FormulaFunctions();
 /**
  * Convenience function to quickly evaluate an expression
  */
 export function evaluateExpression(expression, context = {}, options = {}) {
-    const evaluator = new ExpressionEvaluator(context, globalCache);
+    const evaluator = new ExpressionEvaluator(context, globalCache, globalFormulas);
     return evaluator.evaluate(expression, options);
 }
 /**
  * Convenience function to evaluate a condition
  */
 export function evaluateCondition(condition, context = {}) {
-    const evaluator = new ExpressionEvaluator(context, globalCache);
+    const evaluator = new ExpressionEvaluator(context, globalCache, globalFormulas);
     return evaluator.evaluateCondition(condition);
 }

package/dist/evaluator/FormulaFunctions.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 - Formula Functions
+ *
+ * Built-in formula functions for the expression engine.
+ * Provides aggregation, date, logic, and string functions
+ * compatible with low-code platform expression evaluation.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+/**
+ * A formula function that can be registered with the expression evaluator
+ */
+export type FormulaFunction = (...args: any[]) => any;
+/**
+ * Registry of built-in formula functions
+ */
+export declare class FormulaFunctions {
+    private functions;
+    constructor();
+    /**
+     * Register a custom formula function
+     */
+    register(name: string, fn: FormulaFunction): void;
+    /**
+     * Get a formula function by name
+     */
+    get(name: string): FormulaFunction | undefined;
+    /**
+     * Check if a function is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered function names
+     */
+    getNames(): string[];
+    /**
+     * Get all functions as a plain object (for injection into expression context)
+     */
+    toObject(): Record<string, FormulaFunction>;
+    /**
+     * Register all default built-in functions
+     */
+    private registerDefaults;
+    private registerAggregationFunctions;
+    private registerDateFunctions;
+    private registerLogicFunctions;
+    private registerStringFunctions;
+    private registerStringSearchFunctions;
+    private registerStatisticalFunctions;
+}