@object-ui/core 0.3.1 → 0.5.0

package/src/registry/__tests__/PluginSystem.test.ts

@@ -0,0 +1,226 @@
+/**
+ * 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 { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PluginSystem, type PluginDefinition } from '../PluginSystem';
+import { Registry } from '../Registry';
+
+describe('PluginSystem', () => {
+  let pluginSystem: PluginSystem;
+  let registry: Registry;
+
+  beforeEach(() => {
+    pluginSystem = new PluginSystem();
+    registry = new Registry();
+  });
+
+  it('should load a simple plugin', async () => {
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: (reg) => {
+        reg.register('test', () => 'test');
+      }
+    };
+
+    // Use legacy mode (useScope: false) to test direct registry access
+    await pluginSystem.loadPlugin(plugin, registry, false);
+    
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(true);
+    expect(pluginSystem.getLoadedPlugins()).toContain('test-plugin');
+    expect(registry.has('test')).toBe(true);
+  });
+
+  it('should execute onLoad lifecycle hook', async () => {
+    const onLoad = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should execute async onLoad lifecycle hook', async () => {
+    const onLoad = vi.fn().mockResolvedValue(undefined);
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not load plugin twice', async () => {
+    const onLoad = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should check dependencies before loading', async () => {
+    const plugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await expect(pluginSystem.loadPlugin(plugin, registry)).rejects.toThrow(
+      'Missing dependency: base-plugin required by dependent-plugin'
+    );
+  });
+
+  it('should load plugins with dependencies in correct order', async () => {
+    const basePlugin: PluginDefinition = {
+      name: 'base-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const dependentPlugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(basePlugin, registry);
+    await pluginSystem.loadPlugin(dependentPlugin, registry);
+    
+    expect(pluginSystem.isLoaded('base-plugin')).toBe(true);
+    expect(pluginSystem.isLoaded('dependent-plugin')).toBe(true);
+  });
+
+  it('should unload a plugin', async () => {
+    const onUnload = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onUnload
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(true);
+    
+    await pluginSystem.unloadPlugin('test-plugin');
+    
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(false);
+    expect(onUnload).toHaveBeenCalledTimes(1);
+  });
+
+  it('should prevent unloading plugin with dependents', async () => {
+    const basePlugin: PluginDefinition = {
+      name: 'base-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const dependentPlugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(basePlugin, registry);
+    await pluginSystem.loadPlugin(dependentPlugin, registry);
+    
+    await expect(pluginSystem.unloadPlugin('base-plugin')).rejects.toThrow(
+      'Cannot unload plugin "base-plugin" - plugin "dependent-plugin" depends on it'
+    );
+  });
+
+  it('should throw error when unloading non-existent plugin', async () => {
+    await expect(pluginSystem.unloadPlugin('non-existent')).rejects.toThrow(
+      'Plugin "non-existent" is not loaded'
+    );
+  });
+
+  it('should get plugin definition', async () => {
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    const retrieved = pluginSystem.getPlugin('test-plugin');
+    expect(retrieved).toBe(plugin);
+  });
+
+  it('should get all plugins', async () => {
+    const plugin1: PluginDefinition = {
+      name: 'plugin-1',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const plugin2: PluginDefinition = {
+      name: 'plugin-2',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(plugin1, registry);
+    await pluginSystem.loadPlugin(plugin2, registry);
+    
+    const allPlugins = pluginSystem.getAllPlugins();
+    expect(allPlugins).toHaveLength(2);
+    expect(allPlugins).toContain(plugin1);
+    expect(allPlugins).toContain(plugin2);
+  });
+
+  it('should call register function with registry', async () => {
+    const registerFn = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: registerFn
+    };
+
+    // Use legacy mode (useScope: false) to verify the raw Registry is passed
+    await pluginSystem.loadPlugin(plugin, registry, false);
+    
+    expect(registerFn).toHaveBeenCalledWith(registry);
+    expect(registerFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should cleanup on registration failure', async () => {
+    const plugin: PluginDefinition = {
+      name: 'failing-plugin',
+      version: '1.0.0',
+      register: () => {
+        throw new Error('Registration failed');
+      }
+    };
+
+    await expect(pluginSystem.loadPlugin(plugin, registry)).rejects.toThrow('Registration failed');
+    
+    expect(pluginSystem.isLoaded('failing-plugin')).toBe(false);
+    expect(pluginSystem.getPlugin('failing-plugin')).toBeUndefined();
+  });
+});

package/src/registry/__tests__/Registry.test.ts

@@ -0,0 +1,293 @@
+/**
+ * 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 { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Registry } from '../Registry';
+
+describe('Registry', () => {
+  let registry: Registry;
+  let consoleWarnSpy: any;
+
+  beforeEach(() => {
+    registry = new Registry();
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  describe('Basic Registration', () => {
+    it('should register a component without namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component);
+      
+      expect(registry.has('button')).toBe(true);
+      expect(registry.get('button')).toBe(component);
+    });
+
+    it('should warn when registering without namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component);
+      
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Registering component "button" without a namespace is deprecated')
+      );
+    });
+
+    it('should register a component with namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: 'ui' });
+      
+      expect(registry.has('button', 'ui')).toBe(true);
+      expect(registry.get('button', 'ui')).toBe(component);
+    });
+
+    it('should not warn when registering with namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: 'ui' });
+      
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Namespaced Registration', () => {
+    it('should register components with the same name in different namespaces', () => {
+      const gridComponent1 = () => 'grid1';
+      const gridComponent2 = () => 'grid2';
+      
+      registry.register('grid', gridComponent1, { namespace: 'plugin-grid' });
+      registry.register('grid', gridComponent2, { namespace: 'plugin-aggrid' });
+      
+      expect(registry.get('grid', 'plugin-grid')).toBe(gridComponent1);
+      expect(registry.get('grid', 'plugin-aggrid')).toBe(gridComponent2);
+    });
+
+    it('should store full type as namespace:type', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: 'ui' });
+      
+      const config = registry.getConfig('button', 'ui');
+      expect(config?.type).toBe('ui:button');
+    });
+
+    it('should preserve namespace in component config', () => {
+      const component = () => 'test';
+      registry.register('button', component, { 
+        namespace: 'ui',
+        label: 'Button',
+        category: 'form'
+      });
+      
+      const config = registry.getConfig('button', 'ui');
+      expect(config?.namespace).toBe('ui');
+      expect(config?.label).toBe('Button');
+      expect(config?.category).toBe('form');
+    });
+  });
+
+  describe('Namespace Lookup with Fallback', () => {
+    it('should not fallback when namespace is explicitly specified', () => {
+      const component = () => 'test';
+      registry.register('button', component);
+      
+      // When no namespace is specified, should find it
+      expect(registry.get('button')).toBe(component);
+      
+      // When namespace is specified but component isn't in that namespace, should return undefined
+      expect(registry.get('button', 'ui')).toBeUndefined();
+    });
+
+    it('should prefer namespaced component over non-namespaced', () => {
+      const component1 = () => 'non-namespaced';
+      const component2 = () => 'namespaced';
+      
+      registry.register('button', component1);
+      registry.register('button', component2, { namespace: 'ui' });
+      
+      // When searching with namespace, should get namespaced version
+      expect(registry.get('button', 'ui')).toBe(component2);
+      
+      // When searching without namespace, should get the latest registered (namespaced one due to backward compatibility)
+      expect(registry.get('button')).toBe(component2);
+    });
+
+    it('should return undefined when component not found in any namespace', () => {
+      expect(registry.get('nonexistent', 'ui')).toBeUndefined();
+      expect(registry.get('nonexistent')).toBeUndefined();
+    });
+  });
+
+  describe('has() method', () => {
+    it('should check existence with namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: 'ui' });
+      
+      expect(registry.has('button', 'ui')).toBe(true);
+      // Due to backward compatibility, non-namespaced lookup also works
+      expect(registry.has('button')).toBe(true);
+      // Other namespaces should return false
+      expect(registry.has('button', 'other')).toBe(false);
+    });
+
+    it('should fallback to non-namespaced check only when no namespace provided', () => {
+      const component = () => 'test';
+      registry.register('button', component);
+      
+      expect(registry.has('button')).toBe(true);
+      // When namespace is explicitly requested, should not find non-namespaced component
+      expect(registry.has('button', 'ui')).toBe(false);
+    });
+  });
+
+  describe('getConfig() method', () => {
+    it('should get config with namespace', () => {
+      const component = () => 'test';
+      registry.register('button', component, { 
+        namespace: 'ui',
+        label: 'Button' 
+      });
+      
+      const config = registry.getConfig('button', 'ui');
+      expect(config).toBeDefined();
+      expect(config?.component).toBe(component);
+      expect(config?.label).toBe('Button');
+    });
+
+    it('should not fallback when namespace is explicitly provided', () => {
+      const component = () => 'test';
+      registry.register('button', component, { label: 'Button' });
+      
+      // When no namespace is provided, should find it
+      const config1 = registry.getConfig('button');
+      expect(config1).toBeDefined();
+      
+      // When namespace is provided but component isn't in that namespace, should return undefined
+      const config2 = registry.getConfig('button', 'ui');
+      expect(config2).toBeUndefined();
+    });
+  });
+
+  describe('getAllTypes() and getAllConfigs()', () => {
+    it('should return all registered types including namespaced ones', () => {
+      registry.register('button', () => 'b1');
+      registry.register('input', () => 'i1', { namespace: 'ui' });
+      registry.register('grid', () => 'g1', { namespace: 'plugin-grid' });
+      
+      const types = registry.getAllTypes();
+      // Due to backward compatibility, namespaced components are stored under both keys
+      expect(types).toContain('button');
+      expect(types).toContain('ui:input');
+      expect(types).toContain('input'); // backward compat
+      expect(types).toContain('plugin-grid:grid');
+      expect(types).toContain('grid'); // backward compat
+    });
+
+    it('should return all configs', () => {
+      registry.register('button', () => 'b1', { label: 'Button' });
+      registry.register('input', () => 'i1', { 
+        namespace: 'ui',
+        label: 'Input' 
+      });
+      
+      const configs = registry.getAllConfigs();
+      // Due to backward compatibility, namespaced components are stored twice
+      expect(configs.length).toBeGreaterThanOrEqual(2);
+      expect(configs.map(c => c.type)).toContain('button');
+      expect(configs.map(c => c.type)).toContain('ui:input');
+    });
+  });
+
+  describe('Conflict Prevention', () => {
+    it('should allow same type name in different namespaces', () => {
+      const grid1 = () => 'grid-plugin-1';
+      const grid2 = () => 'grid-plugin-2';
+      const grid3 = () => 'aggrid-plugin';
+      
+      registry.register('grid', grid1, { namespace: 'plugin-grid' });
+      registry.register('grid', grid2, { namespace: 'plugin-view' });
+      registry.register('grid', grid3, { namespace: 'plugin-aggrid' });
+      
+      expect(registry.get('grid', 'plugin-grid')).toBe(grid1);
+      expect(registry.get('grid', 'plugin-view')).toBe(grid2);
+      expect(registry.get('grid', 'plugin-aggrid')).toBe(grid3);
+    });
+
+    it('should handle complex namespace names', () => {
+      const component = () => 'test';
+      registry.register('table', component, { namespace: 'plugin-advanced-grid' });
+      
+      expect(registry.get('table', 'plugin-advanced-grid')).toBe(component);
+      expect(registry.getConfig('table', 'plugin-advanced-grid')?.type).toBe('plugin-advanced-grid:table');
+    });
+  });
+
+  describe('Backward Compatibility', () => {
+    it('should maintain compatibility with existing non-namespaced code', () => {
+      const component = () => 'test';
+      
+      // Old-style registration
+      registry.register('button', component);
+      
+      // Old-style retrieval should still work
+      expect(registry.get('button')).toBe(component);
+      expect(registry.has('button')).toBe(true);
+      expect(registry.getConfig('button')).toBeDefined();
+    });
+
+    it('should support mixed namespaced and non-namespaced registrations', () => {
+      const oldButton = () => 'old';
+      const newButton = () => 'new';
+      
+      registry.register('button-old', oldButton);
+      registry.register('button-new', newButton, { namespace: 'ui' });
+      
+      expect(registry.get('button-old')).toBe(oldButton);
+      expect(registry.get('button-new', 'ui')).toBe(newButton);
+    });
+    
+    it('should allow non-namespaced lookup of namespaced components', () => {
+      const component = () => 'test';
+      
+      // Register with namespace
+      registry.register('button', component, { namespace: 'ui' });
+      
+      // Should be findable both ways for backward compatibility
+      expect(registry.get('button')).toBe(component);
+      expect(registry.get('button', 'ui')).toBe(component);
+      
+      // The full type should be namespaced
+      const config = registry.getConfig('button');
+      expect(config?.type).toBe('ui:button');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty namespace string', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: '' });
+      
+      // Empty namespace should be treated as no namespace
+      expect(registry.get('button')).toBe(component);
+    });
+
+    it('should handle namespace with special characters', () => {
+      const component = () => 'test';
+      registry.register('button', component, { namespace: 'plugin-my-custom' });
+      
+      expect(registry.get('button', 'plugin-my-custom')).toBe(component);
+    });
+
+    it('should handle undefined meta', () => {
+      const component = () => 'test';
+      registry.register('button', component, undefined);
+      
+      expect(registry.get('button')).toBe(component);
+    });
+  });
+});