@useavalon/avalon 0.1.4 → 0.1.6

package/src/middleware/__tests__/discovery.test.ts

@@ -1,107 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { join } from 'node:path';
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { discoverScopedMiddleware, getMatchingMiddleware } from '../discovery.ts';
-
-describe('discoverScopedMiddleware', () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), 'middleware-test-'));
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  it('discovers _middleware.ts files in pages subdirectories', async () => {
-    // Create pages directory structure with middleware files
-    await mkdir(join(tempDir, 'pages', 'admin'), { recursive: true });
-    await mkdir(join(tempDir, 'pages', 'blog'), { recursive: true });
-    await writeFile(join(tempDir, 'pages', 'admin', '_middleware.ts'), 'export default () => {};');
-    await writeFile(join(tempDir, 'pages', 'blog', '_middleware.ts'), 'export default () => {};');
-
-    const routes = await discoverScopedMiddleware({ baseDir: tempDir });
-
-    expect(routes).toHaveLength(2);
-    expect(routes.every(r => r.type === 'pages')).toBe(true);
-    expect(routes.map(r => r.filePath)).toEqual(
-      expect.arrayContaining([
-        join(tempDir, 'pages', 'admin', '_middleware.ts'),
-        join(tempDir, 'pages', 'blog', '_middleware.ts'),
-      ])
-    );
-  });
-
-  it('discovers nested _middleware.ts files with correct priority ordering', async () => {
-    await mkdir(join(tempDir, 'pages', 'admin', 'users'), { recursive: true });
-    await writeFile(join(tempDir, 'pages', 'admin', '_middleware.ts'), 'export default () => {};');
-    await writeFile(join(tempDir, 'pages', 'admin', 'users', '_middleware.ts'), 'export default () => {};');
-
-    const routes = await discoverScopedMiddleware({ baseDir: tempDir });
-
-    expect(routes).toHaveLength(2);
-    // Parent middleware (depth 1) should come before child (depth 2)
-    expect(routes[0].priority).toBeLessThan(routes[1].priority);
-    expect(routes[0].filePath).toContain(join('admin', '_middleware.ts'));
-    expect(routes[1].filePath).toContain(join('admin', 'users', '_middleware.ts'));
-  });
-
-  it('does NOT scan api directory for middleware', async () => {
-    await mkdir(join(tempDir, 'pages', 'admin'), { recursive: true });
-    await mkdir(join(tempDir, 'api', 'admin'), { recursive: true });
-    await writeFile(join(tempDir, 'pages', 'admin', '_middleware.ts'), 'export default () => {};');
-    await writeFile(join(tempDir, 'api', 'admin', '_middleware.ts'), 'export default () => {};');
-
-    const routes = await discoverScopedMiddleware({ baseDir: tempDir });
-
-    expect(routes).toHaveLength(1);
-    expect(routes[0].type).toBe('pages');
-    expect(routes[0].filePath).toContain(join('pages', 'admin', '_middleware.ts'));
-  });
-
-  it('returns empty array when no middleware files exist', async () => {
-    await mkdir(join(tempDir, 'pages'), { recursive: true });
-
-    const routes = await discoverScopedMiddleware({ baseDir: tempDir });
-
-    expect(routes).toHaveLength(0);
-  });
-
-  it('returns empty array when pages directory does not exist', async () => {
-    const routes = await discoverScopedMiddleware({ baseDir: tempDir });
-
-    expect(routes).toHaveLength(0);
-  });
-});
-
-describe('getMatchingMiddleware', () => {
-  it('matches page middleware for page routes', () => {
-    const routes = [
-      {
-        pattern: new URLPattern({ pathname: '/admin{/*}?' }),
-        filePath: '/src/pages/admin/_middleware.ts',
-        priority: 51,
-        type: 'pages' as const,
-      },
-    ];
-
-    const matches = getMatchingMiddleware(routes, new URL('http://localhost/admin/dashboard'));
-    expect(matches).toHaveLength(1);
-  });
-
-  it('does not match page middleware for API routes', () => {
-    const routes = [
-      {
-        pattern: new URLPattern({ pathname: '/*' }),
-        filePath: '/src/pages/_middleware.ts',
-        priority: 50,
-        type: 'pages' as const,
-      },
-    ];
-
-    const matches = getMatchingMiddleware(routes, new URL('http://localhost/api/users'));
-    expect(matches).toHaveLength(0);
-  });
-});

