@object-ui/core 0.3.1 → 0.5.0

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @object-ui/core@0.5.0 build /home/runner/work/objectui/objectui/packages/core
+> tsc
+

package/dist/actions/index.d.ts

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

package/dist/actions/index.js

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

package/dist/evaluator/ExpressionCache.d.ts

@@ -0,0 +1,101 @@
+/**
+ * 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 - Expression Cache
+ *
+ * Caches compiled expressions to avoid re-parsing on every render.
+ * Provides significant performance improvement for frequently evaluated expressions.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+/**
+ * A compiled expression function that can be executed with context values
+ */
+export type CompiledExpression = (...args: any[]) => any;
+/**
+ * Expression compilation metadata
+ */
+export interface ExpressionMetadata {
+    /**
+     * The compiled function
+     */
+    fn: CompiledExpression;
+    /**
+     * Variable names used in the expression
+     */
+    varNames: string[];
+    /**
+     * Original expression string
+     */
+    expression: string;
+    /**
+     * Timestamp when the expression was compiled
+     */
+    compiledAt: number;
+    /**
+     * Number of times this expression has been used
+     */
+    hitCount: number;
+}
+/**
+ * Cache for compiled expressions
+ *
+ * @example
+ * ```ts
+ * const cache = new ExpressionCache();
+ * const compiled = cache.compile('data.amount > 1000', ['data']);
+ * const result = compiled.fn({ amount: 1500 }); // true
+ * ```
+ */
+export declare class ExpressionCache {
+    private cache;
+    private maxSize;
+    /**
+     * Create a new expression cache
+     *
+     * @param maxSize Maximum number of expressions to cache (default: 1000)
+     */
+    constructor(maxSize?: number);
+    /**
+     * Compile an expression or retrieve from cache
+     *
+     * @param expr The expression to compile
+     * @param varNames Variable names available in the context
+     * @returns Compiled expression metadata
+     */
+    compile(expr: string, varNames: string[]): ExpressionMetadata;
+    /**
+     * Compile an expression into a function
+     */
+    private compileExpression;
+    /**
+     * Evict the least frequently used expression from cache
+     */
+    private evictLFU;
+    /**
+     * Check if an expression is cached
+     */
+    has(expr: string, varNames: string[]): boolean;
+    /**
+     * Clear the cache
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        totalHits: number;
+        entries: Array<{
+            expression: string;
+            hitCount: number;
+        }>;
+    };
+}

package/dist/evaluator/ExpressionCache.js

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+/**
+ * Cache for compiled expressions
+ *
+ * @example
+ * ```ts
+ * const cache = new ExpressionCache();
+ * const compiled = cache.compile('data.amount > 1000', ['data']);
+ * const result = compiled.fn({ amount: 1500 }); // true
+ * ```
+ */
+export class ExpressionCache {
+    /**
+     * Create a new expression cache
+     *
+     * @param maxSize Maximum number of expressions to cache (default: 1000)
+     */
+    constructor(maxSize = 1000) {
+        Object.defineProperty(this, "cache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "maxSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxSize = maxSize;
+    }
+    /**
+     * Compile an expression or retrieve from cache
+     *
+     * @param expr The expression to compile
+     * @param varNames Variable names available in the context
+     * @returns Compiled expression metadata
+     */
+    compile(expr, varNames) {
+        // Create a cache key that includes variable names to ensure correct scoping
+        const cacheKey = `${expr}::${varNames.join(',')}`;
+        if (this.cache.has(cacheKey)) {
+            const metadata = this.cache.get(cacheKey);
+            metadata.hitCount++;
+            return metadata;
+        }
+        // Evict least frequently used if cache is full
+        if (this.cache.size >= this.maxSize) {
+            this.evictLFU();
+        }
+        // Compile the expression
+        const fn = this.compileExpression(expr, varNames);
+        const metadata = {
+            fn,
+            varNames: [...varNames],
+            expression: expr,
+            compiledAt: Date.now(),
+            hitCount: 1,
+        };
+        this.cache.set(cacheKey, metadata);
+        return metadata;
+    }
+    /**
+     * Compile an expression into a function
+     */
+    compileExpression(expression, varNames) {
+        // SECURITY NOTE: Using Function constructor for expression evaluation.
+        // This is a controlled use case with:
+        // 1. Sanitization check (isDangerous) performed by caller
+        // 2. Strict mode enabled ("use strict")
+        // 3. Limited scope (only varNames variables available)
+        // 4. No access to global objects (process, window, etc.)
+        return new Function(...varNames, `"use strict"; return (${expression});`);
+    }
+    /**
+     * Evict the least frequently used expression from cache
+     */
+    evictLFU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        let lowestHits = Infinity;
+        // Find the entry with lowest hit count, or oldest if tied
+        for (const [key, metadata] of this.cache.entries()) {
+            if (metadata.hitCount < lowestHits ||
+                (metadata.hitCount === lowestHits && metadata.compiledAt < oldestTime)) {
+                oldestKey = key;
+                oldestTime = metadata.compiledAt;
+                lowestHits = metadata.hitCount;
+            }
+        }
+        if (oldestKey) {
+            this.cache.delete(oldestKey);
+        }
+    }
+    /**
+     * Check if an expression is cached
+     */
+    has(expr, varNames) {
+        const cacheKey = `${expr}::${varNames.join(',')}`;
+        return this.cache.has(cacheKey);
+    }
+    /**
+     * Clear the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        let totalHits = 0;
+        const entries = [];
+        for (const metadata of this.cache.values()) {
+            totalHits += metadata.hitCount;
+            entries.push({
+                expression: metadata.expression,
+                hitCount: metadata.hitCount,
+            });
+        }
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            totalHits,
+            entries: entries.sort((a, b) => b.hitCount - a.hitCount),
+        };
+    }
+}

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -14,7 +14,8 @@
  * @module evaluator
  * @packageDocumentation
  */
-import { ExpressionContext } from './ExpressionContext';
+import { ExpressionContext } from './ExpressionContext.js';
+import { ExpressionCache } from './ExpressionCache.js';
 /**
  * Options for expression evaluation
  */
@@ -39,7 +40,8 @@ export interface EvaluationOptions {
  */
 export declare class ExpressionEvaluator {
     private context;
-    constructor(context?: ExpressionContext | Record<string, any>);
+    private cache;
+    constructor(context?: ExpressionContext | Record<string, any>, cache?: ExpressionCache);
     /**
      * Evaluate a string that may contain template expressions like ${...}
      *
@@ -88,6 +90,22 @@ 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;
 }
 /**
  * Convenience function to quickly evaluate an expression

package/dist/evaluator/ExpressionEvaluator.js

@@ -14,24 +14,33 @@
  * @module evaluator
  * @packageDocumentation
  */
-import { ExpressionContext } from './ExpressionContext';
+import { ExpressionContext } from './ExpressionContext.js';
+import { ExpressionCache } from './ExpressionCache.js';
 /**
  * Expression evaluator for dynamic UI expressions
  */
 export class ExpressionEvaluator {
-    constructor(context) {
+    constructor(context, cache) {
         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
+        });
         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();
     }
     /**
      * Evaluate a string that may contain template expressions like ${...}
@@ -108,16 +117,10 @@ export class ExpressionEvaluator {
             // 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});`);
+            // 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 +184,37 @@ export class ExpressionEvaluator {
      * Create a new evaluator with additional context data
      */
     withContext(data) {
-        return new ExpressionEvaluator(this.context.createChild(data));
+        // Share the cache with the new evaluator for maximum efficiency
+        return new ExpressionEvaluator(this.context.createChild(data), this.cache);
+    }
+    /**
+     * Get cache statistics (useful for debugging and optimization)
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Clear the expression cache
+     */
+    clearCache() {
+        this.cache.clear();
     }
 }
+/**
+ * Shared global cache for convenience functions
+ */
+const globalCache = new ExpressionCache();
 /**
  * Convenience function to quickly evaluate an expression
  */
 export function evaluateExpression(expression, context = {}, options = {}) {
-    const evaluator = new ExpressionEvaluator(context);
+    const evaluator = new ExpressionEvaluator(context, globalCache);
     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);
     return evaluator.evaluateCondition(condition);
 }

package/dist/evaluator/index.d.ts

@@ -5,5 +5,6 @@
  * 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';

package/dist/evaluator/index.js

@@ -5,5 +5,6 @@
  * 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';

package/dist/index.d.ts

@@ -5,10 +5,13 @@
  * 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 './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';

package/dist/index.js

@@ -5,12 +5,14 @@
  * 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 './registry/Registry.js';
+export * from './registry/PluginSystem.js';
+export * from './registry/PluginScopeImpl.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 './data-scope'; // TODO
 // export * from './validators'; // TODO

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';

package/dist/query/query-ast.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ObjectUI - Query AST Builder
+ * Phase 3.3: QuerySchema AST implementation
+ * ObjectStack Spec v0.7.1: Window functions support
+ */
+import type { QueryAST, QuerySchema } from '@object-ui/types';
+/**
+ * Query AST Builder - Converts QuerySchema to AST
+ */
+export declare class QueryASTBuilder {
+    build(query: QuerySchema): QueryAST;
+    private buildSelect;
+    private buildFrom;
+    private buildWhere;
+    private buildFilterCondition;
+    private buildCondition;
+    private buildJoin;
+    private buildGroupBy;
+    private buildOrderBy;
+    private buildLimit;
+    private buildOffset;
+    private buildField;
+    private buildLiteral;
+    private buildAggregation;
+    /**
+     * Build window function node (ObjectStack Spec v0.7.1)
+     */
+    private buildWindow;
+    optimize(ast: QueryAST): QueryAST;
+}
+export declare const defaultQueryASTBuilder: QueryASTBuilder;
+export declare function buildQueryAST(query: QuerySchema): QueryAST;