@object-ui/core 0.3.0 → 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/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @object-ui/core
 
+## 0.3.1
+
+### Patch Changes
+
+- Maintenance release - Documentation and build improvements
+- Updated dependencies
+  - @object-ui/types@0.3.1
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/actions/ActionRunner.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 ActionResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    reload?: boolean;
+    close?: boolean;
+    redirect?: string;
+}
+export interface ActionContext {
+    data?: Record<string, any>;
+    record?: any;
+    user?: any;
+    [key: string]: any;
+}
+export type ActionHandler = (action: any, context: ActionContext) => Promise<ActionResult> | ActionResult;
+export declare class ActionRunner {
+    private handlers;
+    private evaluator;
+    private context;
+    constructor(context?: ActionContext);
+    registerHandler(actionName: string, handler: ActionHandler): void;
+    execute(action: any): Promise<ActionResult>;
+    private executeActionSchema;
+    /**
+     * Execute navigation action
+     */
+    private executeNavigation;
+    private executeAPI;
+    private showConfirmation;
+    updateContext(newContext: Partial<ActionContext>): void;
+    getContext(): ActionContext;
+}
+export declare function executeAction(action: any, context?: ActionContext): Promise<ActionResult>;

package/dist/actions/ActionRunner.js

@@ -0,0 +1,160 @@
+/**
+ * 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 - Action Runner
+ *
+ * Executes actions defined in ActionSchema and EventHandler.
+ */
+import { ExpressionEvaluator } from '../evaluator/ExpressionEvaluator';
+export class ActionRunner {
+    constructor(context = {}) {
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "evaluator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "context", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.context = context;
+        this.evaluator = new ExpressionEvaluator(context);
+    }
+    registerHandler(actionName, handler) {
+        this.handlers.set(actionName, handler);
+    }
+    async execute(action) {
+        try {
+            if (action.condition) {
+                const shouldExecute = this.evaluator.evaluateCondition(action.condition);
+                if (!shouldExecute) {
+                    return { success: false, error: 'Action condition not met' };
+                }
+            }
+            if (action.disabled) {
+                const isDisabled = typeof action.disabled === 'string'
+                    ? this.evaluator.evaluateCondition(action.disabled)
+                    : action.disabled;
+                if (isDisabled) {
+                    return { success: false, error: 'Action is disabled' };
+                }
+            }
+            if (action.type === 'action' || action.actionType) {
+                return await this.executeActionSchema(action);
+            }
+            else if (action.type === 'navigation' || action.navigate) {
+                return await this.executeNavigation(action);
+            }
+            else if (action.type === 'api' || action.api) {
+                return await this.executeAPI(action);
+            }
+            else if (action.onClick) {
+                await action.onClick();
+                return { success: true };
+            }
+            return { success: false, error: 'Unknown action type' };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    async executeActionSchema(action) {
+        const result = { success: true };
+        if (action.confirmText) {
+            const confirmed = await this.showConfirmation(action.confirmText);
+            if (!confirmed) {
+                return { success: false, error: 'Action cancelled by user' };
+            }
+        }
+        if (action.api) {
+            const apiResult = await this.executeAPI(action);
+            if (!apiResult.success)
+                return apiResult;
+            result.data = apiResult.data;
+        }
+        if (action.onClick) {
+            await action.onClick();
+        }
+        result.reload = action.reload !== false;
+        result.close = action.close !== false;
+        if (action.redirect) {
+            result.redirect = this.evaluator.evaluate(action.redirect);
+        }
+        return result;
+    }
+    /**
+     * Execute navigation action
+     */
+    async executeNavigation(action) {
+        const nav = action.navigate || action;
+        const to = this.evaluator.evaluate(nav.to);
+        // Validate URL to prevent javascript: or data: schemes
+        const isValidUrl = typeof to === 'string' && (to.startsWith('http://') ||
+            to.startsWith('https://') ||
+            to.startsWith('/') ||
+            to.startsWith('./'));
+        if (!isValidUrl) {
+            return {
+                success: false,
+                error: 'Invalid URL scheme. Only http://, https://, and relative URLs are allowed.'
+            };
+        }
+        if (nav.external) {
+            window.open(to, '_blank', 'noopener,noreferrer');
+        }
+        else {
+            return { success: true, redirect: to };
+        }
+        return { success: true };
+    }
+    async executeAPI(action) {
+        const apiConfig = action.api;
+        if (typeof apiConfig === 'string') {
+            try {
+                const response = await fetch(apiConfig, {
+                    method: action.method || 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(this.context.data || {})
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const data = await response.json();
+                return { success: true, data };
+            }
+            catch (error) {
+                return { success: false, error: error.message };
+            }
+        }
+        return { success: false, error: 'Complex API configuration not yet implemented' };
+    }
+    async showConfirmation(message) {
+        const evaluatedMessage = this.evaluator.evaluate(message);
+        return window.confirm(evaluatedMessage);
+    }
+    updateContext(newContext) {
+        this.context = { ...this.context, ...newContext };
+        this.evaluator.updateContext(newContext);
+    }
+    getContext() {
+        return this.context;
+    }
+}
+export async function executeAction(action, context = {}) {
+    const runner = new ActionRunner(context);
+    return await runner.execute(action);
+}

package/dist/actions/index.d.ts

@@ -0,0 +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 * from './ActionRunner.js';

package/dist/actions/index.js

@@ -0,0 +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 * from './ActionRunner.js';

package/dist/adapters/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */

package/dist/adapters/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * 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 { ObjectStackAdapter, createObjectStackAdapter } from './objectstack-adapter';
+// Adapters have been moved to separate packages (e.g. @object-ui/data-objectstack)

package/dist/builder/schema-builder.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 Builder
  *

package/dist/builder/schema-builder.js

@@ -1,11 +1,9 @@
 /**
- * @object-ui/core - Schema Builder
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
  *
- * Fluent API for building schemas programmatically.
- * Provides type-safe builder functions for common schema patterns.
- *
- * @module builder
- * @packageDocumentation
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  */
 /**
  * Base builder class

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/ExpressionContext.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 Context
+ *
+ * Manages variable scope and data context for expression evaluation.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+/**
+ * Expression context for variable resolution
+ */
+export declare class ExpressionContext {
+    private scopes;
+    constructor(initialData?: Record<string, any>);
+    /**
+     * Push a new scope onto the context stack
+     */
+    pushScope(data: Record<string, any>): void;
+    /**
+     * Pop the current scope from the context stack
+     */
+    popScope(): void;
+    /**
+     * Get a variable value from the context
+     * Searches from innermost to outermost scope
+     */
+    get(path: string): any;
+    /**
+     * Set a variable value in the current scope
+     */
+    set(name: string, value: any): void;
+    /**
+     * Check if a variable exists in any scope
+     */
+    has(name: string): boolean;
+    /**
+     * Get all variables from all scopes as a flat object
+     */
+    toObject(): Record<string, any>;
+    /**
+     * Create a child context with additional data
+     */
+    createChild(data?: Record<string, any>): ExpressionContext;
+}

package/dist/evaluator/ExpressionContext.js

@@ -0,0 +1,110 @@
+/**
+ * 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 Context
+ *
+ * Manages variable scope and data context for expression evaluation.
+ *
+ * @module evaluator
+ * @packageDocumentation
+ */
+/**
+ * Expression context for variable resolution
+ */
+export class ExpressionContext {
+    constructor(initialData = {}) {
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.scopes.push(new Map(Object.entries(initialData)));
+    }
+    /**
+     * Push a new scope onto the context stack
+     */
+    pushScope(data) {
+        this.scopes.push(new Map(Object.entries(data)));
+    }
+    /**
+     * Pop the current scope from the context stack
+     */
+    popScope() {
+        if (this.scopes.length > 1) {
+            this.scopes.pop();
+        }
+    }
+    /**
+     * Get a variable value from the context
+     * Searches from innermost to outermost scope
+     */
+    get(path) {
+        // Split path by dots for nested access
+        const parts = path.split('.');
+        const varName = parts[0];
+        // Search scopes from innermost to outermost
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].has(varName)) {
+                let value = this.scopes[i].get(varName);
+                // Navigate nested path
+                for (let j = 1; j < parts.length; j++) {
+                    if (value && typeof value === 'object') {
+                        value = value[parts[j]];
+                    }
+                    else {
+                        return undefined;
+                    }
+                }
+                return value;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Set a variable value in the current scope
+     */
+    set(name, value) {
+        if (this.scopes.length > 0) {
+            this.scopes[this.scopes.length - 1].set(name, value);
+        }
+    }
+    /**
+     * Check if a variable exists in any scope
+     */
+    has(name) {
+        const varName = name.split('.')[0];
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].has(varName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get all variables from all scopes as a flat object
+     */
+    toObject() {
+        const result = {};
+        // Merge from outermost to innermost (later scopes override earlier ones)
+        for (const scope of this.scopes) {
+            for (const [key, value] of scope.entries()) {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    /**
+     * Create a child context with additional data
+     */
+    createChild(data = {}) {
+        const child = new ExpressionContext();
+        child.scopes = [...this.scopes, new Map(Object.entries(data))];
+        return child;
+    }
+}