microui-wc 0.1.0 → 0.1.2

package/tests/core/feature-registry.test.js

@@ -1,198 +0,0 @@
-/**
- * @fileoverview Tests for Feature Registry (Enterprise Features)
- * Tests createFeature, getFeatures, getFeature, getFeatureComponents, destroyFeature
- */
-
-import { describe, test, expect, beforeEach, beforeAll } from 'bun:test';
-
-let createFeature, getFeatures, getFeature, getFeatureComponents;
-let getFeatureRoutes, getFeatureByRoute, getFeatureByComponent;
-let destroyFeature, getFeatureSummary, clearFeatures, FeatureRegistry;
-
-describe('Feature Registry', () => {
-
-    beforeAll(async () => {
-        const module = await import('../../src/core/feature-registry.js');
-        createFeature = module.createFeature;
-        getFeatures = module.getFeatures;
-        getFeature = module.getFeature;
-        getFeatureComponents = module.getFeatureComponents;
-        getFeatureRoutes = module.getFeatureRoutes;
-        getFeatureByRoute = module.getFeatureByRoute;
-        getFeatureByComponent = module.getFeatureByComponent;
-        destroyFeature = module.destroyFeature;
-        getFeatureSummary = module.getFeatureSummary;
-        clearFeatures = module.clearFeatures;
-        FeatureRegistry = module.FeatureRegistry;
-    });
-
-    beforeEach(() => { clearFeatures(); });
-
-    // ========================================
-    // createFeature
-    // ========================================
-
-    test('createFeature creates feature with name', () => {
-        const f = createFeature('user', { routes: ['/user'] });
-        expect(f.name).toBe('user');
-    });
-
-    test('createFeature returns existing for same name', () => {
-        const f1 = createFeature('dup', {});
-        const f2 = createFeature('dup', { routes: ['/x'] });
-        expect(f1).toBe(f2);
-    });
-
-    test('createFeature with init calls init', () => {
-        let called = false;
-        createFeature('init-test', { init: () => { called = true; } });
-        expect(called).toBe(true);
-    });
-
-    test('createFeature with init sets initialized', () => {
-        const f = createFeature('init-flag', { init: () => { } });
-        expect(f.initialized).toBe(true);
-    });
-
-    test('createFeature sets registeredAt', () => {
-        const f = createFeature('time', {});
-        expect(typeof f.registeredAt).toBe('number');
-    });
-
-    test('createFeature handles init error', () => {
-        const f = createFeature('err', { init: () => { throw new Error('fail'); } });
-        expect(f.initialized).toBe(false);
-    });
-
-    // ========================================
-    // getFeatures / getFeature
-    // ========================================
-
-    test('getFeatures returns all features', () => {
-        createFeature('a', {});
-        createFeature('b', {});
-        const all = getFeatures();
-        expect(all.a).toBeDefined();
-        expect(all.b).toBeDefined();
-    });
-
-    test('getFeature returns feature by name', () => {
-        createFeature('single', { meta: { v: 1 } });
-        const f = getFeature('single');
-        expect(f.config.meta.v).toBe(1);
-    });
-
-    test('getFeature returns undefined for unknown', () => {
-        expect(getFeature('unknown')).toBeUndefined();
-    });
-
-    // ========================================
-    // getFeatureComponents / getFeatureRoutes
-    // ========================================
-
-    test('getFeatureComponents returns components', () => {
-        createFeature('comp', { components: ['mu-card', 'mu-form'] });
-        expect(getFeatureComponents('comp')).toEqual(['mu-card', 'mu-form']);
-    });
-
-    test('getFeatureRoutes returns routes', () => {
-        createFeature('route', { routes: ['/a', '/b'] });
-        expect(getFeatureRoutes('route')).toEqual(['/a', '/b']);
-    });
-
-    test('getFeatureComponents returns empty for unknown', () => {
-        expect(getFeatureComponents('nope')).toEqual([]);
-    });
-
-    test('getFeatureRoutes returns empty for unknown', () => {
-        expect(getFeatureRoutes('nope')).toEqual([]);
-    });
-
-    // ========================================
-    // getFeatureByRoute / getFeatureByComponent
-    // ========================================
-
-    test('getFeatureByRoute finds by route prefix', () => {
-        createFeature('admin', { routes: ['/admin'] });
-        const f = getFeatureByRoute('/admin/users');
-        expect(f.name).toBe('admin');
-    });
-
-    test('getFeatureByRoute returns null if no match', () => {
-        expect(getFeatureByRoute('/nonexistent')).toBeNull();
-    });
-
-    test('getFeatureByComponent finds by component tag', () => {
-        createFeature('widgets', { components: ['mu-widget'] });
-        const f = getFeatureByComponent('mu-widget');
-        expect(f.name).toBe('widgets');
-    });
-
-    test('getFeatureByComponent returns null if no match', () => {
-        expect(getFeatureByComponent('mu-unknown')).toBeNull();
-    });
-
-    // ========================================
-    // destroyFeature
-    // ========================================
-
-    test('destroyFeature removes feature', () => {
-        createFeature('destroy-test', {});
-        destroyFeature('destroy-test');
-        expect(getFeature('destroy-test')).toBeUndefined();
-    });
-
-    test('destroyFeature calls destroy callback', () => {
-        let called = false;
-        createFeature('destroy-cb', { destroy: () => { called = true; } });
-        destroyFeature('destroy-cb');
-        expect(called).toBe(true);
-    });
-
-    test('destroyFeature handles non-existent', () => {
-        destroyFeature('nope');
-        expect(true).toBe(true);
-    });
-
-    test('destroyFeature handles destroy error', () => {
-        createFeature('destroy-err', { destroy: () => { throw new Error('fail'); } });
-        destroyFeature('destroy-err');
-        expect(getFeature('destroy-err')).toBeUndefined();
-    });
-
-    // ========================================
-    // getFeatureSummary
-    // ========================================
-
-    test('getFeatureSummary returns summary object', () => {
-        createFeature('s1', { routes: ['/x'], components: ['a'], store: {} });
-        const summary = getFeatureSummary();
-        expect(summary.totalFeatures).toBe(1);
-        expect(summary.totalRoutes).toBe(1);
-        expect(summary.totalComponents).toBe(1);
-        expect(summary.features[0].hasStore).toBe(true);
-    });
-
-    // ========================================
-    // clearFeatures
-    // ========================================
-
-    test('clearFeatures removes all features', () => {
-        createFeature('a', {});
-        createFeature('b', {});
-        clearFeatures();
-        expect(Object.keys(getFeatures()).length).toBe(0);
-    });
-
-    // ========================================
-    // FeatureRegistry export
-    // ========================================
-
-    test('FeatureRegistry has all methods', () => {
-        expect(FeatureRegistry.createFeature).toBe(createFeature);
-        expect(FeatureRegistry.getFeatures).toBe(getFeatures);
-        expect(FeatureRegistry.clearFeatures).toBe(clearFeatures);
-        expect(FeatureRegistry.destroyFeature).toBe(destroyFeature);
-        expect(FeatureRegistry.getFeatureSummary).toBe(getFeatureSummary);
-    });
-});

