@object-ui/core 0.3.0 → 0.5.0

package/dist/registry/PluginSystem.js

@@ -0,0 +1,142 @@
+/**
+ * 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 { PluginScopeImpl } from './PluginScopeImpl.js';
+export class PluginSystem {
+    constructor() {
+        Object.defineProperty(this, "plugins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "loaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    /**
+     * Load a plugin into the system with optional scope isolation
+     * @param plugin The plugin definition to load
+     * @param registry The component registry to use for registration
+     * @param useScope Whether to use scoped loading (default: true for better isolation)
+     * @throws Error if dependencies are missing
+     */
+    async loadPlugin(plugin, registry, useScope = true) {
+        // Check if already loaded
+        if (this.loaded.has(plugin.name)) {
+            console.warn(`Plugin "${plugin.name}" is already loaded. Skipping.`);
+            return;
+        }
+        // Check dependencies
+        for (const dep of plugin.dependencies || []) {
+            if (!this.loaded.has(dep)) {
+                throw new Error(`Missing dependency: ${dep} required by ${plugin.name}`);
+            }
+        }
+        try {
+            if (useScope) {
+                // Create scoped environment for plugin
+                const scope = new PluginScopeImpl(plugin.name, plugin.version, registry, plugin.scopeConfig);
+                // Store scope for cleanup
+                this.scopes.set(plugin.name, scope);
+                // Execute registration with scope
+                plugin.register(scope);
+            }
+            else {
+                // Legacy mode: direct registry access
+                plugin.register(registry);
+            }
+            // Store plugin definition
+            this.plugins.set(plugin.name, plugin);
+            // Execute lifecycle hook
+            await plugin.onLoad?.();
+            // Mark as loaded
+            this.loaded.add(plugin.name);
+        }
+        catch (error) {
+            // Clean up on failure
+            this.plugins.delete(plugin.name);
+            this.scopes.delete(plugin.name);
+            throw error;
+        }
+    }
+    /**
+     * Unload a plugin from the system
+     * @param name The name of the plugin to unload
+     * @throws Error if other plugins depend on this plugin
+     */
+    async unloadPlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`Plugin "${name}" is not loaded`);
+        }
+        // Check if any loaded plugins depend on this one
+        for (const [pluginName, pluginDef] of this.plugins.entries()) {
+            if (this.loaded.has(pluginName) && pluginDef.dependencies?.includes(name)) {
+                throw new Error(`Cannot unload plugin "${name}" - plugin "${pluginName}" depends on it`);
+            }
+        }
+        // Execute lifecycle hook
+        await plugin.onUnload?.();
+        // Clean up scope if exists
+        const scope = this.scopes.get(name);
+        if (scope) {
+            scope.cleanup();
+            this.scopes.delete(name);
+        }
+        // Remove from loaded set
+        this.loaded.delete(name);
+        this.plugins.delete(name);
+    }
+    /**
+     * Get the scope for a loaded plugin
+     * @param name The name of the plugin
+     * @returns The plugin scope or undefined
+     */
+    getScope(name) {
+        return this.scopes.get(name);
+    }
+    /**
+     * Check if a plugin is loaded
+     * @param name The name of the plugin
+     * @returns true if the plugin is loaded
+     */
+    isLoaded(name) {
+        return this.loaded.has(name);
+    }
+    /**
+     * Get a loaded plugin definition
+     * @param name The name of the plugin
+     * @returns The plugin definition or undefined
+     */
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    /**
+     * Get all loaded plugin names
+     * @returns Array of loaded plugin names
+     */
+    getLoadedPlugins() {
+        return Array.from(this.loaded);
+    }
+    /**
+     * Get all plugin definitions
+     * @returns Array of all plugin definitions
+     */
+    getAllPlugins() {
+        return Array.from(this.plugins.values());
+    }
+}

package/dist/registry/Registry.d.ts

