microui-wc 0.1.1 → 0.1.2

package/tests/core/bus.test.js

@@ -1,364 +0,0 @@
-/**
- * @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

@@ -1,160 +0,0 @@
-/**
- * @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');
-        });
-    });
-});