@object-ui/core 0.3.0 → 0.5.0

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

package/src/registry/__tests__/plugin-scope-integration.test.ts

@@ -0,0 +1,283 @@
+/**
+ * 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.
+ */
+
+/**
+ * Plugin Scope Integration Tests
+ * Section 3.3: Test scoped plugin system to ensure isolation
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Registry } from '../Registry';
+import { PluginSystem } from '../PluginSystem';
+import type { PluginScope } from '@object-ui/types';
+
+describe('Plugin Scope Integration', () => {
+  let registry: Registry;
+  let pluginSystem: PluginSystem;
+
+  beforeEach(() => {
+    registry = new Registry();
+    pluginSystem = new PluginSystem();
+  });
+
+  describe('Component Registration Isolation', () => {
+    it('should isolate component registrations between plugins', async () => {
+      const MockTableA = () => 'Table A';
+      const MockTableB = () => 'Table B';
+
+      const pluginA = {
+        name: 'plugin-a',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.registerComponent('table', MockTableA);
+        },
+      };
+
+      const pluginB = {
+        name: 'plugin-b',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.registerComponent('table', MockTableB);
+        },
+      };
+
+      await pluginSystem.loadPlugin(pluginA, registry, true);
+      await pluginSystem.loadPlugin(pluginB, registry, true);
+
+      // Both plugins should have their own namespaced component
+      const tableA = registry.getConfig('plugin-a:table');
+      const tableB = registry.getConfig('plugin-b:table');
+
+      expect(tableA).toBeDefined();
+      expect(tableB).toBeDefined();
+      expect(tableA?.component).toBe(MockTableA);
+      expect(tableB?.component).toBe(MockTableB);
+    });
+
+    it('should allow scoped component to access global components', async () => {
+      const GlobalButton = () => 'Global Button';
+      const MockGrid = () => 'Grid';
+
+      // Register a global component
+      registry.register('button', GlobalButton);
+
+      const plugin = {
+        name: 'plugin-grid',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.registerComponent('grid', MockGrid);
+          
+          // Plugin should be able to access global components
+          const button = scope.getComponent('button');
+          expect(button).toBe(GlobalButton);
+        },
+      };
+
+      await pluginSystem.loadPlugin(plugin, registry, true);
+    });
+  });
+
+  describe('State Management Isolation', () => {
+    it('should isolate state between plugins', async () => {
+      let stateA: any;
+      let stateB: any;
+
+      const pluginA = {
+        name: 'plugin-a',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          const [config, setConfig] = scope.useState('config', { theme: 'dark' });
+          stateA = config;
+          setConfig({ theme: 'light' });
+        },
+      };
+
+      const pluginB = {
+        name: 'plugin-b',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          const [config, setConfig] = scope.useState('config', { theme: 'auto' });
+          stateB = config;
+        },
+      };
+
+      await pluginSystem.loadPlugin(pluginA, registry, true);
+      await pluginSystem.loadPlugin(pluginB, registry, true);
+
+      // State should be isolated
+      const scopeA = pluginSystem.getScope('plugin-a');
+      const scopeB = pluginSystem.getScope('plugin-b');
+
+      expect(scopeA?.getState('config')).toEqual({ theme: 'light' });
+      expect(scopeB?.getState('config')).toEqual({ theme: 'auto' });
+    });
+
+    it('should enforce state size limits', async () => {
+      const plugin = {
+        name: 'plugin-heavy',
+        version: '1.0.0',
+        scopeConfig: {
+          maxStateSize: 100, // Very small limit for testing
+        },
+        register: (scope: PluginScope) => {
+          // This should throw due to size limit
+          expect(() => {
+            scope.setState('largeData', {
+              data: 'x'.repeat(1000), // Much larger than 100 bytes
+            });
+          }).toThrow(/exceeded maximum state size/);
+        },
+      };
+
+      await pluginSystem.loadPlugin(plugin, registry, true);
+    });
+  });
+
+  describe('Event Bus Isolation', () => {
+    it('should isolate events between plugins', async () => {
+      const eventsA: any[] = [];
+      const eventsB: any[] = [];
+
+      const pluginA = {
+        name: 'plugin-a',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.on('data-updated', (data) => {
+            eventsA.push(data);
+          });
+          
+          scope.emit('data-updated', { source: 'A' });
+        },
+      };
+
+      const pluginB = {
+        name: 'plugin-b',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.on('data-updated', (data) => {
+            eventsB.push(data);
+          });
+          
+          scope.emit('data-updated', { source: 'B' });
+        },
+      };
+
+      await pluginSystem.loadPlugin(pluginA, registry, true);
+      await pluginSystem.loadPlugin(pluginB, registry, true);
+
+      // Events should be isolated - plugin A should only see its own events
+      expect(eventsA).toHaveLength(1);
+      expect(eventsA[0]).toEqual({ source: 'A' });
+      
+      expect(eventsB).toHaveLength(1);
+      expect(eventsB[0]).toEqual({ source: 'B' });
+    });
+
+    it('should support global events for cross-plugin communication', async () => {
+      const globalEvents: any[] = [];
+
+      const pluginA = {
+        name: 'plugin-a',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.onGlobal('app-ready', (data) => {
+            globalEvents.push({ plugin: 'A', data });
+          });
+        },
+      };
+
+      const pluginB = {
+        name: 'plugin-b',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.onGlobal('app-ready', (data) => {
+            globalEvents.push({ plugin: 'B', data });
+          });
+          
+          // Emit global event
+          scope.emitGlobal('app-ready', { status: 'ready' });
+        },
+      };
+
+      await pluginSystem.loadPlugin(pluginA, registry, true);
+      await pluginSystem.loadPlugin(pluginB, registry, true);
+
+      // Both plugins should receive the global event
+      expect(globalEvents).toHaveLength(2);
+      expect(globalEvents[0]).toEqual({ plugin: 'A', data: { status: 'ready' } });
+      expect(globalEvents[1]).toEqual({ plugin: 'B', data: { status: 'ready' } });
+    });
+  });
+
+  describe('Plugin Lifecycle', () => {
+    it('should cleanup plugin resources on unload', async () => {
+      const plugin = {
+        name: 'plugin-temp',
+        version: '1.0.0',
+        register: (scope: PluginScope) => {
+          scope.setState('data', { value: 123 });
+          scope.registerComponent('temp', () => 'Temp');
+        },
+      };
+
+      await pluginSystem.loadPlugin(plugin, registry, true);
+      
+      const scope = pluginSystem.getScope('plugin-temp');
+      expect(scope?.getState('data')).toEqual({ value: 123 });
+
+      await pluginSystem.unloadPlugin('plugin-temp');
+
+      // Scope should be cleaned up
+      expect(pluginSystem.getScope('plugin-temp')).toBeUndefined();
+    });
+
+    it('should call lifecycle hooks', async () => {
+      let loadCalled = false;
+      let unloadCalled = false;
+
+      const plugin = {
+        name: 'plugin-lifecycle',
+        version: '1.0.0',
+        register: () => {},
+        onLoad: async () => {
+          loadCalled = true;
+        },
+        onUnload: async () => {
+          unloadCalled = true;
+        },
+      };
+
+      await pluginSystem.loadPlugin(plugin, registry, true);
+      expect(loadCalled).toBe(true);
+
+      await pluginSystem.unloadPlugin('plugin-lifecycle');
+      expect(unloadCalled).toBe(true);
+    });
+  });
+
+  describe('Legacy Compatibility', () => {
+    it('should support legacy plugins without scopes', async () => {
+      const MockComponent = () => 'Legacy';
+
+      const legacyPlugin = {
+        name: 'legacy-plugin',
+        version: '1.0.0',
+        register: (reg: Registry) => {
+          reg.register('legacy', MockComponent);
+        },
+      };
+
+      // Load without scope
+      await pluginSystem.loadPlugin(legacyPlugin, registry, false);
+
+      // Component should be registered directly
+      const component = registry.getConfig('legacy');
+      expect(component?.component).toBe(MockComponent);
+    });
+  });
+});

package/src/types/index.ts

@@ -1,3 +1,11 @@
+/**
+ * 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;