package/tests/core/form-state.test.js

@@ -1,167 +0,0 @@
-/**
- * @fileoverview Unit Tests for form-state.js Module
- * Target: 84% → 95% coverage
- */
-
-import { describe, test, expect, beforeAll, beforeEach } from 'bun:test';
-import { parseHTML } from 'linkedom';
-
-let createFormState;
-
-describe('form-state Module Unit Tests', () => {
-
-    beforeAll(async () => {
-        const dom = parseHTML('<!DOCTYPE html><html><body></body></html>');
-        globalThis.document = dom.document;
-        globalThis.window = dom.window;
-        globalThis.HTMLElement = dom.HTMLElement;
-        globalThis.MutationObserver = class { observe() { } disconnect() { } };
-
-        const module = await import('../../src/core/form-state.js');
-        createFormState = module.createFormState;
-    });
-
-    beforeEach(() => {
-        globalThis.document.body.innerHTML = '';
-    });
-
-    // CREATE FORM STATE
-    test('createFormState should be a function', () => {
-        expect(typeof createFormState).toBe('function');
-    });
-
-    test('createFormState should return object', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state).toBe('object');
-    });
-
-    test('createFormState should have fields property', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(state.fields).toBeDefined();
-    });
-
-    test('createFormState should have isValid property', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.isValid).toBe('boolean');
-    });
-
-    test('createFormState should have isDirty property', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.isDirty).toBe('boolean');
-    });
-
-    test('createFormState should have isSubmitting property', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.isSubmitting).toBe('boolean');
-    });
-
-    test('createFormState should have getValues method', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.getValues).toBe('function');
-    });
-
-    test('createFormState should have getErrors method', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.getErrors).toBe('function');
-    });
-
-    test('createFormState should have reset method', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.reset).toBe('function');
-    });
-
-    test('createFormState should have validate method', () => {
-        const form = globalThis.document.createElement('form');
-        const state = createFormState(form, {});
-        expect(typeof state.validate).toBe('function');
-    });
-
-    // WITH SCHEMA
-    test('should create field from schema', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: { required: true } });
-        expect(state.fields.email).toBeDefined();
-    });
-
-    test('field should have value property', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="test@example.com">';
-        const state = createFormState(form, { email: {} });
-        expect(state.fields.email.value).toBe('test@example.com');
-    });
-
-    test('field should have error property', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: { required: true } });
-        expect(state.fields.email.error).toBeDefined();
-    });
-
-    test('field should have touched property', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: {} });
-        expect(state.fields.email.touched).toBe(false);
-    });
-
-    test('field should have dirty property', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: {} });
-        expect(state.fields.email.dirty).toBe(false);
-    });
-
-    // VALIDATION
-    test('isValid should be true for valid form', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="test@example.com">';
-        const state = createFormState(form, { email: { type: 'email' } });
-        expect(state.isValid).toBe(true);
-    });
-
-    test('isValid should be false for invalid form', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: { required: true } });
-        expect(state.isValid).toBe(false);
-    });
-
-    // METHODS
-    test('getValues should return all values', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="test@example.com">';
-        const state = createFormState(form, { email: {} });
-        expect(state.getValues().email).toBe('test@example.com');
-    });
-
-    test('getErrors should return all errors', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="">';
-        const state = createFormState(form, { email: { required: true } });
-        expect(state.getErrors().email).toBeDefined();
-    });
-
-    test('reset should clear values', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="test@example.com">';
-        const state = createFormState(form, { email: {} });
-        state.reset();
-        expect(state.isDirty).toBe(false);
-    });
-
-    test('validate should return boolean', () => {
-        const form = globalThis.document.createElement('form');
-        form.innerHTML = '<input name="email" value="test@example.com">';
-        const state = createFormState(form, { email: {} });
-        expect(typeof state.validate()).toBe('boolean');
-    });
-});

