meno-core 1.0.0

package/lib/test-utils/factories/EventMockFactory.ts

@@ -0,0 +1,244 @@
+/**
+ * Event Mock Factory
+ * Properly typed mock factories for Keyboard, Mouse, and Custom events
+ */
+
+import { mock } from 'bun:test';
+
+// ========== Types ==========
+
+export interface MockKeyboardEventOptions {
+  key: string;
+  code?: string;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  repeat?: boolean;
+  bubbles?: boolean;
+  cancelable?: boolean;
+}
+
+export interface MockMouseEventOptions {
+  button?: number;
+  buttons?: number;
+  clientX?: number;
+  clientY?: number;
+  screenX?: number;
+  screenY?: number;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  target?: EventTarget | null;
+  bubbles?: boolean;
+  cancelable?: boolean;
+}
+
+export interface TypedMockKeyboardEvent extends KeyboardEvent {
+  preventDefault: ReturnType<typeof mock>;
+  stopPropagation: ReturnType<typeof mock>;
+  stopImmediatePropagation: ReturnType<typeof mock>;
+}
+
+export interface TypedMockMouseEvent extends MouseEvent {
+  preventDefault: ReturnType<typeof mock>;
+  stopPropagation: ReturnType<typeof mock>;
+  stopImmediatePropagation: ReturnType<typeof mock>;
+}
+
+// ========== Keyboard Events ==========
+
+export function createTypedKeyboardEvent(
+  type: 'keydown' | 'keyup' | 'keypress',
+  options: MockKeyboardEventOptions
+): TypedMockKeyboardEvent {
+  const event = new KeyboardEvent(type, {
+    key: options.key,
+    code: options.code ?? options.key,
+    ctrlKey: options.ctrlKey ?? false,
+    metaKey: options.metaKey ?? false,
+    shiftKey: options.shiftKey ?? false,
+    altKey: options.altKey ?? false,
+    repeat: options.repeat ?? false,
+    bubbles: options.bubbles ?? true,
+    cancelable: options.cancelable ?? true,
+  });
+
+  // Create mock functions for event methods
+  const preventDefaultMock = mock(() => {});
+  const stopPropagationMock = mock(() => {});
+  const stopImmediatePropagationMock = mock(() => {});
+
+  // Override methods with mocks
+  Object.defineProperties(event, {
+    preventDefault: { value: preventDefaultMock, writable: true },
+    stopPropagation: { value: stopPropagationMock, writable: true },
+    stopImmediatePropagation: { value: stopImmediatePropagationMock, writable: true },
+  });
+
+  return event as TypedMockKeyboardEvent;
+}
+
+/**
+ * Convenience function for creating common keyboard shortcuts
+ */
+export const KeyboardShortcuts = {
+  copy: (meta = true) =>
+    createTypedKeyboardEvent('keydown', {
+      key: 'c',
+      metaKey: meta,
+      ctrlKey: !meta,
+    }),
+  paste: (meta = true) =>
+    createTypedKeyboardEvent('keydown', {
+      key: 'v',
+      metaKey: meta,
+      ctrlKey: !meta,
+    }),
+  cut: (meta = true) =>
+    createTypedKeyboardEvent('keydown', {
+      key: 'x',
+      metaKey: meta,
+      ctrlKey: !meta,
+    }),
+  undo: (meta = true) =>
+    createTypedKeyboardEvent('keydown', {
+      key: 'z',
+      metaKey: meta,
+      ctrlKey: !meta,
+    }),
+  redo: (meta = true) =>
+    createTypedKeyboardEvent('keydown', {
+      key: 'z',
+      metaKey: meta,
+      ctrlKey: !meta,
+      shiftKey: true,
+    }),
+  delete: () => createTypedKeyboardEvent('keydown', { key: 'Backspace' }),
+  enter: () => createTypedKeyboardEvent('keydown', { key: 'Enter' }),
+  escape: () => createTypedKeyboardEvent('keydown', { key: 'Escape' }),
+  tab: (shift = false) =>
+    createTypedKeyboardEvent('keydown', { key: 'Tab', shiftKey: shift }),
+  arrowUp: () => createTypedKeyboardEvent('keydown', { key: 'ArrowUp' }),
+  arrowDown: () => createTypedKeyboardEvent('keydown', { key: 'ArrowDown' }),
+  arrowLeft: () => createTypedKeyboardEvent('keydown', { key: 'ArrowLeft' }),
+  arrowRight: () => createTypedKeyboardEvent('keydown', { key: 'ArrowRight' }),
+};
+
+// ========== Mouse Events ==========
+
+export function createTypedMouseEvent(
+  type:
+    | 'click'
+    | 'dblclick'
+    | 'mousedown'
+    | 'mouseup'
+    | 'mousemove'
+    | 'mouseenter'
+    | 'mouseleave'
+    | 'mouseover'
+    | 'mouseout'
+    | 'contextmenu',
+  options: MockMouseEventOptions = {}
+): TypedMockMouseEvent {
+  const event = new MouseEvent(type, {
+    button: options.button ?? 0,
+    buttons: options.buttons ?? 0,
+    clientX: options.clientX ?? 0,
+    clientY: options.clientY ?? 0,
+    screenX: options.screenX ?? options.clientX ?? 0,
+    screenY: options.screenY ?? options.clientY ?? 0,
+    ctrlKey: options.ctrlKey ?? false,
+    metaKey: options.metaKey ?? false,
+    shiftKey: options.shiftKey ?? false,
+    altKey: options.altKey ?? false,
+    bubbles: options.bubbles ?? true,
+    cancelable: options.cancelable ?? true,
+  });
+
+  const preventDefaultMock = mock(() => {});
+  const stopPropagationMock = mock(() => {});
+  const stopImmediatePropagationMock = mock(() => {});
+
+  Object.defineProperties(event, {
+    preventDefault: { value: preventDefaultMock, writable: true },
+    stopPropagation: { value: stopPropagationMock, writable: true },
+    stopImmediatePropagation: { value: stopImmediatePropagationMock, writable: true },
+    target: { value: options.target ?? null, writable: true },
+  });
+
+  return event as TypedMockMouseEvent;
+}
+
+// ========== Custom Events ==========
+
+export function createTypedCustomEvent<T = unknown>(
+  type: string,
+  detail?: T,
+  options: { bubbles?: boolean; cancelable?: boolean } = {}
+): CustomEvent<T> {
+  return new CustomEvent(type, {
+    detail,
+    bubbles: options.bubbles ?? true,
+    cancelable: options.cancelable ?? true,
+  });
+}
+
+// ========== PopState Event ==========
+
+export function createTypedPopStateEvent(state?: unknown): PopStateEvent {
+  return new PopStateEvent('popstate', { state });
+}
+
+// ========== Message Event ==========
+
+export interface MockMessageEventOptions<T = unknown> {
+  data: T;
+  origin?: string;
+  source?: MessageEventSource | null;
+}
+
+export function createTypedMessageEvent<T = unknown>(
+  options: MockMessageEventOptions<T>
+): MessageEvent<T> {
+  return new MessageEvent('message', {
+    data: options.data,
+    origin: options.origin ?? 'http://localhost',
+    source: options.source ?? null,
+  });
+}
+
+// ========== Focus Events ==========
+
+export function createTypedFocusEvent(
+  type: 'focus' | 'blur' | 'focusin' | 'focusout',
+  options: { relatedTarget?: EventTarget | null } = {}
+): FocusEvent {
+  return new FocusEvent(type, {
+    bubbles: type === 'focusin' || type === 'focusout',
+    cancelable: false,
+    relatedTarget: options.relatedTarget ?? null,
+  });
+}
+
+// ========== Input Events ==========
+
+export interface MockInputEventOptions {
+  data?: string | null;
+  inputType?: string;
+  isComposing?: boolean;
+}
+
+export function createTypedInputEvent(
+  type: 'input' | 'beforeinput',
+  options: MockInputEventOptions = {}
+): InputEvent {
+  return new InputEvent(type, {
+    data: options.data ?? null,
+    inputType: options.inputType ?? 'insertText',
+    isComposing: options.isComposing ?? false,
+    bubbles: true,
+    cancelable: type === 'beforeinput',
+  });
+}

