microui-wc 0.1.0

package/tests/core/bus.test.js

@@ -0,0 +1,364 @@
+/**
+ * @fileoverview Unit Tests for bus.js Module
+ * Target: 57% → 90% coverage
+ */
+
+import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
+import {
+    bus,
+    UIEvents,
+    showToast,
+    MICROUI_VERSION,
+    isDebugEnabled,
+    enableDebug,
+    disableDebug,
+    getHealth,
+    getCapabilities,
+    addInboundHook,
+    addOutboundHook,
+    registerComponent,
+    unregisterComponent,
+    getComponentCapabilities,
+    getRegisteredComponents,
+    getComponentsForSignal
+} from '../../src/core/bus.js';
+
+describe('bus Module Unit Tests', () => {
+
+    // BUS OBJECT
+    test('bus should exist', () => {
+        expect(bus).toBeDefined();
+    });
+
+    // METHODS
+    test('bus.on should be a function', () => {
+        expect(typeof bus.on).toBe('function');
+    });
+
+    test('bus.once should be a function', () => {
+        expect(typeof bus.once).toBe('function');
+    });
+
+    test('bus.off should be a function', () => {
+        expect(typeof bus.off).toBe('function');
+    });
+
+    test('bus.emit should be a function', () => {
+        expect(typeof bus.emit).toBe('function');
+    });
+
+    test('bus.emitAsync should be a function', () => {
+        expect(typeof bus.emitAsync).toBe('function');
+    });
+
+    test('bus.signal should be a function', () => {
+        expect(typeof bus.signal).toBe('function');
+    });
+
+    test('bus.request should be a function', () => {
+        expect(typeof bus.request).toBe('function');
+    });
+
+    test('bus.broadcastRequest should be a function', () => {
+        expect(typeof bus.broadcastRequest).toBe('function');
+    });
+
+    test('bus.handle should be a function', () => {
+        expect(typeof bus.handle).toBe('function');
+    });
+
+    test('bus.unhandle should be a function', () => {
+        expect(typeof bus.unhandle).toBe('function');
+    });
+
+    test('bus.destroy should be a function', () => {
+        expect(typeof bus.destroy).toBe('function');
+    });
+
+    test('bus.setMaxListeners should be a function', () => {
+        expect(typeof bus.setMaxListeners).toBe('function');
+    });
+
+    test('bus.hasListeners should be a function', () => {
+        expect(typeof bus.hasListeners).toBe('function');
+    });
+
+    // PROPERTIES
+    test('bus.peerId should be microui', () => {
+        expect(bus.peerId).toBe('microui');
+    });
+
+    test('bus.raw should return CrossBus instance', () => {
+        expect(bus.raw).toBeDefined();
+    });
+
+    test('bus.peers should be defined', () => {
+        expect(bus.peers).toBeDefined();
+    });
+
+    test('bus.peerCount should be a number', () => {
+        expect(typeof bus.peerCount).toBe('number');
+    });
+
+    // SUBSCRIPTION
+    test('on should return unsubscribe function', () => {
+        const unsub = bus.on('test-event', () => { });
+        expect(typeof unsub).toBe('function');
+        unsub();
+    });
+
+    test('emit should work', () => {
+        let received = null;
+        const unsub = bus.on('test-emit', (data) => { received = data; });
+        bus.emit('test-emit', { value: 42 });
+        unsub();
+        expect(received).toEqual({ value: 42 });
+    });
+
+    test('once should only trigger once', () => {
+        let count = 0;
+        bus.once('test-once', () => { count++; });
+        bus.emit('test-once', {});
+        bus.emit('test-once', {});
+        expect(count).toBe(1);
+    });
+
+    test('hasListeners should return boolean', () => {
+        const unsub = bus.on('test-has-listeners', () => { });
+        expect(bus.hasListeners('test-has-listeners')).toBe(true);
+        unsub();
+    });
+
+    test('off should work', () => {
+        const callback = () => { };
+        bus.on('test-off', callback);
+        bus.off('test-off', callback);
+        expect(true).toBe(true);
+    });
+
+    test('signal should work', () => {
+        bus.signal('test-signal', { data: 'test' });
+        expect(true).toBe(true);
+    });
+
+    test('handle should register handler', () => {
+        const handler = bus.handle('test-handler', () => ({ result: 'ok' }));
+        expect(handler).toBeDefined();
+        bus.unhandle('test-handler');
+    });
+
+    test('unhandle should work', () => {
+        bus.handle('test-unhandle', () => { });
+        bus.unhandle('test-unhandle');
+        expect(true).toBe(true);
+    });
+
+    test('setMaxListeners should work', () => {
+        bus.setMaxListeners(200);
+        expect(true).toBe(true);
+    });
+
+    // UI EVENTS
+    test('UIEvents should have TOAST_SHOW', () => {
+        expect(UIEvents.TOAST_SHOW).toBe('ui:toast:show');
+    });
+
+    test('UIEvents should have TOAST_DISMISS', () => {
+        expect(UIEvents.TOAST_DISMISS).toBe('ui:toast:dismiss');
+    });
+
+    test('UIEvents should have MODAL_OPEN', () => {
+        expect(UIEvents.MODAL_OPEN).toBe('ui:modal:open');
+    });
+
+    test('UIEvents should have MODAL_CLOSE', () => {
+        expect(UIEvents.MODAL_CLOSE).toBe('ui:modal:close');
+    });
+
+    test('UIEvents should have THEME_CHANGE', () => {
+        expect(UIEvents.THEME_CHANGE).toBe('ui:theme:change');
+    });
+
+    test('UIEvents should have TAB_CHANGE', () => {
+        expect(UIEvents.TAB_CHANGE).toBe('ui:tab:change');
+    });
+
+    test('UIEvents should have DROPDOWN_SELECT', () => {
+        expect(UIEvents.DROPDOWN_SELECT).toBe('ui:dropdown:select');
+    });
+
+    test('UIEvents should have FORM_SUBMIT', () => {
+        expect(UIEvents.FORM_SUBMIT).toBe('ui:form:submit');
+    });
+
+    test('UIEvents should have FORM_VALIDATE', () => {
+        expect(UIEvents.FORM_VALIDATE).toBe('ui:form:validate');
+    });
+
+    // SHOW TOAST HELPER
+    test('showToast should be a function', () => {
+        expect(typeof showToast).toBe('function');
+    });
+
+    test('showToast should emit toast event', () => {
+        let toastData = null;
+        const unsub = bus.on(UIEvents.TOAST_SHOW, (data) => { toastData = data; });
+        showToast('Hello World', { type: 'success' });
+        unsub();
+        expect(toastData.message).toBe('Hello World');
+        expect(toastData.type).toBe('success');
+    });
+
+    // ========================================================================
+    // AI AGENT FEATURES (CrossBus)
+    // ========================================================================
+
+    test('MICROUI_VERSION should be defined', () => {
+        expect(MICROUI_VERSION).toBeDefined();
+        expect(typeof MICROUI_VERSION).toBe('string');
+        expect(MICROUI_VERSION).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+
+    test('enableDebug should be a function', () => {
+        expect(typeof enableDebug).toBe('function');
+    });
+
+    test('disableDebug should be a function', () => {
+        expect(typeof disableDebug).toBe('function');
+    });
+
+    test('isDebugEnabled should be a function', () => {
+        expect(typeof isDebugEnabled).toBe('function');
+    });
+
+    test('isDebugEnabled should return boolean', () => {
+        const result = isDebugEnabled();
+        expect(typeof result).toBe('boolean');
+    });
+
+    test('enableDebug should return boolean (deprecated)', () => {
+        // enableDebug now returns the current state and logs a warning
+        const result = enableDebug();
+        expect(typeof result).toBe('boolean');
+    });
+
+    test('getHealth should be a function', () => {
+        expect(typeof getHealth).toBe('function');
+    });
+
+    test('getHealth should return health object', () => {
+        const health = getHealth();
+        expect(health).toBeDefined();
+        expect(typeof health).toBe('object');
+        // Should have at least peerId
+        expect(health.peerId || health.note).toBeDefined();
+    });
+
+    test('getCapabilities should be a function', () => {
+        expect(typeof getCapabilities).toBe('function');
+    });
+
+    test('getCapabilities should return capabilities object', () => {
+        const caps = getCapabilities();
+        expect(caps.peerId).toBe('microui');
+        expect(Array.isArray(caps.capabilities)).toBe(true);
+        expect(caps.capabilities.length).toBeGreaterThan(0);
+        expect(caps.capabilities).toContain('ui:toast');
+        expect(caps.meta).toBeDefined();
+        expect(caps.meta.type).toBe('ui-framework');
+        expect(caps.version).toBe(MICROUI_VERSION);
+    });
+
+    test('addInboundHook should be a function', () => {
+        expect(typeof addInboundHook).toBe('function');
+    });
+
+    test('addOutboundHook should be a function', () => {
+        expect(typeof addOutboundHook).toBe('function');
+    });
+
+    test('addInboundHook should return unsubscribe function', () => {
+        const removeHook = addInboundHook((payload) => payload);
+        expect(typeof removeHook).toBe('function');
+        removeHook();
+    });
+
+    test('addOutboundHook should return unsubscribe function', () => {
+        const removeHook = addOutboundHook((payload) => payload);
+        expect(typeof removeHook).toBe('function');
+        removeHook();
+    });
+
+    // ========================================================================
+    // COMPONENT CAPABILITY REGISTRATION (Phase 2)
+    // ========================================================================
+
+    test('registerComponent should be a function', () => {
+        expect(typeof registerComponent).toBe('function');
+    });
+
+    test('unregisterComponent should be a function', () => {
+        expect(typeof unregisterComponent).toBe('function');
+    });
+
+    test('getComponentCapabilities should be a function', () => {
+        expect(typeof getComponentCapabilities).toBe('function');
+    });
+
+    test('getRegisteredComponents should be a function', () => {
+        expect(typeof getRegisteredComponents).toBe('function');
+    });
+
+    test('getComponentsForSignal should be a function', () => {
+        expect(typeof getComponentsForSignal).toBe('function');
+    });
+
+    test('registerComponent should register a component', () => {
+        registerComponent('mu-test-component', {
+            signals: ['ui:test:signal'],
+            options: { foo: 'bar' }
+        });
+        const caps = getComponentCapabilities('mu-test-component');
+        expect(caps).not.toBeNull();
+        expect(caps.signals).toContain('ui:test:signal');
+        expect(caps.options.foo).toBe('bar');
+        expect(caps.registeredAt).toBeDefined();
+        unregisterComponent('mu-test-component');
+    });
+
+    test('unregisterComponent should remove a component', () => {
+        registerComponent('mu-temp-component', { signals: [] });
+        unregisterComponent('mu-temp-component');
+        expect(getComponentCapabilities('mu-temp-component')).toBeNull();
+    });
+
+    test('getRegisteredComponents should return all registered components', () => {
+        registerComponent('mu-comp-a', { signals: ['sig:a'] });
+        registerComponent('mu-comp-b', { signals: ['sig:b'] });
+        const all = getRegisteredComponents();
+        expect(all['mu-comp-a']).toBeDefined();
+        expect(all['mu-comp-b']).toBeDefined();
+        unregisterComponent('mu-comp-a');
+        unregisterComponent('mu-comp-b');
+    });
+
+    test('getComponentsForSignal should find handlers', () => {
+        registerComponent('mu-handler-1', { signals: ['ui:shared:signal'] });
+        registerComponent('mu-handler-2', { signals: ['ui:shared:signal', 'ui:other'] });
+        registerComponent('mu-unrelated', { signals: ['ui:different'] });
+
+        const handlers = getComponentsForSignal('ui:shared:signal');
+        expect(handlers).toContain('mu-handler-1');
+        expect(handlers).toContain('mu-handler-2');
+        expect(handlers).not.toContain('mu-unrelated');
+
+        unregisterComponent('mu-handler-1');
+        unregisterComponent('mu-handler-2');
+        unregisterComponent('mu-unrelated');
+    });
+
+    test('getComponentCapabilities should return null for unknown component', () => {
+        expect(getComponentCapabilities('mu-nonexistent')).toBeNull();
+    });
+});
+

package/tests/core/component-schema.test.js

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Tests for Component Schema API (2026 Features)
+ * Tests getComponentSchema, getAllSchemas, getSchemaComponents, getSchemaQuickRef
+ */
+
+import { describe, test, expect } from 'bun:test';
+
+describe('Component Schema API', () => {
+    describe('getComponentSchema', () => {
+        test('should export getComponentSchema function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.getComponentSchema).toBe('function');
+        });
+
+        test('should return schema for mu-button', async () => {
+            const { getComponentSchema } = await import('../../src/core/component-schema.js');
+            const schema = getComponentSchema('mu-button');
+
+            expect(schema).not.toBeNull();
+            expect(schema.title).toBe('mu-button');
+            expect(schema.type).toBe('object');
+        });
+
+        test('should include properties with types', async () => {
+            const { getComponentSchema } = await import('../../src/core/component-schema.js');
+            const schema = getComponentSchema('mu-button');
+
+            expect(schema.properties).toBeDefined();
+            expect(schema.properties.variant).toBeDefined();
+            expect(schema.properties.variant.type).toBe('string');
+            expect(Array.isArray(schema.properties.variant.enum)).toBe(true);
+        });
+
+        test('should include actions array', async () => {
+            const { getComponentSchema } = await import('../../src/core/component-schema.js');
+            const schema = getComponentSchema('mu-button');
+
+            expect(Array.isArray(schema.actions)).toBe(true);
+            expect(schema.actions).toContain('click');
+        });
+
+        test('should return null for unknown component', async () => {
+            const { getComponentSchema } = await import('../../src/core/component-schema.js');
+            const schema = getComponentSchema('mu-nonexistent');
+
+            expect(schema).toBeNull();
+        });
+    });
+
+    describe('getAllSchemas', () => {
+        test('should export getAllSchemas function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.getAllSchemas).toBe('function');
+        });
+
+        test('should return a Map', async () => {
+            const { getAllSchemas } = await import('../../src/core/component-schema.js');
+            const schemas = getAllSchemas();
+
+            expect(schemas instanceof Map).toBe(true);
+        });
+
+        test('should contain multiple components', async () => {
+            const { getAllSchemas } = await import('../../src/core/component-schema.js');
+            const schemas = getAllSchemas();
+
+            expect(schemas.size).toBeGreaterThan(5);
+            expect(schemas.has('mu-button')).toBe(true);
+            expect(schemas.has('mu-input')).toBe(true);
+        });
+    });
+
+    describe('getSchemaComponents', () => {
+        test('should export getSchemaComponents function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.getSchemaComponents).toBe('function');
+        });
+
+        test('should return array of tag names', async () => {
+            const { getSchemaComponents } = await import('../../src/core/component-schema.js');
+            const components = getSchemaComponents();
+
+            expect(Array.isArray(components)).toBe(true);
+            expect(components).toContain('mu-button');
+            expect(components).toContain('mu-input');
+            expect(components).toContain('mu-checkbox');
+        });
+    });
+
+    describe('getSchemaQuickRef', () => {
+        test('should export getSchemaQuickRef function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.getSchemaQuickRef).toBe('function');
+        });
+
+        test('should return minimal summary', async () => {
+            const { getSchemaQuickRef } = await import('../../src/core/component-schema.js');
+            const ref = getSchemaQuickRef('mu-button');
+
+            expect(ref).not.toBeNull();
+            expect(ref.tag).toBe('mu-button');
+            expect(ref.description).toBeDefined();
+            expect(Array.isArray(ref.properties)).toBe(true);
+            expect(Array.isArray(ref.actions)).toBe(true);
+        });
+
+        test('should return null for unknown component', async () => {
+            const { getSchemaQuickRef } = await import('../../src/core/component-schema.js');
+            const ref = getSchemaQuickRef('mu-fake');
+
+            expect(ref).toBeNull();
+        });
+    });
+
+    describe('getSchemas (batch)', () => {
+        test('should export getSchemas function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.getSchemas).toBe('function');
+        });
+
+        test('should return multiple schemas at once', async () => {
+            const { getSchemas } = await import('../../src/core/component-schema.js');
+            const schemas = getSchemas(['mu-button', 'mu-input', 'mu-checkbox']);
+
+            expect(Object.keys(schemas).length).toBe(3);
+            expect(schemas['mu-button']).toBeDefined();
+            expect(schemas['mu-input']).toBeDefined();
+        });
+    });
+
+    describe('exportSchemasAsJSON', () => {
+        test('should export exportSchemasAsJSON function', async () => {
+            const module = await import('../../src/core/component-schema.js');
+            expect(typeof module.exportSchemasAsJSON).toBe('function');
+        });
+
+        test('should return valid JSON string', async () => {
+            const { exportSchemasAsJSON } = await import('../../src/core/component-schema.js');
+            const json = exportSchemasAsJSON();
+
+            expect(typeof json).toBe('string');
+            expect(() => JSON.parse(json)).not.toThrow();
+
+            const parsed = JSON.parse(json);
+            expect(parsed['mu-button']).toBeDefined();
+        });
+    });
+
+    describe('ComponentSchema namespace', () => {
+        test('should export ComponentSchema object with all methods', async () => {
+            const { ComponentSchema } = await import('../../src/core/component-schema.js');
+
+            expect(typeof ComponentSchema.getComponentSchema).toBe('function');
+            expect(typeof ComponentSchema.getAllSchemas).toBe('function');
+            expect(typeof ComponentSchema.getSchemaComponents).toBe('function');
+            expect(typeof ComponentSchema.getSchemaQuickRef).toBe('function');
+            expect(typeof ComponentSchema.exportSchemasAsJSON).toBe('function');
+        });
+    });
+});