package/src/types/tests/layout-types.test.ts

@@ -1,197 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-	LayoutContextSchema,
-	LayoutDataSchema,
-	LayoutRouteSchema,
-	LayoutHandlerSchema,
-	LayoutPropsSchema,
-	LayoutDiscoveryOptionsSchema,
-	LayoutConfigSchema,
-	ResolvedLayoutSchema,
-} from '../../schemas/layout.ts';
-import { validators, safeValidators } from '../../schemas/index.ts';
-import type {
-	LayoutContext,
-	LayoutData,
-	LayoutRoute,
-	LayoutHandler,
-	LayoutProps,
-	LayoutDiscoveryOptions,
-	LayoutConfig,
-	ResolvedLayout,
-} from '../layout.ts';
-
-describe('Layout System Types and Schemas', () => {
-	it('LayoutContext - should validate valid layout context', () => {
-		const mockRequest = new Request('https://example.com/test');
-		const mockParams = { id: '123' };
-		const mockQuery = new URLSearchParams('?page=1');
-		const mockState = new Map();
-
-		const validContext: LayoutContext = {
-			request: mockRequest,
-			params: mockParams,
-			query: mockQuery,
-			state: mockState,
-		};
-
-		const result = safeValidators.layoutContext(validContext);
-		expect(result.success).toEqual(true);
-	});
-
-	it('LayoutContext - should reject invalid layout context', () => {
-		const invalidContext = {
-			request: 'not-a-request',
-			params: 'not-an-object',
-			query: 'not-urlsearchparams',
-			state: 'not-a-map',
-		};
-
-		const result = safeValidators.layoutContext(invalidContext);
-		expect(result.success).toEqual(false);
-	});
-
-	it('LayoutData - should validate layout data as record', () => {
-		const validData: LayoutData = {
-			user: { name: 'John', id: 123 },
-			settings: { theme: 'dark' },
-			items: [1, 2, 3],
-		};
-
-		const result = safeValidators.layoutData(validData);
-		expect(result.success).toEqual(true);
-	});
-
-	it('LayoutData - should accept empty layout data', () => {
-		const emptyData: LayoutData = {};
-
-		const result = safeValidators.layoutData(emptyData);
-		expect(result.success).toEqual(true);
-	});
-
-	it('LayoutHandler - should validate valid layout handler', () => {
-		const validHandler = {
-			component: () => null,
-			path: '/src/pages/blog/_layout.tsx',
-			priority: 10,
-		};
-
-		const result = safeValidators.layoutHandler(validHandler);
-		expect(result.success).toEqual(true);
-	});
-
-	it('LayoutDiscoveryOptions - should validate with defaults', () => {
-		const options = {
-			baseDirectory: '/src/pages',
-		};
-
-		const result = safeValidators.layoutDiscoveryOptions(options);
-		expect(result.success).toEqual(true);
-		if (result.success) {
-			expect(result.data.filePattern).toEqual('_layout.tsx');
-			expect(result.data.excludeDirectories).toEqual([]);
-			expect(result.data.enableWatching).toEqual(false);
-			expect(result.data.developmentMode).toEqual(false);
-		}
-	});
-
-	it('LayoutDiscoveryOptions - should validate with custom options', () => {
-		const options: LayoutDiscoveryOptions = {
-			baseDirectory: '/src/pages',
-			filePattern: 'layout.tsx',
-			excludeDirectories: ['node_modules', '.git'],
-			enableWatching: true,
-			developmentMode: true,
-		};
-
-		const result = safeValidators.layoutDiscoveryOptions(options);
-		expect(result.success).toEqual(true);
-		if (result.success) {
-			expect(result.data.filePattern).toEqual('layout.tsx');
-			expect(result.data.excludeDirectories).toEqual(['node_modules', '.git']);
-			expect(result.data.enableWatching).toEqual(true);
-			expect(result.data.developmentMode).toEqual(true);
-		}
-	});
-
-	it('LayoutConfig - should validate layout config with all options', () => {
-		const config: LayoutConfig = {
-			skipLayouts: ['root', 'admin'],
-			replaceLayout: true,
-			onlyLayouts: ['custom'],
-			customLayout: '/custom/layout.tsx',
-		};
-
-		const result = safeValidators.layoutConfig(config);
-		expect(result.success).toEqual(true);
-	});
-
-	it('LayoutConfig - should validate empty layout config', () => {
-		const config: LayoutConfig = {};
-
-		const result = safeValidators.layoutConfig(config);
-		expect(result.success).toEqual(true);
-	});
-
-	it('ResolvedLayout - should validate complete resolved layout', () => {
-		const resolvedLayout: ResolvedLayout = {
-			handlers: [],
-			dataLoaders: [],
-			errorBoundaries: [],
-			streamingComponents: [],
-			metadata: {
-				totalLayouts: 2,
-				resolutionTime: 15.5,
-				cacheHit: false,
-			},
-		};
-
-		const result = safeValidators.resolvedLayout(resolvedLayout);
-		expect(result.success).toEqual(true);
-	});
-
-	it('ResolvedLayout - should require all metadata fields', () => {
-		const incompleteLayout = {
-			handlers: [],
-			dataLoaders: [],
-			errorBoundaries: [],
-			streamingComponents: [],
-			metadata: {
-				totalLayouts: 2,
-			},
-		};
-
-		const result = safeValidators.resolvedLayout(incompleteLayout);
-		expect(result.success).toEqual(false);
-	});
-
-	it('Type compatibility - should ensure TypeScript types match Zod schemas', () => {
-		const mockRequest = new Request('https://example.com');
-		const layoutContext: LayoutContext = {
-			request: mockRequest,
-			params: { id: '123' },
-			query: new URLSearchParams(),
-			state: new Map(),
-		};
-
-		const validatedContext = validators.layoutContext(layoutContext);
-		expect(validatedContext).toBeDefined();
-		expect(validatedContext.request).toEqual(mockRequest);
-	});
-
-	it('Error handling - should provide meaningful error messages', () => {
-		const invalidData = {
-			request: null,
-			params: null,
-			query: null,
-			state: null,
-		};
-
-		const result = safeValidators.layoutContext(invalidData);
-		expect(result.success).toEqual(false);
-		if (!result.success) {
-			expect(result.error.message).toContain('Invalid layout context');
-			expect(result.error.getFormattedErrors().length > 0).toEqual(true);
-		}
-	});
-});