@@ -1,4 +1,11 @@
-import type { SchemaNode } from '../types';
+/**
+ * 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/index.js';
 export type ComponentRenderer<T = any> = T;
 export type ComponentInput = {
     name: string;
@@ -18,6 +25,7 @@ export type ComponentMeta = {
     label?: string;
     icon?: string;
     category?: string;
+    namespace?: string;
     inputs?: ComponentInput[];
     defaultProps?: Record<string, any>;
     defaultChildren?: SchemaNode[];
@@ -39,11 +47,79 @@ export type ComponentConfig<T = any> = ComponentMeta & {
 };
 export declare class Registry<T = any> {
     private components;
+    /**
+     * Register a component with optional namespace support.
+     * If namespace is provided in meta, the component will be registered as "namespace:type".
+     *
+     * @param type - Component type identifier
+     * @param component - Component renderer
+     * @param meta - Component metadata (including optional namespace)
+     *
+     * @example
+     * // Register with namespace
+     * registry.register('button', ButtonComponent, { namespace: 'ui' });
+     * // Accessible as 'ui:button' or 'button' (fallback)
+     *
+     * @example
+     * // Register without namespace (backward compatible)
+     * registry.register('button', ButtonComponent);
+     * // Accessible as 'button'
+     */
     register(type: string, component: ComponentRenderer<T>, meta?: ComponentMeta): void;
-    get(type: string): ComponentRenderer<T> | undefined;
-    getConfig(type: string): ComponentConfig<T> | undefined;
-    has(type: string): boolean;
+    /**
+     * Get a component by type. Supports both namespaced and non-namespaced lookups.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup priority
+     * @returns Component renderer or undefined
+     *
+     * @example
+     * // Direct lookup
+     * registry.get('ui:button') // Gets ui:button
+     *
+     * @example
+     * // Fallback lookup
+     * registry.get('button') // Gets first registered button
+     *
+     * @example
+     * // Namespaced lookup with priority
+     * registry.get('button', 'ui') // Tries 'ui:button' first, then 'button'
+     */
+    get(type: string, namespace?: string): ComponentRenderer<T> | undefined;
+    /**
+     * Get component configuration by type with namespace support.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup priority
+     * @returns Component configuration or undefined
+     */
+    getConfig(type: string, namespace?: string): ComponentConfig<T> | undefined;
+    /**
+     * Check if a component type is registered.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup
+     * @returns True if component is registered
+     */
+    has(type: string, namespace?: string): boolean;
+    /**
+     * Get all registered component types.
+     *
+     * @returns Array of all component type identifiers
+     */
     getAllTypes(): string[];
+    /**
+     * Get all registered component configurations.
+     *
+     * @returns Array of all component configurations
+     */
     getAllConfigs(): ComponentConfig<T>[];
+    /**
+     * Get all components in a specific namespace.
+     *
+     * @param namespace - Namespace to filter by
+     * @returns Array of component configurations in the namespace
+     */
+    getNamespaceComponents(namespace: string): ComponentConfig<T>[];
 }
 export declare const ComponentRegistry: Registry<any>;

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", {
@@ -7,30 +14,135 @@ export class Registry {
             value: new Map()
         });
     }