package/lib/test-utils/factories/FetchMockFactory.ts

@@ -0,0 +1,210 @@
+/**
+ * Fetch Mock Factory
+ * Properly typed mock factory for fetch with URL pattern matching
+ */
+
+import { mock } from 'bun:test';
+
+// ========== Types ==========
+
+export interface MockFetchResponse {
+  status?: number;
+  statusText?: string;
+  ok?: boolean;
+  headers?: Record<string, string>;
+  json?: () => Promise<unknown>;
+  text?: () => Promise<string>;
+  blob?: () => Promise<Blob>;
+}
+
+export interface FetchMockConfig {
+  /** URL pattern to response mapping */
+  responses?: Map<string | RegExp, MockFetchResponse | (() => MockFetchResponse)>;
+  /** Default response for unmatched URLs */
+  defaultResponse?: MockFetchResponse;
+  /** Whether to throw on unmatched URLs */
+  throwOnUnmatched?: boolean;
+  /** Delay in ms before resolving */
+  delay?: number;
+}
+
+export interface TypedFetchMock {
+  (input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+  /** Recorded calls for assertions */
+  _calls: Array<{ url: string; options?: RequestInit }>;
+  /** Reset call history */
+  _reset: () => void;
+  /** Add a response for a URL pattern */
+  _addResponse: (
+    pattern: string | RegExp,
+    response: MockFetchResponse | (() => MockFetchResponse)
+  ) => void;
+}
+
+// ========== Response Factory ==========
+
+function createMockResponse(config: MockFetchResponse): Response {
+  const status = config.status ?? 200;
+  const ok = config.ok ?? (status >= 200 && status < 300);
+
+  return {
+    status,
+    statusText: config.statusText ?? (ok ? 'OK' : 'Error'),
+    ok,
+    headers: new Headers(config.headers),
+    json: config.json ?? (() => Promise.resolve({})),
+    text: config.text ?? (() => Promise.resolve('')),
+    blob: config.blob ?? (() => Promise.resolve(new Blob())),
+    clone: function () {
+      return createMockResponse(config);
+    },
+    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+    formData: () => Promise.resolve(new FormData()),
+    body: null,
+    bodyUsed: false,
+    redirected: false,
+    type: 'basic',
+    url: '',
+  } as Response;
+}
+
+// ========== Main Factory ==========
+
+export function createTypedFetchMock(config: FetchMockConfig = {}): TypedFetchMock {
+  const calls: Array<{ url: string; options?: RequestInit }> = [];
+  const responses = new Map(config.responses || []);
+
+  const mockFn = mock(
+    async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+      const url = typeof input === 'string' ? input : input.toString();
+      calls.push({ url, options: init });
+
+      if (config.delay) {
+        await new Promise((resolve) => setTimeout(resolve, config.delay));
+      }
+
+      // Find matching response
+      let responseConfig:
+        | MockFetchResponse
+        | (() => MockFetchResponse)
+        | undefined;
+
+      for (const [pattern, response] of responses) {
+        if (typeof pattern === 'string' && url === pattern) {
+          responseConfig = response;
+          break;
+        }
+        if (typeof pattern === 'string' && url.includes(pattern)) {
+          responseConfig = response;
+          break;
+        }
+        if (pattern instanceof RegExp && pattern.test(url)) {
+          responseConfig = response;
+          break;
+        }
+      }
+
+      if (!responseConfig && config.defaultResponse) {
+        responseConfig = config.defaultResponse;
+      }
+
+      if (!responseConfig) {
+        if (config.throwOnUnmatched) {
+          throw new Error(`Unmatched fetch request: ${url}`);
+        }
+        return createMockResponse({ status: 404, ok: false });
+      }
+
+      const resolvedConfig =
+        typeof responseConfig === 'function'
+          ? responseConfig()
+          : responseConfig;
+
+      return createMockResponse(resolvedConfig);
+    }
+  ) as TypedFetchMock;
+
+  mockFn._calls = calls;
+  mockFn._reset = () => {
+    calls.length = 0;
+  };
+  mockFn._addResponse = (pattern, response) => {
+    responses.set(pattern, response);
+  };
+
+  return mockFn;
+}
+
+// ========== Convenience Factories ==========
+
+/**
+ * Create a fetch mock that returns JSON data
+ */
+export function createJsonFetchMock<T>(
+  responseData: T,
+  options: Partial<MockFetchResponse> = {}
+): TypedFetchMock {
+  return createTypedFetchMock({
+    defaultResponse: {
+      status: 200,
+      ok: true,
+      json: () => Promise.resolve(responseData),
+      text: () => Promise.resolve(JSON.stringify(responseData)),
+      ...options,
+    },
+  });
+}
+
+/**
+ * Create a fetch mock that returns an error
+ */
+export function createErrorFetchMock(
+  error: Error | string = 'Network error'
+): TypedFetchMock {
+  const mockFn = mock(() =>
+    Promise.reject(typeof error === 'string' ? new Error(error) : error)
+  ) as TypedFetchMock;
+
+  mockFn._calls = [];
+  mockFn._reset = () => {};
+  mockFn._addResponse = () => {};
+
+  return mockFn;
+}
+
+/**
+ * Create a fetch mock that returns different responses based on URL
+ */
+export function createRoutedFetchMock(
+  routes: Record<string, MockFetchResponse | (() => MockFetchResponse)>
+): TypedFetchMock {
+  const responses = new Map<string, MockFetchResponse | (() => MockFetchResponse)>();
+  for (const [url, response] of Object.entries(routes)) {
+    responses.set(url, response);
+  }
+  return createTypedFetchMock({ responses });
+}
+
+// ========== Global Installation ==========
+
+export interface FetchMockInstallation {
+  fetch: TypedFetchMock;
+  cleanup: () => void;
+}
+
+/**
+ * Install mock fetch globally and return cleanup function
+ */
+export function installMockFetch(config: FetchMockConfig = {}): FetchMockInstallation {
+  const originalFetch = globalThis.fetch;
+  const mockFetch = createTypedFetchMock(config);
+
+  globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+  return {
+    fetch: mockFetch,
+    cleanup: () => {
+      globalThis.fetch = originalFetch;
+    },
+  };
+}

