@object-ui/core 0.3.0 → 0.3.1

package/dist/evaluator/ExpressionEvaluator.js

@@ -0,0 +1,200 @@
+/**
+ * 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';
+/**
+ * Expression evaluator for dynamic UI expressions
+ */
+export class ExpressionEvaluator {
+    constructor(context) {
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (context instanceof ExpressionContext) {
+            this.context = context;
+        }
+        else {
+            this.context = new ExpressionContext(context || {});
+        }
+    }
+    /**
+     * 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);
+            // 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});`);
+            // Execute with context values
+            return 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) {
+        return new ExpressionEvaluator(this.context.createChild(data));
+    }
+}
+/**
+ * Convenience function to quickly evaluate an expression
+ */
+export function evaluateExpression(expression, context = {}, options = {}) {
+    const evaluator = new ExpressionEvaluator(context);
+    return evaluator.evaluate(expression, options);
+}
+/**
+ * Convenience function to evaluate a condition
+ */
+export function evaluateCondition(condition, context = {}) {
+    const evaluator = new ExpressionEvaluator(context);
+    return evaluator.evaluateCondition(condition);
+}

package/dist/evaluator/index.d.ts

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

package/dist/evaluator/index.js

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

package/dist/index.d.ts

@@ -1,4 +1,14 @@
+/**
+ * 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 './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';

package/dist/index.js

@@ -1,7 +1,16 @@
+/**
+ * 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 './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 './evaluator'; // TODO
 // export * from './validators'; // TODO

package/dist/registry/Registry.d.ts

@@ -1,3 +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.
+ */
 import type { SchemaNode } from '../types';
 export type ComponentRenderer<T = any> = T;
 export type ComponentInput = {

package/dist/registry/Registry.js

@@ -1,3 +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 class Registry {
     constructor() {
         Object.defineProperty(this, "components", {

package/dist/types/index.d.ts

@@ -1,3 +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 interface SchemaNode {
     type: string;
     id?: string;

package/dist/types/index.js

@@ -1 +1,8 @@
+/**
+ * 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 {};

package/dist/utils/filter-converter.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+/**
+ * Filter Converter Utilities
+ *
+ * Shared utilities for converting MongoDB-like filter operators
+ * to ObjectStack FilterNode AST format.
+ */
+/**
+ * FilterNode AST type definition
+ * Represents a filter condition or a logical combination of conditions
+ *
+ * @example
+ * // Simple condition
+ * ['status', '=', 'active']
+ *
+ * // Logical combination
+ * ['and', ['age', '>=', 18], ['status', '=', 'active']]
+ */
+export type FilterNode = [string, string, any] | [string, ...FilterNode[]];
+/**
+ * Map MongoDB-like operators to ObjectStack filter operators.
+ *
+ * @param operator - MongoDB-style operator (e.g., '$gte', '$in')
+ * @returns ObjectStack operator or null if not recognized
+ */
+export declare function convertOperatorToAST(operator: string): string | null;
+/**
+ * Convert object-based filters to ObjectStack FilterNode AST format.
+ * Converts MongoDB-like operators to ObjectStack filter expressions.
+ *
+ * @param filter - Object-based filter with optional operators
+ * @returns FilterNode AST array
+ *
+ * @example
+ * // Simple filter - converted to AST
+ * convertFiltersToAST({ status: 'active' })
+ * // => ['status', '=', 'active']
+ *
+ * @example
+ * // Complex filter with operators
+ * convertFiltersToAST({ age: { $gte: 18 } })
+ * // => ['age', '>=', 18]
+ *
+ * @example
+ * // Multiple conditions
+ * convertFiltersToAST({ age: { $gte: 18, $lte: 65 }, status: 'active' })
+ * // => ['and', ['age', '>=', 18], ['age', '<=', 65], ['status', '=', 'active']]
+ *
+ * @throws {Error} If an unknown operator is encountered
+ */
+export declare function convertFiltersToAST(filter: Record<string, any>): FilterNode | Record<string, any>;

package/dist/utils/filter-converter.js

@@ -0,0 +1,100 @@
+/**
+ * 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.
+ */
+/**
+ * Map MongoDB-like operators to ObjectStack filter operators.
+ *
+ * @param operator - MongoDB-style operator (e.g., '$gte', '$in')
+ * @returns ObjectStack operator or null if not recognized
+ */
+export function convertOperatorToAST(operator) {
+    const operatorMap = {
+        '$eq': '=',
+        '$ne': '!=',
+        '$gt': '>',
+        '$gte': '>=',
+        '$lt': '<',
+        '$lte': '<=',
+        '$in': 'in',
+        '$nin': 'notin',
+        '$notin': 'notin',
+        '$contains': 'contains',
+        '$startswith': 'startswith',
+        '$between': 'between',
+    };
+    return operatorMap[operator] || null;
+}
+/**
+ * Convert object-based filters to ObjectStack FilterNode AST format.
+ * Converts MongoDB-like operators to ObjectStack filter expressions.
+ *
+ * @param filter - Object-based filter with optional operators
+ * @returns FilterNode AST array
+ *
+ * @example
+ * // Simple filter - converted to AST
+ * convertFiltersToAST({ status: 'active' })
+ * // => ['status', '=', 'active']
+ *
+ * @example
+ * // Complex filter with operators
+ * convertFiltersToAST({ age: { $gte: 18 } })
+ * // => ['age', '>=', 18]
+ *
+ * @example
+ * // Multiple conditions
+ * convertFiltersToAST({ age: { $gte: 18, $lte: 65 }, status: 'active' })
+ * // => ['and', ['age', '>=', 18], ['age', '<=', 65], ['status', '=', 'active']]
+ *
+ * @throws {Error} If an unknown operator is encountered
+ */
+export function convertFiltersToAST(filter) {
+    const conditions = [];
+    for (const [field, value] of Object.entries(filter)) {
+        if (value === null || value === undefined)
+            continue;
+        // Check if value is a complex operator object
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            // Handle operator-based filters
+            for (const [operator, operatorValue] of Object.entries(value)) {
+                // Special handling for $regex - warn users about limited support
+                if (operator === '$regex') {
+                    console.warn(`[ObjectUI] Warning: $regex operator is not fully supported. ` +
+                        `Converting to 'contains' which only supports substring matching, not regex patterns. ` +
+                        `Field: '${field}', Value: ${JSON.stringify(operatorValue)}. ` +
+                        `Consider using $contains or $startswith instead.`);
+                    conditions.push([field, 'contains', operatorValue]);
+                    continue;
+                }
+                const astOperator = convertOperatorToAST(operator);
+                if (astOperator) {
+                    conditions.push([field, astOperator, operatorValue]);
+                }
+                else {
+                    // Unknown operator - throw error to avoid silent failure
+                    throw new Error(`[ObjectUI] Unknown filter operator '${operator}' for field '${field}'. ` +
+                        `Supported operators: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $contains, $startswith, $between. ` +
+                        `If you need exact object matching, use the value directly without an operator.`);
+                }
+            }
+        }
+        else {
+            // Simple equality filter
+            conditions.push([field, '=', value]);
+        }
+    }
+    // If no conditions, return original filter
+    if (conditions.length === 0) {
+        return filter;
+    }
+    // If only one condition, return it directly
+    if (conditions.length === 1) {
+        return conditions[0];
+    }
+    // Multiple conditions: combine with 'and'
+    return ['and', ...conditions];
+}

package/dist/validation/schema-validator.d.ts

@@ -1,3 +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.
+ */
 /**
  * @object-ui/core - Schema Validation
  *

package/dist/validation/schema-validator.js

@@ -1,11 +1,9 @@
 /**
- * @object-ui/core - Schema Validation
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
  *
- * Runtime validation utilities for Object UI schemas.
- * These utilities help ensure schemas are valid before rendering.
- *
- * @module validation
- * @packageDocumentation
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  */
 /**
  * Validation rules for base schema

package/package.json

@@ -1,17 +1,28 @@
 {
   "name": "@object-ui/core",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "license": "MIT",
+  "description": "Core logic, types, and validation for Object UI. Zero React dependencies.",
+  "homepage": "https://www.objectui.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/objectstack-ai/objectui.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/objectstack-ai/objectui/issues"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "lodash": "^4.17.21",
-    "zod": "^3.22.4",
-    "@object-ui/types": "0.3.0"
+    "@objectstack/spec": "^0.3.3",
+    "lodash": "^4.17.23",
+    "zod": "^4.3.6",
+    "@object-ui/types": "0.3.1"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
-    "vitest": "^4.0.17"
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "tsc",