@object-ui/core 0.3.0 → 0.3.1

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

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

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/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;
+    }
+}

package/dist/evaluator/ExpressionEvaluator.d.ts

@@ -0,0 +1,99 @@
+/**
+ * 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';
+/**
+ * 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;
+    constructor(context?: ExpressionContext | Record<string, any>);
+    /**
+     * 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;
+}
+/**
+ * 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;