package/lib/test-utils/factories/ServerMockFactory.ts

@@ -0,0 +1,223 @@
+/**
+ * Server Mock Factory
+ * Properly typed mock factories for server-side services
+ */
+
+import { mock } from 'bun:test';
+import type { PageProvider, ComponentProvider } from '../../shared/interfaces/contentProvider';
+import type { ComponentServiceFs, ComponentLoader } from '../../server/services/componentService';
+import type { ComponentDefinition } from '../../shared/types';
+
+// ========== PageProvider Mock ==========
+
+export interface TypedMockPageProvider extends PageProvider {
+  loadAll: ReturnType<typeof mock>;
+  get: ReturnType<typeof mock>;
+  save: ReturnType<typeof mock>;
+  delete: ReturnType<typeof mock>;
+  exists: ReturnType<typeof mock>;
+  // Internal state for assertions
+  _pages: Record<string, string>;
+}
+
+/**
+ * Create a typed mock PageProvider
+ * @param initialPages - Initial page content map (path -> content)
+ */
+export function createTypedMockPageProvider(
+  initialPages: Record<string, string> = {}
+): TypedMockPageProvider {
+  const pages = { ...initialPages };
+
+  const provider: TypedMockPageProvider = {
+    loadAll: mock(async () => new Map(Object.entries(pages))),
+    get: mock(async (path: string) => pages[path] ?? null),
+    save: mock(async (path: string, content: string) => {
+      pages[path] = content;
+    }),
+    delete: mock(async (path: string) => {
+      delete pages[path];
+    }),
+    exists: mock(async (path: string) => path in pages),
+    _pages: pages,
+  };
+
+  return provider;
+}
+
+// ========== ComponentProvider Mock ==========
+
+export interface TypedMockComponentProvider extends ComponentProvider {
+  loadAll: ReturnType<typeof mock>;
+  get: ReturnType<typeof mock>;
+  getJS: ReturnType<typeof mock>;
+  getCSS: ReturnType<typeof mock>;
+  save: ReturnType<typeof mock>;
+  // Internal state for assertions
+  _components: Map<string, ComponentDefinition>;
+  _js: Map<string, string>;
+  _css: Map<string, string>;
+}
+
+/**
+ * Create a typed mock ComponentProvider
+ */
+export function createTypedMockComponentProvider(
+  initialComponents: Map<string, ComponentDefinition> = new Map()
+): TypedMockComponentProvider {
+  const components = new Map(initialComponents);
+  const js = new Map<string, string>();
+  const css = new Map<string, string>();
+
+  const provider: TypedMockComponentProvider = {
+    loadAll: mock(async () => new Map(components)),
+    get: mock(async (name: string) => components.get(name) ?? null),
+    getJS: mock(async (name: string) => js.get(name) ?? null),
+    getCSS: mock(async (name: string) => css.get(name) ?? null),
+    save: mock(async (name: string, definition: ComponentDefinition) => {
+      components.set(name, definition);
+    }),
+    _components: components,
+    _js: js,
+    _css: css,
+  };
+
+  return provider;
+}
+
+// ========== ComponentServiceFs Mock ==========
+
+export interface TypedMockComponentServiceFs extends ComponentServiceFs {
+  writeFile: ReturnType<typeof mock>;
+  readFile: ReturnType<typeof mock>;
+  // Internal state for assertions
+  _files: Record<string, string>;
+}
+
+/**
+ * Create a typed mock file system for ComponentService
+ */
+export function createTypedMockComponentServiceFs(
+  initialFiles: Record<string, string> = {}
+): TypedMockComponentServiceFs {
+  const files = { ...initialFiles };
+
+  const fs: TypedMockComponentServiceFs = {
+    writeFile: mock(async (path: string, content: string) => {
+      files[path] = content;
+    }),
+    readFile: mock(async (path: string) => files[path] ?? null),
+    _files: files,
+  };
+
+  return fs;
+}
+
+// ========== ComponentLoader Mock ==========
+
+export interface TypedMockComponentLoader extends ComponentLoader {
+  loadDirectory: ReturnType<typeof mock>;
+  loadFile: ReturnType<typeof mock>;
+  // Internal state for assertions
+  _components: Map<string, ComponentDefinition>;
+}
+
+/**
+ * Create a typed mock component loader
+ */
+export function createTypedMockComponentLoader(
+  components: Map<string, ComponentDefinition> = new Map()
+): TypedMockComponentLoader {
+  const storedComponents = new Map(components);
+
+  const loader: TypedMockComponentLoader = {
+    loadDirectory: mock(async () => new Map(storedComponents)),
+    loadFile: mock(async () => null),
+    _components: storedComponents,
+  };
+
+  return loader;
+}
+
+// ========== Full-stack file system mock ==========
+
+export interface TypedMockFs {
+  readFile: ReturnType<typeof mock>;
+  writeFile: ReturnType<typeof mock>;
+  unlink: ReturnType<typeof mock>;
+  readdir: ReturnType<typeof mock>;
+  stat: ReturnType<typeof mock>;
+  access: ReturnType<typeof mock>;
+  mkdir: ReturnType<typeof mock>;
+  rm: ReturnType<typeof mock>;
+  // Internal state for assertions
+  _files: Record<string, string>;
+}
+
+/**
+ * Create a comprehensive mock file system (similar to fs/promises)
+ * @param initialFiles - Initial file content map (path -> content)
+ */
+export function createTypedMockFs(
+  initialFiles: Record<string, string> = {}
+): TypedMockFs {
+  const files = { ...initialFiles };
+
+  const makeError = (code: string, message: string) => {
+    const error = new Error(message);
+    (error as NodeJS.ErrnoException).code = code;
+    return error;
+  };
+
+  const fs: TypedMockFs = {
+    readFile: mock(async (path: string) => {
+      if (path in files) {
+        return files[path];
+      }
+      throw makeError('ENOENT', `ENOENT: no such file or directory, open '${path}'`);
+    }),
+    writeFile: mock(async (path: string, content: string) => {
+      files[path] = content;
+    }),
+    unlink: mock(async (path: string) => {
+      if (!(path in files)) {
+        throw makeError('ENOENT', `ENOENT: no such file or directory, unlink '${path}'`);
+      }
+      delete files[path];
+    }),
+    readdir: mock(async (dir: string) => {
+      const normalizedDir = dir.endsWith('/') ? dir : dir + '/';
+      const entries = new Set<string>();
+      for (const path of Object.keys(files)) {
+        if (path.startsWith(normalizedDir)) {
+          const relativePath = path.slice(normalizedDir.length);
+          const firstSegment = relativePath.split('/')[0];
+          if (firstSegment) {
+            entries.add(firstSegment);
+          }
+        }
+      }
+      return Array.from(entries);
+    }),
+    stat: mock(async (path: string) => ({
+      isDirectory: () => !path.includes('.') || path.endsWith('/'),
+      isFile: () => path.includes('.') && !path.endsWith('/'),
+    })),
+    access: mock(async (path: string) => {
+      if (!(path in files)) {
+        throw makeError('ENOENT', `ENOENT: no such file or directory, access '${path}'`);
+      }
+    }),
+    mkdir: mock(async () => {}),
+    rm: mock(async (path: string) => {
+      for (const filePath of Object.keys(files)) {
+        if (filePath.startsWith(path)) {
+          delete files[filePath];
+        }
+      }
+    }),
+    _files: files,
+  };
+
+  return fs;
+}