@object-ui/core 0.5.0 → 2.0.0

package/dist/evaluator/FormulaFunctions.js

@@ -0,0 +1,350 @@
+/**
+ * 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.
+ */
+/**
+ * Registry of built-in formula functions
+ */
+export class FormulaFunctions {
+    constructor() {
+        Object.defineProperty(this, "functions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.registerDefaults();
+    }
+    /**
+     * Register a custom formula function
+     */
+    register(name, fn) {
+        this.functions.set(name.toUpperCase(), fn);
+    }
+    /**
+     * Get a formula function by name
+     */
+    get(name) {
+        return this.functions.get(name.toUpperCase());
+    }
+    /**
+     * Check if a function is registered
+     */
+    has(name) {
+        return this.functions.has(name.toUpperCase());
+    }
+    /**
+     * Get all registered function names
+     */
+    getNames() {
+        return Array.from(this.functions.keys());
+    }
+    /**
+     * Get all functions as a plain object (for injection into expression context)
+     */
+    toObject() {
+        const result = {};
+        for (const [name, fn] of this.functions) {
+            result[name] = fn;
+        }
+        return result;
+    }
+    /**
+     * Register all default built-in functions
+     */
+    registerDefaults() {
+        this.registerAggregationFunctions();
+        this.registerDateFunctions();
+        this.registerLogicFunctions();
+        this.registerStringFunctions();
+        this.registerStringSearchFunctions();
+        this.registerStatisticalFunctions();
+    }
+    // ==========================================================================
+    // Aggregation Functions
+    // ==========================================================================
+    registerAggregationFunctions() {
+        this.register('SUM', (...args) => {
+            const values = flattenNumericArgs(args);
+            return values.reduce((sum, v) => sum + v, 0);
+        });
+        this.register('AVG', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return values.reduce((sum, v) => sum + v, 0) / values.length;
+        });
+        this.register('COUNT', (...args) => {
+            const values = flattenArgs(args);
+            return values.filter(v => v != null).length;
+        });
+        this.register('MIN', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return Math.min(...values);
+        });
+        this.register('MAX', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length === 0)
+                return 0;
+            return Math.max(...values);
+        });
+    }
+    // ==========================================================================
+    // Date Functions
+    // ==========================================================================
+    registerDateFunctions() {
+        this.register('TODAY', () => {
+            const now = new Date();
+            return now.toISOString().split('T')[0];
+        });
+        this.register('NOW', () => {
+            return new Date().toISOString();
+        });
+        this.register('DATEADD', (dateStr, amount, unit) => {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                throw new Error(`DATEADD: Invalid date "${dateStr}"`);
+            }
+            const normalizedUnit = String(unit).toLowerCase();
+            switch (normalizedUnit) {
+                case 'day':
+                case 'days':
+                    date.setDate(date.getDate() + amount);
+                    break;
+                case 'month':
+                case 'months':
+                    date.setMonth(date.getMonth() + amount);
+                    break;
+                case 'year':
+                case 'years':
+                    date.setFullYear(date.getFullYear() + amount);
+                    break;
+                case 'hour':
+                case 'hours':
+                    date.setHours(date.getHours() + amount);
+                    break;
+                case 'minute':
+                case 'minutes':
+                    date.setMinutes(date.getMinutes() + amount);
+                    break;
+                default:
+                    throw new Error(`DATEADD: Unsupported unit "${unit}"`);
+            }
+            return date.toISOString();
+        });
+        this.register('DATEDIFF', (dateStr1, dateStr2, unit) => {
+            const date1 = new Date(dateStr1);
+            const date2 = new Date(dateStr2);
+            if (isNaN(date1.getTime())) {
+                throw new Error(`DATEDIFF: Invalid date "${dateStr1}"`);
+            }
+            if (isNaN(date2.getTime())) {
+                throw new Error(`DATEDIFF: Invalid date "${dateStr2}"`);
+            }
+            const diffMs = date2.getTime() - date1.getTime();
+            const normalizedUnit = String(unit).toLowerCase();
+            switch (normalizedUnit) {
+                case 'day':
+                case 'days':
+                    return Math.floor(diffMs / (1000 * 60 * 60 * 24));
+                case 'month':
+                case 'months':
+                    return (date2.getFullYear() - date1.getFullYear()) * 12 + (date2.getMonth() - date1.getMonth());
+                case 'year':
+                case 'years':
+                    return date2.getFullYear() - date1.getFullYear();
+                case 'hour':
+                case 'hours':
+                    return Math.floor(diffMs / (1000 * 60 * 60));
+                case 'minute':
+                case 'minutes':
+                    return Math.floor(diffMs / (1000 * 60));
+                default:
+                    throw new Error(`DATEDIFF: Unsupported unit "${unit}"`);
+            }
+        });
+        this.register('DATEFORMAT', (dateStr, format) => {
+            const date = new Date(dateStr);
+            if (isNaN(date.getTime())) {
+                throw new Error(`DATEFORMAT: Invalid date "${dateStr}"`);
+            }
+            const pad = (n, len = 2) => String(n).padStart(len, '0');
+            return format
+                .replace('YYYY', String(date.getFullYear()))
+                .replace('YY', String(date.getFullYear()).slice(-2))
+                .replace('MM', pad(date.getMonth() + 1))
+                .replace('DD', pad(date.getDate()))
+                .replace('HH', pad(date.getHours()))
+                .replace('mm', pad(date.getMinutes()))
+                .replace('ss', pad(date.getSeconds()));
+        });
+    }
+    // ==========================================================================
+    // Logic Functions
+    // ==========================================================================
+    registerLogicFunctions() {
+        this.register('IF', (condition, trueValue, falseValue) => {
+            return condition ? trueValue : falseValue;
+        });
+        this.register('AND', (...args) => {
+            return args.every(Boolean);
+        });
+        this.register('OR', (...args) => {
+            return args.some(Boolean);
+        });
+        this.register('NOT', (value) => {
+            return !value;
+        });
+        this.register('SWITCH', (expr, ...cases) => {
+            // SWITCH(expr, val1, result1, val2, result2, ..., defaultResult)
+            for (let i = 0; i < cases.length - 1; i += 2) {
+                if (expr === cases[i]) {
+                    return cases[i + 1];
+                }
+            }
+            // Return default value if odd number of case args
+            if (cases.length % 2 === 1) {
+                return cases[cases.length - 1];
+            }
+            return undefined;
+        });
+    }
+    // ==========================================================================
+    // String Functions
+    // ==========================================================================
+    registerStringFunctions() {
+        this.register('CONCAT', (...args) => {
+            return args.map(a => String(a ?? '')).join('');
+        });
+        this.register('LEFT', (text, count) => {
+            return String(text ?? '').substring(0, count);
+        });
+        this.register('RIGHT', (text, count) => {
+            const str = String(text ?? '');
+            return str.substring(Math.max(0, str.length - count));
+        });
+        this.register('TRIM', (text) => {
+            return String(text ?? '').trim();
+        });
+        this.register('UPPER', (text) => {
+            return String(text ?? '').toUpperCase();
+        });
+        this.register('LOWER', (text) => {
+            return String(text ?? '').toLowerCase();
+        });
+    }
+    // ==========================================================================
+    // String Search Functions
+    // ==========================================================================
+    registerStringSearchFunctions() {
+        this.register('FIND', (search, text, startPos) => {
+            const str = String(text ?? '');
+            const idx = str.indexOf(String(search ?? ''), startPos ?? 0);
+            return idx;
+        });
+        this.register('REPLACE', (text, search, replacement) => {
+            const str = String(text ?? '');
+            return str.split(String(search ?? '')).join(String(replacement ?? ''));
+        });
+        this.register('SUBSTRING', (text, start, length) => {
+            const str = String(text ?? '');
+            if (length !== undefined) {
+                return str.substring(start, start + length);
+            }
+            return str.substring(start);
+        });
+        this.register('REGEX', (text, pattern, flags) => {
+            const str = String(text ?? '');
+            const regex = new RegExp(pattern, flags);
+            return regex.test(str);
+        });
+        this.register('LEN', (text) => {
+            return String(text ?? '').length;
+        });
+    }
+    // ==========================================================================
+    // Statistical Functions
+    // ==========================================================================
+    registerStatisticalFunctions() {
+        this.register('MEDIAN', (...args) => {
+            const values = flattenNumericArgs(args).sort((a, b) => a - b);
+            if (values.length === 0)
+                return 0;
+            const mid = Math.floor(values.length / 2);
+            return values.length % 2 !== 0
+                ? values[mid]
+                : (values[mid - 1] + values[mid]) / 2;
+        });
+        this.register('STDEV', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length < 2)
+                return 0;
+            const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+            const squaredDiffs = values.map(v => (v - mean) ** 2);
+            const variance = squaredDiffs.reduce((sum, v) => sum + v, 0) / (values.length - 1);
+            return Math.sqrt(variance);
+        });
+        this.register('VARIANCE', (...args) => {
+            const values = flattenNumericArgs(args);
+            if (values.length < 2)
+                return 0;
+            const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+            const squaredDiffs = values.map(v => (v - mean) ** 2);
+            return squaredDiffs.reduce((sum, v) => sum + v, 0) / (values.length - 1);
+        });
+        this.register('PERCENTILE', (percentile, ...args) => {
+            const values = flattenNumericArgs(args).sort((a, b) => a - b);
+            if (values.length === 0)
+                return 0;
+            const p = Math.max(0, Math.min(100, percentile)) / 100;
+            const index = p * (values.length - 1);
+            const lower = Math.floor(index);
+            const upper = Math.ceil(index);
+            if (lower === upper)
+                return values[lower];
+            const fraction = index - lower;
+            return values[lower] + fraction * (values[upper] - values[lower]);
+        });
+    }
+}
+// ==========================================================================
+// Helpers
+// ==========================================================================
+/**
+ * Flatten nested arrays and extract numeric values
+ */
+function flattenNumericArgs(args) {
+    const result = [];
+    for (const arg of args) {
+        if (Array.isArray(arg)) {
+            result.push(...flattenNumericArgs(arg));
+        }
+        else {
+            const num = Number(arg);
+            if (!isNaN(num)) {
+                result.push(num);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Flatten nested arrays
+ */
+function flattenArgs(args) {
+    const result = [];
+    for (const arg of args) {
+        if (Array.isArray(arg)) {
+            result.push(...flattenArgs(arg));
+        }
+        else {
+            result.push(arg);
+        }
+    }
+    return result;
+}

package/dist/evaluator/index.d.ts

@@ -8,3 +8,4 @@
 export * from './ExpressionContext.js';
 export * from './ExpressionEvaluator.js';
 export * from './ExpressionCache.js';
+export * from './FormulaFunctions.js';

package/dist/evaluator/index.js

@@ -8,3 +8,4 @@
 export * from './ExpressionContext.js';
 export * from './ExpressionEvaluator.js';
 export * from './ExpressionCache.js';
+export * from './FormulaFunctions.js';

package/dist/index.d.ts

@@ -9,9 +9,13 @@ 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 './registry/WidgetRegistry.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 './adapters/index.js';
+export * from './theme/index.js';
+export * from './data-scope/index.js';

package/dist/index.js

@@ -8,11 +8,13 @@
 export * from './registry/Registry.js';
 export * from './registry/PluginSystem.js';
 export * from './registry/PluginScopeImpl.js';
+export * from './registry/WidgetRegistry.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
+export * from './adapters/index.js';
+export * from './theme/index.js';
+export * from './data-scope/index.js';

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

@@ -1,7 +1,7 @@
 /**
  * ObjectUI - Query AST Builder
  * Phase 3.3: QuerySchema AST implementation
- * ObjectStack Spec v0.7.1: Window functions support
+ * ObjectStack Spec v2.0.1: Window functions support
  */
 import type { QueryAST, QuerySchema } from '@object-ui/types';
 /**
@@ -23,7 +23,7 @@ export declare class QueryASTBuilder {
     private buildLiteral;
     private buildAggregation;
     /**
-     * Build window function node (ObjectStack Spec v0.7.1)
+     * Build window function node (ObjectStack Spec v2.0.1)
      */
     private buildWindow;
     optimize(ast: QueryAST): QueryAST;

package/dist/query/query-ast.js

@@ -1,7 +1,7 @@
 /**
  * ObjectUI - Query AST Builder
  * Phase 3.3: QuerySchema AST implementation
- * ObjectStack Spec v0.7.1: Window functions support
+ * ObjectStack Spec v2.0.1: Window functions support
  */
 /**
  * Query AST Builder - Converts QuerySchema to AST
@@ -44,7 +44,7 @@ export class QueryASTBuilder {
         if (query.aggregations && query.aggregations.length > 0) {
             fields.push(...query.aggregations.map(agg => this.buildAggregation(agg)));
         }
-        // Add window functions (ObjectStack Spec v0.7.1)
+        // Add window functions (ObjectStack Spec v2.0.1)
         if (query.windows && query.windows.length > 0) {
             fields.push(...query.windows.map(win => this.buildWindow(win)));
         }
@@ -227,7 +227,7 @@ export class QueryASTBuilder {
         };
     }
     /**
-     * Build window function node (ObjectStack Spec v0.7.1)
+     * Build window function node (ObjectStack Spec v2.0.1)
      */
     buildWindow(config) {
         const node = {

package/dist/registry/Registry.d.ts

@@ -26,6 +26,16 @@ export type ComponentMeta = {
     icon?: string;
     category?: string;
     namespace?: string;
+    /**
+     * When true, prevents the component from being registered with a non-namespaced fallback.
+     * Use this when a component should only be accessible via its full namespaced key.
+     * This avoids conflicts with other components that share the same base name.
+     *
+     * @example
+     * // Register as 'view:form' only, don't overwrite 'form'
+     * registry.register('form', FormView, { namespace: 'view', skipFallback: true });
+     */
+    skipFallback?: boolean;
     inputs?: ComponentInput[];
     defaultProps?: Record<string, any>;
     defaultChildren?: SchemaNode[];

package/dist/registry/Registry.js

@@ -51,7 +51,8 @@ export class Registry {
         // This allows "button" to work even when registered as "ui:button"
         // Note: If multiple namespaced components share the same short name,
         // the last registration wins for non-namespaced lookups
-        if (meta?.namespace) {
+        // Skip this if skipFallback is true to avoid overwriting other components
+        if (meta?.namespace && !meta?.skipFallback) {
             this.components.set(type, {
                 type: fullType, // Keep reference to namespaced type
                 component,

package/dist/registry/WidgetRegistry.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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.
+ */
+/**
+ * WidgetRegistry - Runtime widget management with auto-discovery.
+ *
+ * Provides registration, loading, and lookup of runtime widgets
+ * described by WidgetManifest objects. Widgets can be loaded from
+ * ES module URLs, provided inline, or resolved from the component registry.
+ *
+ * @module
+ */
+import type { WidgetManifest, ResolvedWidget, WidgetRegistryListener } from '@object-ui/types';
+import type { Registry } from './Registry.js';
+/**
+ * Options for creating a WidgetRegistry instance.
+ */
+export interface WidgetRegistryOptions {
+    /**
+     * Component registry to sync loaded widgets into.
+     * When a widget is loaded, its component is also registered here.
+     */
+    componentRegistry?: Registry;
+}
+/**
+ * WidgetRegistry manages runtime-loadable widgets described by manifests.
+ *
+ * @example
+ * ```ts
+ * const widgets = new WidgetRegistry({ componentRegistry: registry });
+ *
+ * widgets.register({
+ *   name: 'custom-chart',
+ *   version: '1.0.0',
+ *   type: 'chart',
+ *   label: 'Custom Chart',
+ *   source: { type: 'module', url: '/widgets/chart.js' },
+ * });
+ *
+ * const resolved = await widgets.load('custom-chart');
+ * ```
+ */
+export declare class WidgetRegistry {
+    private manifests;
+    private resolved;
+    private listeners;
+    private componentRegistry?;
+    constructor(options?: WidgetRegistryOptions);
+    /**
+     * Register a widget manifest.
+     * Does not load the widget; call `load()` to resolve it.
+     */
+    register(manifest: WidgetManifest): void;
+    /**
+     * Register multiple widget manifests at once.
+     */
+    registerAll(manifests: WidgetManifest[]): void;
+    /**
+     * Unregister a widget by name.
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get a widget manifest by name.
+     */
+    getManifest(name: string): WidgetManifest | undefined;
+    /**
+     * Get all registered widget manifests.
+     */
+    getAllManifests(): WidgetManifest[];
+    /**
+     * Get manifests filtered by category.
+     */
+    getByCategory(category: string): WidgetManifest[];
+    /**
+     * Check if a widget is registered.
+     */
+    has(name: string): boolean;
+    /**
+     * Check if a widget has been loaded (resolved).
+     */
+    isLoaded(name: string): boolean;
+    /**
+     * Load (resolve) a widget by name.
+     * If already loaded, returns the cached resolved widget.
+     *
+     * @throws Error if the widget is not registered or fails to load.
+     */
+    load(name: string): Promise<ResolvedWidget>;
+    /**
+     * Load all registered widgets.
+     * Returns an array of results (settled promises).
+     */
+    loadAll(): Promise<Array<{
+        name: string;
+        result: ResolvedWidget | Error;
+    }>>;
+    /**
+     * Subscribe to widget registry events.
+     * @returns Unsubscribe function.
+     */
+    on(listener: WidgetRegistryListener): () => void;
+    /**
+     * Clear all registered and loaded widgets.
+     */
+    clear(): void;
+    /**
+     * Get registry statistics.
+     */
+    getStats(): {
+        registered: number;
+        loaded: number;
+        categories: string[];
+    };
+    private resolveComponent;
+    private emit;
+}