+    /**
+     * Register a component with optional namespace support.
+     * If namespace is provided in meta, the component will be registered as "namespace:type".
+     *
+     * @param type - Component type identifier
+     * @param component - Component renderer
+     * @param meta - Component metadata (including optional namespace)
+     *
+     * @example
+     * // Register with namespace
+     * registry.register('button', ButtonComponent, { namespace: 'ui' });
+     * // Accessible as 'ui:button' or 'button' (fallback)
+     *
+     * @example
+     * // Register without namespace (backward compatible)
+     * registry.register('button', ButtonComponent);
+     * // Accessible as 'button'
+     */
     register(type, component, meta) {
-        if (this.components.has(type)) {
-            console.warn(`Component type "${type}" is already registered. Overwriting.`);
+        const fullType = meta?.namespace ? `${meta.namespace}:${type}` : type;
+        // Warn if registering without namespace (deprecated pattern)
+        if (!meta?.namespace) {
+            console.warn(`Registering component "${type}" without a namespace is deprecated. ` +
+                `Please provide a namespace in the meta parameter.`);
         }
-        this.components.set(type, {
-            type,
+        if (this.components.has(fullType)) {
+            // console.warn(`Component type "${fullType}" is already registered. Overwriting.`);
+        }
+        this.components.set(fullType, {
+            type: fullType,
             component,
             ...meta
         });
+        // Also register without namespace for backward compatibility
+        // 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) {
+            this.components.set(type, {
+                type: fullType, // Keep reference to namespaced type
+                component,
+                ...meta
+            });
+        }
     }
-    get(type) {
+    /**
+     * Get a component by type. Supports both namespaced and non-namespaced lookups.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup priority
+     * @returns Component renderer or undefined
+     *
+     * @example
+     * // Direct lookup
+     * registry.get('ui:button') // Gets ui:button
+     *
+     * @example
+     * // Fallback lookup
+     * registry.get('button') // Gets first registered button
+     *
+     * @example
+     * // Namespaced lookup with priority
+     * registry.get('button', 'ui') // Tries 'ui:button' first, then 'button'
+     */
+    get(type, namespace) {
+        // If namespace is explicitly provided, ONLY look in that namespace (no fallback)
+        if (namespace) {
+            const namespacedType = `${namespace}:${type}`;
+            return this.components.get(namespacedType)?.component;
+        }
+        // When no namespace provided, use backward compatibility lookup
         return this.components.get(type)?.component;
     }
-    getConfig(type) {
+    /**
+     * Get component configuration by type with namespace support.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup priority
+     * @returns Component configuration or undefined
+     */
+    getConfig(type, namespace) {
+        // If namespace is explicitly provided, ONLY look in that namespace (no fallback)
+        if (namespace) {
+            const namespacedType = `${namespace}:${type}`;
+            return this.components.get(namespacedType);
+        }
+        // When no namespace provided, use backward compatibility lookup
         return this.components.get(type);
     }
-    has(type) {
+    /**
+     * Check if a component type is registered.
+     *
+     * @param type - Component type (e.g., 'button' or 'ui:button')
+     * @param namespace - Optional namespace for lookup
+     * @returns True if component is registered
+     */
+    has(type, namespace) {
+        // If namespace is explicitly provided, ONLY look in that namespace (no fallback)
+        if (namespace) {
+            const namespacedType = `${namespace}:${type}`;
+            return this.components.has(namespacedType);
+        }
+        // When no namespace provided, use backward compatibility lookup
         return this.components.has(type);
     }
+    /**
+     * Get all registered component types.
+     *
+     * @returns Array of all component type identifiers
+     */
     getAllTypes() {
         return Array.from(this.components.keys());
     }
+    /**
+     * Get all registered component configurations.
+     *
+     * @returns Array of all component configurations
+     */
     getAllConfigs() {
         return Array.from(this.components.values());
     }
+    /**
+     * Get all components in a specific namespace.
+     *
+     * @param namespace - Namespace to filter by
+     * @returns Array of component configurations in the namespace
+     */
+    getNamespaceComponents(namespace) {
+        return Array.from(this.components.values()).filter(config => config.namespace === namespace);
+    }
 }
 export const ComponentRegistry = new Registry();

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

@@ -0,0 +1,9 @@
+/**
+ * @object-ui/core - Validation Module
+ *
+ * Phase 3.5: Validation engine
+ * ObjectStack Spec v0.7.1: Object-level validation
+ */
+export * from './validation-engine.js';
+export * from './schema-validator.js';
+export * from './validators/index.js';

package/dist/validation/index.js

@@ -0,0 +1,9 @@
+/**
+ * @object-ui/core - Validation Module
+ *
+ * Phase 3.5: Validation engine
+ * ObjectStack Spec v0.7.1: Object-level validation
+ */
+export * from './validation-engine.js';
+export * from './schema-validator.js';
+export * from './validators/index.js';

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