@object-ui/core 0.3.1 → 2.0.0

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -14,7 +14,9 @@
  * @module evaluator
  * @packageDocumentation
  */
-import { ExpressionContext } from './ExpressionContext';
+import { ExpressionContext } from './ExpressionContext.js';
+import { ExpressionCache } from './ExpressionCache.js';
+import { FormulaFunctions } from './FormulaFunctions.js';
 /**
  * Options for expression evaluation
  */
@@ -39,7 +41,9 @@ export interface EvaluationOptions {
  */
 export declare class ExpressionEvaluator {
     private context;
-    constructor(context?: ExpressionContext | Record<string, any>);
+    private cache;
+    private formulas;
+    constructor(context?: ExpressionContext | Record<string, any>, cache?: ExpressionCache, formulas?: FormulaFunctions);
     /**
      * Evaluate a string that may contain template expressions like ${...}
      *
@@ -88,6 +92,30 @@ export declare class ExpressionEvaluator {
      * Create a new evaluator with additional context data
      */
     withContext(data: Record<string, any>): ExpressionEvaluator;
+    /**
+     * Get cache statistics (useful for debugging and optimization)
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        totalHits: number;
+        entries: Array<{
+            expression: string;
+            hitCount: number;
+        }>;
+    };
+    /**
+     * 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

@@ -14,24 +14,41 @@
  * @module evaluator
  * @packageDocumentation
  */
-import { ExpressionContext } from './ExpressionContext';
+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) {
+    constructor(context, cache, formulas) {
         Object.defineProperty(this, "context", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            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;
         }
         else {
             this.context = new ExpressionContext(context || {});
         }
+        // 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 ${...}
@@ -105,19 +122,16 @@ 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);
-            // SECURITY NOTE: Using Function constructor for expression evaluation.
-            // This is a controlled use case with:
-            // 1. Sanitization check (isDangerous) blocks dangerous patterns
-            // 2. Strict mode enabled ("use strict")
-            // 3. Limited scope (only contextObj variables available)
-            // 4. No access to global objects (process, window, etc.)
-            // For production use, consider: expr-eval, safe-eval, or a custom parser
-            const fn = new Function(...varNames, `"use strict"; return (${expression});`);
+            const varNames = Object.keys(mergedContext);
+            const varValues = Object.values(mergedContext);
+            // Use cached compilation
+            const compiled = this.cache.compile(expression, varNames);
             // Execute with context values
-            return fn(...varValues);
+            return compiled.fn(...varValues);
         }
         catch (error) {
             throw new Error(`Failed to evaluate expression "${expression}": ${error.message}`);
@@ -181,20 +195,50 @@ export class ExpressionEvaluator {
      * Create a new evaluator with additional context data
      */
     withContext(data) {
-        return new ExpressionEvaluator(this.context.createChild(data));
+        // 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)
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Clear the expression cache
+     */
+    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 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);
+    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);
+    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;
+}

package/dist/evaluator/FormulaFunctions.js

@@ -0,0 +1,350 @@
+/**
+ * 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.
+ */
+/**
+ * Registry of built-in formula functions
+ */
+export class FormulaFunctions {
+    constructor() {
+        Object.defineProperty(this, "functions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.registerDefaults();
+    }
+    /**
+     * Register a custom formula function
+     */
+    register(name, fn) {
+        this.functions.set(name.toUpperCase(), fn);
+    }
+    /**
+     * Get a formula function by name
+     */
+    get(name) {
+        return this.functions.get(name.toUpperCase());
+    }
+    /**
+     * Check if a function is registered
+     */
+    has(name) {
+        return this.functions.has(name.toUpperCase());
+    }
+    /**
+     * Get all registered function names
+     */
+    getNames() {
+        return Array.from(this.functions.keys());
+    }
+    /**
+     * Get all functions as a plain object (for injection into expression context)
+     */
+    toObject() {
+        const result = {};
+        for (const [name, fn] of this.functions) {
+            result[name] = fn;
+        }
+        return result;
+    }
+    /**
+     * Register all default built-in functions
+     */
+    registerDefaults() {
+        this.registerAggregationFunctions();
+        this.registerDateFunctions();
+        this.registerLogicFunctions();
+        this.registerStringFunctions();
+        this.registerStringSearchFunctions();
+        this.registerStatisticalFunctions();
+    }
+    // ==========================================================================
+    // Aggregation Functions
+    // ==========================================================================
+    registerAggregationFunctions() {
+        this.register('SUM', (...args) => {
+            const values = flattenNumericArgs(args);
+            return values.reduce((sum, v) => sum + v, 0);
+        });
+        this.register('AVG', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return values.reduce((sum, v) => sum + v, 0) / values.length;
+        });
+        this.register('COUNT', (...args) => {
+            const values = flattenArgs(args);
+            return values.filter(v => v != null).length;
+        });
+        this.register('MIN', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return Math.min(...values);
+        });
+        this.register('MAX', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return Math.max(...values);
+        });
+    }
+    // ==========================================================================
+    // Date Functions
+    // ==========================================================================
+    registerDateFunctions() {
+        this.register('TODAY', () => {
+            const now = new Date();
+            return now.toISOString().split('T')[0];
+        });
+        this.register('NOW', () => {
+            return new Date().toISOString();
+        });
+        this.register('DATEADD', (dateStr, amount, unit) => {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                throw new Error(`DATEADD: Invalid date "${dateStr}"`);
+            }
+            const normalizedUnit = String(unit).toLowerCase();
+            switch (normalizedUnit) {
+                case 'day':
+                case 'days':
+                    date.setDate(date.getDate() + amount);
+                    break;
+                case 'month':
+                case 'months':
+                    date.setMonth(date.getMonth() + amount);
+                    break;
+                case 'year':
+                case 'years':
+                    date.setFullYear(date.getFullYear() + amount);
+                    break;
+                case 'hour':
+                case 'hours':
+                    date.setHours(date.getHours() + amount);
+                    break;
+                case 'minute':
+                case 'minutes':
+                    date.setMinutes(date.getMinutes() + amount);
+                    break;
+                default:
+                    throw new Error(`DATEADD: Unsupported unit "${unit}"`);
+            }
+            return date.toISOString();
+        });
+        this.register('DATEDIFF', (dateStr1, dateStr2, unit) => {
+            const date1 = new Date(dateStr1);
+            const date2 = new Date(dateStr2);
+            if (isNaN(date1.getTime())) {
+                throw new Error(`DATEDIFF: Invalid date "${dateStr1}"`);
+            }
+            if (isNaN(date2.getTime())) {
+                throw new Error(`DATEDIFF: Invalid date "${dateStr2}"`);
+            }
+            const diffMs = date2.getTime() - date1.getTime();
+            const normalizedUnit = String(unit).toLowerCase();
+            switch (normalizedUnit) {
+                case 'day':
+                case 'days':
+                    return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+                case 'month':
+                case 'months':
+                    return (date2.getFullYear() - date1.getFullYear()) * 12 + (date2.getMonth() - date1.getMonth());
+                case 'year':
+                case 'years':
+                    return date2.getFullYear() - date1.getFullYear();
+                case 'hour':
+                case 'hours':
+                    return Math.floor(diffMs / (1000 * 60 * 60));
+                case 'minute':
+                case 'minutes':
+                    return Math.floor(diffMs / (1000 * 60));
+                default:
+                    throw new Error(`DATEDIFF: Unsupported unit "${unit}"`);
+            }
+        });
+        this.register('DATEFORMAT', (dateStr, format) => {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                throw new Error(`DATEFORMAT: Invalid date "${dateStr}"`);
+            }
+            const pad = (n, len = 2) => String(n).padStart(len, '0');
+            return format
+                .replace('YYYY', String(date.getFullYear()))
+                .replace('YY', String(date.getFullYear()).slice(-2))
+                .replace('MM', pad(date.getMonth() + 1))
+                .replace('DD', pad(date.getDate()))
+                .replace('HH', pad(date.getHours()))
+                .replace('mm', pad(date.getMinutes()))
+                .replace('ss', pad(date.getSeconds()));
+        });
+    }
+    // ==========================================================================
+    // Logic Functions
+    // ==========================================================================
+    registerLogicFunctions() {
+        this.register('IF', (condition, trueValue, falseValue) => {
+            return condition ? trueValue : falseValue;
+        });
+        this.register('AND', (...args) => {
+            return args.every(Boolean);
+        });
+        this.register('OR', (...args) => {
+            return args.some(Boolean);
+        });
+        this.register('NOT', (value) => {
+            return !value;
+        });
+        this.register('SWITCH', (expr, ...cases) => {
+            // SWITCH(expr, val1, result1, val2, result2, ..., defaultResult)
+            for (let i = 0; i < cases.length - 1; i += 2) {
+                if (expr === cases[i]) {
+                    return cases[i + 1];
+                }
+            }
+            // Return default value if odd number of case args
+            if (cases.length % 2 === 1) {
+                return cases[cases.length - 1];
+            }
+            return undefined;
+        });
+    }
+    // ==========================================================================
+    // String Functions
+    // ==========================================================================
+    registerStringFunctions() {
+        this.register('CONCAT', (...args) => {
+            return args.map(a => String(a ?? '')).join('');
+        });
+        this.register('LEFT', (text, count) => {
+            return String(text ?? '').substring(0, count);
+        });
+        this.register('RIGHT', (text, count) => {
+            const str = String(text ?? '');
+            return str.substring(Math.max(0, str.length - count));
+        });
+        this.register('TRIM', (text) => {
+            return String(text ?? '').trim();
+        });
+        this.register('UPPER', (text) => {
+            return String(text ?? '').toUpperCase();
+        });
+        this.register('LOWER', (text) => {
+            return String(text ?? '').toLowerCase();
+        });
+    }
+    // ==========================================================================
+    // String Search Functions
+    // ==========================================================================
+    registerStringSearchFunctions() {
+        this.register('FIND', (search, text, startPos) => {
+            const str = String(text ?? '');
+            const idx = str.indexOf(String(search ?? ''), startPos ?? 0);
+            return idx;
+        });
+        this.register('REPLACE', (text, search, replacement) => {
+            const str = String(text ?? '');
+            return str.split(String(search ?? '')).join(String(replacement ?? ''));
+        });
+        this.register('SUBSTRING', (text, start, length) => {
+            const str = String(text ?? '');
+            if (length !== undefined) {
+                return str.substring(start, start + length);
+            }
+            return str.substring(start);
+        });
+        this.register('REGEX', (text, pattern, flags) => {
+            const str = String(text ?? '');
+            const regex = new RegExp(pattern, flags);
+            return regex.test(str);
+        });
+        this.register('LEN', (text) => {
+            return String(text ?? '').length;
+        });
+    }
+    // ==========================================================================
+    // Statistical Functions
+    // ==========================================================================
+    registerStatisticalFunctions() {
+        this.register('MEDIAN', (...args) => {
+            const values = flattenNumericArgs(args).sort((a, b) => a - b);
+            if (values.length === 0)
+                return 0;
+            const mid = Math.floor(values.length / 2);
+            return values.length % 2 !== 0
+                ? values[mid]
+                : (values[mid - 1] + values[mid]) / 2;
+        });
+        this.register('STDEV', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length < 2)
+                return 0;
+            const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+            const squaredDiffs = values.map(v => (v - mean) ** 2);
+            const variance = squaredDiffs.reduce((sum, v) => sum + v, 0) / (values.length - 1);
+            return Math.sqrt(variance);
+        });
+        this.register('VARIANCE', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length < 2)
+                return 0;
+            const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+            const squaredDiffs = values.map(v => (v - mean) ** 2);
+            return squaredDiffs.reduce((sum, v) => sum + v, 0) / (values.length - 1);
+        });
+        this.register('PERCENTILE', (percentile, ...args) => {
+            const values = flattenNumericArgs(args).sort((a, b) => a - b);
+            if (values.length === 0)
+                return 0;
+            const p = Math.max(0, Math.min(100, percentile)) / 100;
+            const index = p * (values.length - 1);
+            const lower = Math.floor(index);
+            const upper = Math.ceil(index);
+            if (lower === upper)
+                return values[lower];
+            const fraction = index - lower;
+            return values[lower] + fraction * (values[upper] - values[lower]);
+        });
+    }
+}
+// ==========================================================================
+// Helpers
+// ==========================================================================
+/**
+ * Flatten nested arrays and extract numeric values
+ */
+function flattenNumericArgs(args) {
+    const result = [];
+    for (const arg of args) {
+        if (Array.isArray(arg)) {
+            result.push(...flattenNumericArgs(arg));
+        }
+        else {
+            const num = Number(arg);
+            if (!isNaN(num)) {
+                result.push(num);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Flatten nested arrays
+ */
+function flattenArgs(args) {
+    const result = [];
+    for (const arg of args) {
+        if (Array.isArray(arg)) {
+            result.push(...flattenArgs(arg));
+        }
+        else {
+            result.push(arg);
+        }
+    }
+    return result;
+}

package/dist/evaluator/index.d.ts

@@ -5,5 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export * from './ExpressionContext';
-export * from './ExpressionEvaluator';
+export * from './ExpressionContext.js';
+export * from './ExpressionEvaluator.js';
+export * from './ExpressionCache.js';
+export * from './FormulaFunctions.js';

package/dist/evaluator/index.js

@@ -5,5 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export * from './ExpressionContext';
-export * from './ExpressionEvaluator';
+export * from './ExpressionContext.js';
+export * from './ExpressionEvaluator.js';
+export * from './ExpressionCache.js';
+export * from './FormulaFunctions.js';

package/dist/index.d.ts

@@ -5,10 +5,17 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export * from './types';
-export * from './registry/Registry';
-export * from './validation/schema-validator';
-export * from './builder/schema-builder';
-export * from './utils/filter-converter';
-export * from './evaluator';
-export * from './actions';
+export type { SchemaNode, ComponentRendererProps } from './types/index.js';
+export * from './registry/Registry.js';
+export * from './registry/PluginSystem.js';
+export * from './registry/PluginScopeImpl.js';
+export * from './registry/WidgetRegistry.js';
+export * from './validation/index.js';
+export * from './builder/schema-builder.js';
+export * from './utils/filter-converter.js';
+export * from './evaluator/index.js';
+export * from './actions/index.js';
+export * from './query/index.js';
+export * from './adapters/index.js';
+export * from './theme/index.js';
+export * from './data-scope/index.js';

package/dist/index.js

@@ -5,12 +5,16 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export * from './types';
-export * from './registry/Registry';
-export * from './validation/schema-validator';
-export * from './builder/schema-builder';
-export * from './utils/filter-converter';
-export * from './evaluator';
-export * from './actions';
-// export * from './data-scope'; // TODO
-// export * from './validators'; // TODO
+export * from './registry/Registry.js';
+export * from './registry/PluginSystem.js';
+export * from './registry/PluginScopeImpl.js';
+export * from './registry/WidgetRegistry.js';
+export * from './validation/index.js';
+export * from './builder/schema-builder.js';
+export * from './utils/filter-converter.js';
+export * from './evaluator/index.js';
+export * from './actions/index.js';
+export * from './query/index.js';
+export * from './adapters/index.js';
+export * from './theme/index.js';
+export * from './data-scope/index.js';

package/dist/query/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @object-ui/core - Query Module
+ *
+ * Phase 3.3: Query AST builder and utilities
+ */
+export * from './query-ast.js';

package/dist/query/index.js

@@ -0,0 +1,6 @@
+/**
+ * @object-ui/core - Query Module
+ *
+ * Phase 3.3: Query AST builder and utilities
+ */
+export * from './query-ast.js';