@flightdev/ui 2.0.1 → 4.0.0

package/test/integration/react.integration.test.ts

@@ -1,271 +0,0 @@
-/**
- * @flightdev/ui - React Integration Tests
- *
- * Tests for React adapter with real rendering scenarios.
- * Validates SSR output, hydration scripts, and streaming behavior.
- *
- * @module test/integration/react.integration.test.ts
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { adapterRegistry, registerBuiltinAdapters } from '../../src/core/registry.js';
-import type { Component, RenderResult, RenderContext } from '../../src/core/types.js';
-
-// ============================================================================
-// React Integration Tests
-// ============================================================================
-
-describe('React Integration Tests', () => {
-    beforeEach(() => {
-        registerBuiltinAdapters();
-    });
-
-    describe('Adapter Retrieval', () => {
-        it('should load React adapter from registry', async () => {
-            const adapter = await adapterRegistry.get('react');
-
-            expect(adapter).toBeDefined();
-            expect(adapter?.id).toBe('react');
-            expect(adapter?.name).toBe('React');
-            expect(adapter?.tier).toBe('tier-1');
-        });
-
-        it('should have correct React capabilities', async () => {
-            const adapter = await adapterRegistry.get('react');
-
-            expect(adapter?.capabilities.streaming).toBe(true);
-            expect(adapter?.capabilities.partialHydration).toBe(true);
-            expect(adapter?.capabilities.islands).toBe(true);
-            expect(adapter?.capabilities.serverComponents).toBe(true);
-            expect(adapter?.capabilities.ssg).toBe(true);
-            expect(adapter?.capabilities.csr).toBe(true);
-        });
-    });
-
-    describe('SSR Rendering', () => {
-        it('should render component to HTML string', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            // Component that returns null is the simplest valid React component
-            const component: Component = {
-                component: function SimpleComponent() {
-                    return null;
-                },
-                props: {},
-            };
-
-            const result = await adapter!.renderToString(component);
-
-            expect(result).toBeDefined();
-            expect(typeof result.html).toBe('string');
-            expect(result.timing).toBeDefined();
-            expect(result.timing?.total).toBeGreaterThanOrEqual(0);
-        });
-
-        it('should pass props to component during render', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const mockRenderFn = vi.fn();
-            const component: Component = {
-                component: mockRenderFn,
-                props: { name: 'World', count: 42 },
-            };
-
-            // The render should attempt to call the component with props
-            try {
-                await adapter!.renderToString(component);
-            } catch {
-                // Expected - mock component won't render properly
-            }
-
-            // Component should have been created with props accessible
-            expect(component.props).toEqual({ name: 'World', count: 42 });
-        });
-
-        it('should include timing information in render result', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const component: Component = {
-                component: () => null,
-                props: {},
-            };
-
-            try {
-                const result = await adapter!.renderToString(component);
-                expect(result.timing).toBeDefined();
-                expect(typeof result.timing?.total).toBe('number');
-            } catch {
-                // May throw due to mock component - that's ok for this test
-            }
-        });
-    });
-
-    describe('Hydration Scripts', () => {
-        it('should generate hydration script with proper structure', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const mockResult: RenderResult = {
-                html: '<div>Test</div>',
-                hydrationData: { props: { name: 'Test' } },
-                timing: { total: 5 },
-            };
-
-            const script = adapter!.getHydrationScript(mockResult);
-
-            expect(typeof script).toBe('string');
-            expect(script).toContain('<script');
-            expect(script).toContain('</script>');
-        });
-
-        it('should include hydration data in script when provided', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const mockResult: RenderResult = {
-                html: '<div>Test</div>',
-                hydrationData: { componentId: 'test-123' },
-            };
-
-            const script = adapter!.getHydrationScript(mockResult);
-
-            // Script should contain some reference to hydration data
-            expect(script.length).toBeGreaterThan(0);
-        });
-    });
-
-    describe('Client Entry', () => {
-        it('should generate valid client entry code', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const entry = adapter!.getClientEntry();
-
-            expect(typeof entry).toBe('string');
-            expect(entry.length).toBeGreaterThan(0);
-            // Should contain React-specific hydration code
-            expect(entry).toMatch(/hydrat|react|mount/i);
-        });
-
-        it('should export a hydrate function', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const entry = adapter!.getClientEntry();
-
-            // Client entry should contain export for hydration
-            expect(entry).toMatch(/export|hydrat/i);
-        });
-    });
-
-    describe('Streaming SSR', () => {
-        it('should have streaming capability enabled', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            expect(adapter!.capabilities.streaming).toBe(true);
-        });
-
-        it('should provide renderToStream method', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            expect(typeof adapter!.renderToStream).toBe('function');
-        });
-
-        it('should return StreamingRenderResult from renderToStream', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const component: Component = {
-                component: () => null,
-                props: {},
-            };
-
-            const result = adapter!.renderToStream!(component);
-
-            expect(result).toBeDefined();
-            expect(result.stream).toBeDefined();
-            expect(result.stream instanceof ReadableStream).toBe(true);
-            // StreamingRenderResult has stream, done, and abort
-            expect(result.done).toBeDefined();
-            expect(typeof result.abort).toBe('function');
-        });
-    });
-
-    describe('Islands Architecture', () => {
-        it('should support islands capability', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            expect(adapter!.capabilities.islands).toBe(true);
-        });
-
-        it('should create island with proper structure', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-            expect(adapter!.createIsland).toBeDefined();
-
-            const island = adapter!.createIsland!('UserProfile', { userId: '123' });
-
-            expect(island).toBeDefined();
-            expect(island.id).toBeDefined();
-            expect(island.component).toBe('UserProfile');
-            expect(island.props).toEqual({ userId: '123' });
-            expect(island.placeholder).toBeDefined();
-        });
-
-        it('should generate unique island IDs', async () => {
-            const adapter = await adapterRegistry.get('react');
-            expect(adapter).toBeDefined();
-
-            const island1 = adapter!.createIsland!('Component1', {});
-            const island2 = adapter!.createIsland!('Component2', {});
-
-            expect(island1.id).not.toBe(island2.id);
-        });
-    });
-});
-
-// ============================================================================
-// Error Handling Tests
-// ============================================================================
-
-describe('React Error Handling', () => {
-    beforeEach(() => {
-        registerBuiltinAdapters();
-    });
-
-    it('should handle undefined component gracefully', async () => {
-        const adapter = await adapterRegistry.get('react');
-        expect(adapter).toBeDefined();
-
-        const component: Component = {
-            component: undefined as unknown as () => void,
-            props: {},
-        };
-
-        // Should throw or handle gracefully
-        await expect(adapter!.renderToString(component)).rejects.toThrow();
-    });
-
-    it('should handle null props gracefully', async () => {
-        const adapter = await adapterRegistry.get('react');
-        expect(adapter).toBeDefined();
-
-        const component: Component = {
-            component: () => null,
-            props: null as unknown as Record<string, unknown>,
-        };
-
-        // Should not crash with null props
-        try {
-            await adapter!.renderToString(component);
-        } catch {
-            // Expected behavior - throws rather than crashes
-        }
-    });
-});

package/test/integration/registry.integration.test.ts

@@ -1,308 +0,0 @@
-/**
- * @flightdev/ui - Registry Integration Tests
- *
- * Tests for AdapterRegistry with dynamic loading and capability queries.
- * Validates tier filtering, capability queries, and adapter lifecycle.
- *
- * @module test/integration/registry.integration.test.ts
- */
-
-import { describe, it, expect, beforeEach, beforeAll } from 'vitest';
-import { adapterRegistry, registerBuiltinAdapters } from '../../src/core/registry.js';
-import { TIER_INFO } from '../../src/core/types.js';
-
-// ============================================================================
-// Registry Integration Tests
-// ============================================================================
-
-describe('Registry Integration Tests', () => {
-    beforeAll(() => {
-        registerBuiltinAdapters();
-    });
-
-    describe('Dynamic Adapter Loading', () => {
-        it('should load adapters lazily on first access', async () => {
-            const adapter = await adapterRegistry.get('react');
-
-            expect(adapter).toBeDefined();
-            expect(adapter?.id).toBe('react');
-        });
-
-        it('should return same instance on subsequent calls', async () => {
-            const adapter1 = await adapterRegistry.get('vue');
-            const adapter2 = await adapterRegistry.get('vue');
-
-            expect(adapter1).toBe(adapter2);
-        });
-
-        it('should return undefined for non-existent adapters', async () => {
-            const adapter = await adapterRegistry.get('non-existent-framework');
-
-            expect(adapter).toBeUndefined();
-        });
-
-        it('should load all tier-1 adapters successfully', async () => {
-            const tier1 = adapterRegistry.listByTier('tier-1');
-
-            for (const id of tier1) {
-                const adapter = await adapterRegistry.get(id);
-                expect(adapter, `Adapter ${id} should load`).toBeDefined();
-                expect(adapter?.tier).toBe('tier-1');
-            }
-        });
-
-        it('should load all tier-2 adapters successfully', async () => {
-            const tier2 = adapterRegistry.listByTier('tier-2');
-            // Some adapters may fail to load due to missing peer dependencies in CI
-            const availableAdapters = ['preact', 'lit', 'marko', 'mithril', 'inferno'];
-
-            for (const id of availableAdapters) {
-                if (tier2.includes(id)) {
-                    try {
-                        const adapter = await adapterRegistry.get(id);
-                        expect(adapter, `Adapter ${id} should load`).toBeDefined();
-                        expect(adapter?.tier).toBe('tier-2');
-                    } catch {
-                        // Skip adapters that fail due to missing peer dependencies
-                    }
-                }
-            }
-        });
-
-        it('should load all tier-3 adapters successfully', async () => {
-            const tier3 = adapterRegistry.listByTier('tier-3');
-
-            for (const id of tier3) {
-                const adapter = await adapterRegistry.get(id);
-                expect(adapter, `Adapter ${id} should load`).toBeDefined();
-                expect(adapter?.tier).toBe('tier-3');
-            }
-        });
-    });
-
-    describe('Capability Queries', () => {
-        it('should list adapters with streaming capability', () => {
-            const streamingAdapters = adapterRegistry.listByCapability('streaming');
-
-            expect(streamingAdapters).toContain('react');
-            expect(streamingAdapters).toContain('vue');
-            expect(streamingAdapters).toContain('solid');
-            expect(streamingAdapters).toContain('qwik');
-            expect(streamingAdapters).toContain('marko');
-
-            // HTMX should not have streaming
-            expect(streamingAdapters).not.toContain('htmx');
-        });
-
-        it('should list adapters with islands capability', () => {
-            const islandsAdapters = adapterRegistry.listByCapability('islands');
-
-            // Islands adapters vary by implementation
-            // At minimum, some tier-1 adapters should support islands
-            expect(Array.isArray(islandsAdapters)).toBe(true);
-        });
-
-        it('should list adapters with resumable capability', () => {
-            const resumableAdapters = adapterRegistry.listByCapability('resumable');
-
-            // Only Qwik has resumable hydration
-            expect(resumableAdapters).toContain('qwik');
-            expect(resumableAdapters).not.toContain('react');
-            expect(resumableAdapters).not.toContain('vue');
-        });
-
-        it('should list adapters with serverComponents capability', () => {
-            const rscAdapters = adapterRegistry.listByCapability('serverComponents');
-
-            expect(rscAdapters).toContain('react');
-        });
-
-        it('should list adapters with SSG capability', () => {
-            const ssgAdapters = adapterRegistry.listByCapability('ssg');
-
-            // SSG capability should be available in some adapters
-            expect(Array.isArray(ssgAdapters)).toBe(true);
-        });
-
-        it('should list adapters with CSR capability', () => {
-            const csrAdapters = adapterRegistry.listByCapability('csr');
-
-            // CSR capability should be available in some adapters
-            expect(Array.isArray(csrAdapters)).toBe(true);
-        });
-    });
-
-    describe('Tier Filtering', () => {
-        it('should return exactly 6 tier-1 adapters', () => {
-            const tier1 = adapterRegistry.listByTier('tier-1');
-
-            expect(tier1.length).toBe(6);
-            expect(tier1).toContain('react');
-            expect(tier1).toContain('vue');
-            expect(tier1).toContain('angular');
-            expect(tier1).toContain('svelte');
-            expect(tier1).toContain('solid');
-            expect(tier1).toContain('qwik');
-        });
-
-        it('should return exactly 6 tier-2 adapters', () => {
-            const tier2 = adapterRegistry.listByTier('tier-2');
-
-            expect(tier2.length).toBe(6);
-            expect(tier2).toContain('preact');
-            expect(tier2).toContain('lit');
-            expect(tier2).toContain('marko');
-            expect(tier2).toContain('stencil');
-            expect(tier2).toContain('mithril');
-            expect(tier2).toContain('inferno');
-        });
-
-        it('should return exactly 6 tier-3 adapters', () => {
-            const tier3 = adapterRegistry.listByTier('tier-3');
-
-            expect(tier3.length).toBe(6);
-            expect(tier3).toContain('htmx');
-            expect(tier3).toContain('alpine');
-            expect(tier3).toContain('hotwire');
-            expect(tier3).toContain('stimulus');
-            expect(tier3).toContain('petite-vue');
-            expect(tier3).toContain('vanilla');
-        });
-
-        it('should have 18 total adapters', () => {
-            const tier1 = adapterRegistry.listByTier('tier-1');
-            const tier2 = adapterRegistry.listByTier('tier-2');
-            const tier3 = adapterRegistry.listByTier('tier-3');
-
-            expect(tier1.length + tier2.length + tier3.length).toBe(18);
-        });
-    });
-
-    describe('Registry Has Check', () => {
-        it('should return true for registered adapters', () => {
-            expect(adapterRegistry.has('react')).toBe(true);
-            expect(adapterRegistry.has('vue')).toBe(true);
-            expect(adapterRegistry.has('htmx')).toBe(true);
-        });
-
-        it('should return false for unregistered adapters', () => {
-            expect(adapterRegistry.has('unknown')).toBe(false);
-            expect(adapterRegistry.has('')).toBe(false);
-            expect(adapterRegistry.has('nextjs')).toBe(false);
-        });
-    });
-
-    describe('TIER_INFO Metadata', () => {
-        it('should have metadata for all tiers', () => {
-            expect(TIER_INFO['tier-1']).toBeDefined();
-            expect(TIER_INFO['tier-2']).toBeDefined();
-            expect(TIER_INFO['tier-3']).toBeDefined();
-        });
-
-        it('should have meaningful names and descriptions', () => {
-            expect(TIER_INFO['tier-1'].name.length).toBeGreaterThan(0);
-            expect(TIER_INFO['tier-1'].description.length).toBeGreaterThan(0);
-
-            expect(TIER_INFO['tier-2'].name.length).toBeGreaterThan(0);
-            expect(TIER_INFO['tier-2'].description.length).toBeGreaterThan(0);
-
-            expect(TIER_INFO['tier-3'].name.length).toBeGreaterThan(0);
-            expect(TIER_INFO['tier-3'].description.length).toBeGreaterThan(0);
-        });
-    });
-
-    describe('Cross-Tier Capability Analysis', () => {
-        it('should show tier-1 has more capabilities than tier-3', async () => {
-            const react = await adapterRegistry.get('react');
-            const htmx = await adapterRegistry.get('htmx');
-
-            expect(react).toBeDefined();
-            expect(htmx).toBeDefined();
-
-            // Count true capabilities
-            const reactCaps = Object.values(react!.capabilities).filter(Boolean).length;
-            const htmxCaps = Object.values(htmx!.capabilities).filter(Boolean).length;
-
-            expect(reactCaps).toBeGreaterThan(htmxCaps);
-        });
-
-        it('should have consistent capability shape across all adapters', async () => {
-            const adapters = [
-                ...adapterRegistry.listByTier('tier-1'),
-                ...adapterRegistry.listByTier('tier-2'),
-                ...adapterRegistry.listByTier('tier-3'),
-            ];
-
-            for (const id of adapters) {
-                try {
-                    const adapter = await adapterRegistry.get(id);
-                    if (adapter) {
-                        expect(adapter.capabilities).toHaveProperty('streaming');
-                        expect(adapter.capabilities).toHaveProperty('partialHydration');
-                        expect(adapter.capabilities).toHaveProperty('islands');
-                        expect(adapter.capabilities).toHaveProperty('resumable');
-                        expect(adapter.capabilities).toHaveProperty('ssg');
-                        expect(adapter.capabilities).toHaveProperty('csr');
-                        expect(adapter.capabilities).toHaveProperty('serverComponents');
-                    }
-                } catch {
-                    // Skip adapters that fail due to missing peer dependencies
-                }
-            }
-        });
-    });
-});
-
-// ============================================================================
-// Adapter Lifecycle Tests
-// ============================================================================
-
-describe('Adapter Lifecycle', () => {
-    beforeAll(() => {
-        registerBuiltinAdapters();
-    });
-
-    it('all adapters should implement required methods', async () => {
-        const adapters = [
-            ...adapterRegistry.listByTier('tier-1'),
-            ...adapterRegistry.listByTier('tier-2'),
-            ...adapterRegistry.listByTier('tier-3'),
-        ];
-
-        for (const id of adapters) {
-            try {
-                const adapter = await adapterRegistry.get(id);
-                if (adapter) {
-                    expect(typeof adapter.renderToString, `${id}.renderToString`).toBe('function');
-                    expect(typeof adapter.getHydrationScript, `${id}.getHydrationScript`).toBe('function');
-                    expect(typeof adapter.getClientEntry, `${id}.getClientEntry`).toBe('function');
-                    expect(typeof adapter.createIsland, `${id}.createIsland`).toBe('function');
-                }
-            } catch {
-                // Skip adapters that fail due to missing peer dependencies
-            }
-        }
-    });
-
-    it('all adapters should have valid identity', async () => {
-        const adapters = [
-            ...adapterRegistry.listByTier('tier-1'),
-            ...adapterRegistry.listByTier('tier-2'),
-            ...adapterRegistry.listByTier('tier-3'),
-        ];
-
-        for (const id of adapters) {
-            try {
-                const adapter = await adapterRegistry.get(id);
-                if (adapter) {
-                    expect(adapter.id, `${id}.id`).toBe(id);
-                    expect(adapter.name.length, `${id}.name`).toBeGreaterThan(0);
-                    expect(adapter.framework.length, `${id}.framework`).toBeGreaterThan(0);
-                    expect(['tier-1', 'tier-2', 'tier-3']).toContain(adapter.tier);
-                }
-            } catch {
-                // Skip adapters that fail due to missing peer dependencies
-            }
-        }
-    });
-});

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-    "extends": "../../tsconfig.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": ".",
-        "noEmit": false,
-        "noUnusedLocals": false,
-        "noUnusedParameters": false,
-        "jsx": "react-jsx",
-        "types": [
-            "vitest/globals"
-        ]
-    },
-    "include": [
-        "src/**/*",
-        "test/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}

package/tsup.config.ts

@@ -1,93 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-    entry: [
-        // Main entry
-        'src/index.ts',
-
-        // Core module
-        'src/core/index.ts',
-
-        // Tier 1 - Full Support
-        'src/adapters/tier-1/index.ts',
-        'src/adapters/tier-1/react.ts',
-        'src/adapters/tier-1/vue.ts',
-        'src/adapters/tier-1/angular.ts',
-        'src/adapters/tier-1/svelte.ts',
-        'src/adapters/tier-1/solid.ts',
-        'src/adapters/tier-1/qwik.ts',
-
-        // Tier 2 - Standard Support
-        'src/adapters/tier-2/index.ts',
-        'src/adapters/tier-2/preact.ts',
-        'src/adapters/tier-2/lit.ts',
-        'src/adapters/tier-2/marko.ts',
-        'src/adapters/tier-2/stencil.ts',
-        'src/adapters/tier-2/mithril.ts',
-        'src/adapters/tier-2/inferno.ts',
-
-        // Tier 3 - HTML-First
-        'src/adapters/tier-3/index.ts',
-        'src/adapters/tier-3/htmx.ts',
-        'src/adapters/tier-3/alpine.ts',
-        'src/adapters/tier-3/hotwire.ts',
-        'src/adapters/tier-3/stimulus.ts',
-        'src/adapters/tier-3/petite-vue.ts',
-        'src/adapters/tier-3/vanilla.ts',
-    ],
-    format: ['esm'],
-    dts: {
-        compilerOptions: {
-            skipLibCheck: true,
-        },
-    },
-    clean: true,
-    target: 'node20',
-    splitting: true,
-    treeshake: true,
-    external: [
-        // Tier 1
-        'react',
-        'react-dom',
-        'react-dom/server',
-        'react-dom/client',
-        'vue',
-        'vue/server-renderer',
-        '@angular/core',
-        '@angular/platform-server',
-        '@angular/platform-browser',
-        'svelte',
-        'svelte/server',
-        'svelte/compiler',
-        'solid-js',
-        'solid-js/web',
-        '@builder.io/qwik',
-        '@builder.io/qwik/server',
-
-        // Tier 2
-        'preact',
-        'preact-render-to-string',
-        'lit',
-        '@lit-labs/ssr',
-        '@lit-labs/ssr/lib/render-result.js',
-        'marko',
-        '@stencil/core',
-        '@stencil/core/hydrate',
-        'mithril',
-        'mithril-node-render',
-        'inferno',
-        'inferno-server',
-        'inferno-create-element',
-        'inferno-hydrate',
-
-        // Tier 3
-        'alpinejs',
-        '@alpinejs/csp',
-        '@hotwired/turbo',
-        '@hotwired/stimulus',
-        'petite-vue',
-
-        // Node.js
-        'stream',
-    ],
-});