@object-ui/core 0.3.0 → 0.5.0

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 Evaluator
+ *
+ * Evaluates template string expressions like ${data.amount > 1000} for dynamic UI behavior.
+ * Supports variable substitution, comparison operators, and basic JavaScript expressions.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+import { ExpressionContext } from './ExpressionContext.js';
+import { ExpressionCache } from './ExpressionCache.js';
+/**
+ * Options for expression evaluation
+ */
+export interface EvaluationOptions {
+    /**
+     * Default value to return if evaluation fails
+     */
+    defaultValue?: any;
+    /**
+     * Whether to throw errors on evaluation failure
+     * @default false
+     */
+    throwOnError?: boolean;
+    /**
+     * Whether to sanitize the expression before evaluation
+     * @default true
+     */
+    sanitize?: boolean;
+}
+/**
+ * Expression evaluator for dynamic UI expressions
+ */
+export declare class ExpressionEvaluator {
+    private context;
+    private cache;
+    constructor(context?: ExpressionContext | Record<string, any>, cache?: ExpressionCache);
+    /**
+     * Evaluate a string that may contain template expressions like ${...}
+     *
+     * @example
+     * ```ts
+     * const evaluator = new ExpressionEvaluator({ data: { amount: 1500 } });
+     * evaluator.evaluate('${data.amount > 1000}'); // Returns: true
+     * evaluator.evaluate('Amount is ${data.amount}'); // Returns: "Amount is 1500"
+     * ```
+     */
+    evaluate(expression: string | boolean | number | null | undefined, options?: EvaluationOptions): any;
+    /**
+     * Evaluate a single expression (without ${} wrapper)
+     *
+     * @example
+     * ```ts
+     * evaluator.evaluateExpression('data.amount > 1000'); // Returns: true
+     * evaluator.evaluateExpression('data.user.name'); // Returns: "John"
+     * ```
+     */
+    evaluateExpression(expression: string, options?: {
+        sanitize?: boolean;
+    }): any;
+    /**
+     * Check if expression contains potentially dangerous code
+     */
+    private isDangerous;
+    /**
+     * Evaluate a conditional expression and return boolean
+     *
+     * @example
+     * ```ts
+     * evaluator.evaluateCondition('${data.age >= 18}'); // Returns: true/false
+     * ```
+     */
+    evaluateCondition(condition: string | boolean | undefined, options?: EvaluationOptions): boolean;
+    /**
+     * Update the context with new data
+     */
+    updateContext(data: Record<string, any>): void;
+    /**
+     * Get the current context
+     */
+    getContext(): ExpressionContext;
+    /**
+     * 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
+ */
+export declare function evaluateExpression(expression: string | boolean | number | null | undefined, context?: Record<string, any>, options?: EvaluationOptions): any;
+/**
+ * Convenience function to evaluate a condition
+ */
+export declare function evaluateCondition(condition: string | boolean | undefined, context?: Record<string, any>): boolean;

package/dist/evaluator/ExpressionEvaluator.js

@@ -0,0 +1,220 @@
+/**
+ * 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 Evaluator
+ *
+ * Evaluates template string expressions like ${data.amount > 1000} for dynamic UI behavior.
+ * Supports variable substitution, comparison operators, and basic JavaScript expressions.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+import { ExpressionContext } from './ExpressionContext.js';
+import { ExpressionCache } from './ExpressionCache.js';
+/**
+ * Expression evaluator for dynamic UI expressions
+ */
+export class ExpressionEvaluator {
+    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 ${...}
+     *
+     * @example
+     * ```ts
+     * const evaluator = new ExpressionEvaluator({ data: { amount: 1500 } });
+     * evaluator.evaluate('${data.amount > 1000}'); // Returns: true
+     * evaluator.evaluate('Amount is ${data.amount}'); // Returns: "Amount is 1500"
+     * ```
+     */
+    evaluate(expression, options = {}) {
+        // Handle non-string primitives
+        if (typeof expression !== 'string') {
+            return expression;
+        }
+        const { defaultValue, throwOnError = false, sanitize = true } = options;
+        try {
+            // Check if string contains template expressions
+            const hasTemplates = expression.includes('${');
+            if (!hasTemplates) {
+                // No templates, return as-is
+                return expression;
+            }
+            // Special case: if the entire string is a single template expression, return the value directly
+            const singleTemplateMatch = expression.match(/^\$\{([^}]+)\}$/);
+            if (singleTemplateMatch) {
+                return this.evaluateExpression(singleTemplateMatch[1].trim(), { sanitize });
+            }
+            // Replace all ${...} expressions in a string with multiple parts
+            return expression.replace(/\$\{([^}]+)\}/g, (match, expr) => {
+                try {
+                    const result = this.evaluateExpression(expr.trim(), { sanitize });
+                    return String(result ?? '');
+                }
+                catch (error) {
+                    if (throwOnError) {
+                        throw error;
+                    }
+                    console.warn(`Expression evaluation failed for: ${expr}`, error);
+                    return match; // Return original if evaluation fails
+                }
+            });
+        }
+        catch (error) {
+            if (throwOnError) {
+                throw error;
+            }
+            console.warn(`Failed to evaluate expression: ${expression}`, error);
+            return defaultValue ?? expression;
+        }
+    }
+    /**
+     * Evaluate a single expression (without ${} wrapper)
+     *
+     * @example
+     * ```ts
+     * evaluator.evaluateExpression('data.amount > 1000'); // Returns: true
+     * evaluator.evaluateExpression('data.user.name'); // Returns: "John"
+     * ```
+     */
+    evaluateExpression(expression, options = {}) {
+        const { sanitize = true } = options;
+        if (!expression || expression.trim() === '') {
+            return undefined;
+        }
+        // Sanitize expression to prevent dangerous code execution
+        if (sanitize && this.isDangerous(expression)) {
+            throw new Error(`Potentially dangerous expression detected: ${expression}`);
+        }
+        try {
+            // Create a safe evaluation function
+            const contextObj = this.context.toObject();
+            // Build safe function with context variables
+            const varNames = Object.keys(contextObj);
+            const varValues = Object.values(contextObj);
+            // Use cached compilation
+            const compiled = this.cache.compile(expression, varNames);
+            // Execute with context values
+            return compiled.fn(...varValues);
+        }
+        catch (error) {
+            throw new Error(`Failed to evaluate expression "${expression}": ${error.message}`);
+        }
+    }
+    /**
+     * Check if expression contains potentially dangerous code
+     */
+    isDangerous(expression) {
+        const dangerousPatterns = [
+            /eval\s*\(/i,
+            /Function\s*\(/i,
+            /setTimeout\s*\(/i,
+            /setInterval\s*\(/i,
+            /import\s*\(/i,
+            /require\s*\(/i,
+            /process\./i,
+            /global\./i,
+            /window\./i,
+            /document\./i,
+            /__proto__/i,
+            /constructor\s*\(/i,
+            /prototype\./i,
+        ];
+        return dangerousPatterns.some(pattern => pattern.test(expression));
+    }
+    /**
+     * Evaluate a conditional expression and return boolean
+     *
+     * @example
+     * ```ts
+     * evaluator.evaluateCondition('${data.age >= 18}'); // Returns: true/false
+     * ```
+     */
+    evaluateCondition(condition, options = {}) {
+        if (typeof condition === 'boolean') {
+            return condition;
+        }
+        if (!condition) {
+            return true; // Default to visible/enabled if no condition
+        }
+        const result = this.evaluate(condition, options);
+        // Convert result to boolean
+        return Boolean(result);
+    }
+    /**
+     * Update the context with new data
+     */
+    updateContext(data) {
+        Object.entries(data).forEach(([key, value]) => {
+            this.context.set(key, value);
+        });
+    }
+    /**
+     * Get the current context
+     */
+    getContext() {
+        return this.context;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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, globalCache);
+    return evaluator.evaluate(expression, options);
+}
+/**
+ * Convenience function to evaluate a condition
+ */
+export function evaluateCondition(condition, context = {}) {
+    const evaluator = new ExpressionEvaluator(context, globalCache);
+    return evaluator.evaluateCondition(condition);
+}

package/dist/evaluator/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+export * from './ExpressionContext.js';
+export * from './ExpressionEvaluator.js';
+export * from './ExpressionCache.js';

package/dist/evaluator/index.js

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+export * from './ExpressionContext.js';
+export * from './ExpressionEvaluator.js';
+export * from './ExpressionCache.js';

package/dist/index.d.ts

@@ -1,4 +1,17 @@
-export * from './types';
-export * from './registry/Registry';
-export * from './validation/schema-validator';
-export * from './builder/schema-builder';
+/**
+ * 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.
+ */
+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

@@ -1,7 +1,18 @@
-export * from './types';
-export * from './registry/Registry';
-export * from './validation/schema-validator';
-export * from './builder/schema-builder';
+/**
+ * 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.
+ */
+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 './evaluator'; // 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;