package/src/vite-plugin/tests/image-optimization.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createImagePlugin } from "../image-optimization.ts";
-import type { ResolvedImageConfig } from "../types.ts";
-
-describe("createImagePlugin", () => {
-  const defaultConfig: ResolvedImageConfig = {
-    enabled: true,
-    defaultFormat: "webp",
-    quality: 80,
-    widths: [200, 400, 600, 800, 1200],
-    removeMetadata: true,
-    include: /^[^?]+\.(heif|avif|jpeg|jpg|png|tiff|webp|gif)(\?.*)?$/,
-    exclude: "public/**/*",
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("returns empty array when disabled", async () => {
-    const plugins = await createImagePlugin({ ...defaultConfig, enabled: false }, false);
-    expect(plugins).toEqual([]);
-  });
-
-  it("returns imagetools plugin when enabled", async () => {
-    const plugins = await createImagePlugin(defaultConfig, false);
-    expect(plugins.length).toBe(1);
-    expect(plugins[0].name).toBe("imagetools");
-  });
-
-  it("logs info when verbose is true", async () => {
-    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    
-    await createImagePlugin(defaultConfig, true);
-    
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Image optimization enabled"));
-    consoleSpy.mockRestore();
-  });
-
-  it("respects custom format setting", async () => {
-    const plugins = await createImagePlugin({ ...defaultConfig, defaultFormat: "avif" }, true);
-    expect(plugins.length).toBe(1);
-  });
-
-  it("respects custom quality setting", async () => {
-    const plugins = await createImagePlugin({ ...defaultConfig, quality: 90 }, false);
-    expect(plugins.length).toBe(1);
-  });
-
-  it("respects custom widths setting", async () => {
-    const plugins = await createImagePlugin({ ...defaultConfig, widths: [320, 640, 1280] }, false);
-    expect(plugins.length).toBe(1);
-  });
-});