package/tests/core/http.test.js

@@ -1,119 +0,0 @@
-/**
- * @fileoverview Unit Tests for http.js Module
- * Target: 21% → 80% coverage
- */
-
-import { describe, test, expect, beforeAll, beforeEach, mock } from 'bun:test';
-import { http, HttpError } from '../../src/core/http.js';
-
-describe('http Module Unit Tests', () => {
-
-    beforeEach(() => {
-        // Reset state
-        http.baseURL = '';
-        http.headers = { 'Content-Type': 'application/json' };
-    });
-
-    // HTTP OBJECT
-    test('http should exist', () => {
-        expect(http).toBeDefined();
-    });
-
-    test('http should have baseURL property', () => {
-        expect(http.baseURL).toBe('');
-    });
-
-    test('http should have headers property', () => {
-        expect(http.headers['Content-Type']).toBe('application/json');
-    });
-
-    // SET BASE URL
-    test('setBaseURL should set baseURL', () => {
-        http.setBaseURL('https://api.example.com');
-        expect(http.baseURL).toBe('https://api.example.com');
-    });
-
-    // SET HEADER
-    test('setHeader should add header', () => {
-        http.setHeader('Authorization', 'Bearer token123');
-        expect(http.headers['Authorization']).toBe('Bearer token123');
-    });
-
-    test('setHeader should overwrite existing header', () => {
-        http.setHeader('Content-Type', 'text/plain');
-        expect(http.headers['Content-Type']).toBe('text/plain');
-    });
-
-    // HTTP METHODS
-    test('get should be a function', () => {
-        expect(typeof http.get).toBe('function');
-    });
-
-    test('post should be a function', () => {
-        expect(typeof http.post).toBe('function');
-    });
-
-    test('put should be a function', () => {
-        expect(typeof http.put).toBe('function');
-    });
-
-    test('delete should be a function', () => {
-        expect(typeof http.delete).toBe('function');
-    });
-
-    test('request should be a function', () => {
-        expect(typeof http.request).toBe('function');
-    });
-
-    // HTTP ERROR CLASS
-    test('HttpError should be a class', () => {
-        expect(HttpError).toBeDefined();
-    });
-
-    test('HttpError should extend Error', () => {
-        const err = new HttpError(404, 'Not Found', 'Resource not found');
-        expect(err instanceof Error).toBe(true);
-    });
-
-    test('HttpError should have status property', () => {
-        const err = new HttpError(500, 'Internal Server Error', 'body');
-        expect(err.status).toBe(500);
-    });
-
-    test('HttpError should have statusText property', () => {
-        const err = new HttpError(403, 'Forbidden', 'body');
-        expect(err.statusText).toBe('Forbidden');
-    });
-
-    test('HttpError should have body property', () => {
-        const err = new HttpError(400, 'Bad Request', 'Invalid data');
-        expect(err.body).toBe('Invalid data');
-    });
-
-    test('HttpError message should be formatted', () => {
-        const err = new HttpError(401, 'Unauthorized', 'body');
-        expect(err.message).toBe('HTTP 401: Unauthorized');
-    });
-
-    test('HttpError should be throwable', () => {
-        expect(() => { throw new HttpError(500, 'Error', 'body'); }).toThrow();
-    });
-
-    // REQUEST METHOD SIGNATURES
-    test('get should accept url and options', () => {
-        // Just verify it doesn't throw on call signature
-        expect(() => http.get).not.toThrow();
-    });
-
-    test('post should accept url, body and options', () => {
-        expect(() => http.post).not.toThrow();
-    });
-
-    test('put should accept url, body and options', () => {
-        expect(() => http.put).not.toThrow();
-    });
-
-    test('delete should accept url and options', () => {
-        expect(() => http.delete).not.toThrow();
-    });
-});