@object-ui/core 3.3.0 → 3.3.2

package/src/registry/PluginSystem.ts

@@ -1,206 +0,0 @@
-/**
- * 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 { Registry } from './Registry.js';
-import type { PluginScope, PluginScopeConfig, AppMetadataPlugin, AppPluginContext } from '@object-ui/types';
-import { PluginScopeImpl } from './PluginScopeImpl.js';
-
-export interface PluginDefinition {
-  name: string;
-  version: string;
-  dependencies?: string[];  // Dependencies on other plugins
-  peerDependencies?: string[];  // Peer dependencies
-  register: (registry: Registry | PluginScope) => void;  // Support both legacy and scoped registration
-  onLoad?: () => void | Promise<void>;  // Lifecycle hook: called after registration
-  onUnload?: () => void | Promise<void>;  // Lifecycle hook: called before unload
-  scopeConfig?: PluginScopeConfig;  // Optional scope configuration
-}
-
-export class PluginSystem {
-  private plugins = new Map<string, PluginDefinition>();
-  private loaded = new Set<string>();
-  private scopes = new Map<string, PluginScopeImpl>();
-
-  /**
-   * 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: PluginDefinition, registry: Registry, useScope: boolean = true): Promise<void> {
-    // 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: string): Promise<void> {
-    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: string): PluginScope | undefined {
-    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: string): boolean {
-    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: string): PluginDefinition | undefined {
-    return this.plugins.get(name);
-  }
-
-  /**
-   * Get all loaded plugin names
-   * @returns Array of loaded plugin names
-   */
-  getLoadedPlugins(): string[] {
-    return Array.from(this.loaded);
-  }
-
-  /**
-   * Get all plugin definitions
-   * @returns Array of all plugin definitions
-   */
-  getAllPlugins(): PluginDefinition[] {
-    return Array.from(this.plugins.values());
-  }
-
-  /**
-   * Install an AppMetadataPlugin at runtime.
-   *
-   * Wraps the plugin as a PluginDefinition, calls its `init()` and `start()`
-   * lifecycle hooks, and loads it into the system.
-   *
-   * @param plugin - An AppMetadataPlugin instance
-   * @param registry - The component registry
-   * @param ctx - Optional context passed to the plugin's start() hook
-   */
-  async install(plugin: AppMetadataPlugin, registry: Registry, ctx?: AppPluginContext): Promise<void> {
-    if (this.loaded.has(plugin.name)) {
-      console.warn(`Plugin "${plugin.name}" is already installed. Skipping.`);
-      return;
-    }
-
-    await plugin.init();
-
-    const definition: PluginDefinition = {
-      name: plugin.name,
-      version: plugin.version,
-      register: () => {},
-      onLoad: async () => {
-        await plugin.start(ctx ?? { logger: console });
-      },
-      onUnload: async () => {
-        await plugin.stop();
-      },
-    };
-
-    await this.loadPlugin(definition, registry);
-  }
-
-  /**
-   * Uninstall an AppMetadataPlugin at runtime.
-   *
-   * Calls the plugin's `stop()` lifecycle hook (via onUnload) and
-   * removes it from the system.
-   *
-   * @param pluginName - Name of the plugin to uninstall
-   */
-  async uninstall(pluginName: string): Promise<void> {
-    await this.unloadPlugin(pluginName);
-  }
-}

package/src/registry/Registry.ts

@@ -1,219 +0,0 @@
-/**
- * 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;
-  type: 'string' | 'number' | 'boolean' | 'enum' | 'array' | 'object' | 'color' | 'date' | 'code' | 'file' | 'slot';
-  label?: string;
-  defaultValue?: any;
-  required?: boolean;
-  enum?: string[] | { label: string; value: any }[];
-  description?: string;
-  advanced?: boolean;
-  inputType?: string;
-};
-
-export type ComponentMeta = {
-  label?: string; // Display name in designer
-  icon?: string; // Icon name or svg string
-  category?: string; // Grouping category
-  namespace?: string; // Component namespace (e.g., 'ui', 'plugin-grid', 'field')
-  /**
-   * 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>; // Default props when dropped
-  defaultChildren?: SchemaNode[]; // Default children when dropped
-  examples?: Record<string, any>; // Example configurations
-  isContainer?: boolean; // Whether the component can have children
-  resizable?: boolean; // Whether the component can be resized in the designer
-  resizeConstraints?: {
-    width?: boolean;
-    height?: boolean;
-    minWidth?: number;
-    maxWidth?: number;
-    minHeight?: number;
-    maxHeight?: number;
-  };
-};
-
-export type ComponentConfig<T = any> = ComponentMeta & {
-  type: string;
-  component: ComponentRenderer<T>;
-};
-
-export class Registry<T = any> {
-  private components = new Map<string, ComponentConfig<T>>();
-
-  /**
-   * 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) {
-    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.\n\n` +
-        `  Migration:\n` +
-        `  // Before (deprecated):\n` +
-        `  registry.register('${type}', MyComponent);\n\n` +
-        `  // After:\n` +
-        `  registry.register('${type}', MyComponent, { namespace: 'my-plugin' });\n\n` +
-        `  See: https://github.com/objectstack-ai/objectui/blob/main/MIGRATION_GUIDE.md`
-      );
-    }
-    
-    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
-    // 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,
-        ...meta
-      });
-    }
-  }
-
-  /**
-   * 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 {
-    // 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;
-  }
-
-  /**
-   * 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 {
-    // 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);
-  }
-
-  /**
-   * 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 {
-    // 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(): string[] {
-    return Array.from(this.components.keys());
-  }
-
-  /**
-   * Get all registered component configurations.
-   * 
-   * @returns Array of all component configurations
-   */
-  getAllConfigs(): ComponentConfig<T>[] {
-    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: string): ComponentConfig<T>[] {
-    return Array.from(this.components.values()).filter(
-      config => config.namespace === namespace
-    );
-  }
-}
-
-export const ComponentRegistry = new Registry<any>();