meno-core 1.0.0

package/lib/test-utils/mocks.ts

@@ -0,0 +1,341 @@
+/**
+ * Mock Factories
+ * Factory functions for creating mock objects used in tests
+ */
+
+import { mock } from 'bun:test';
+import type { ComponentRegistry } from '../client/componentRegistry';
+import type { ComponentNode, ComponentDefinition, JSONPage, PageDataWithComponent } from '../shared/types';
+import type { ElementRegistry } from '../client/elementRegistry';
+
+// HighlightManager interface (module was removed, keeping type for mock compatibility)
+interface HighlightManager {
+  highlightElements: (paths: string[]) => void;
+  setHoveredElement: (path: string | null) => void;
+  clearHover: () => void;
+  clearAll: () => void;
+}
+import { NODE_TYPE } from '../shared/constants';
+
+/**
+ * Create a mock ComponentRegistry
+ */
+export function createMockComponentRegistry(): ComponentRegistry {
+  return {
+    has: mock(() => false),
+    get: mock(() => undefined),
+    set: mock(() => {}),
+    delete: mock(() => {}),
+    clear: mock(() => {}),
+    getAll: mock(() => ({})),
+  } as any;
+}
+
+/**
+ * Create a mock ComponentNode
+ */
+export function createMockComponentNode(overrides?: Partial<ComponentNode>): ComponentNode {
+  return {
+    type: NODE_TYPE.NODE,
+    tag: 'div',
+    children: [],
+    ...overrides,
+  } as ComponentNode;
+}
+
+/**
+ * Create a mock ComponentDefinition
+ */
+export function createMockComponentDefinition(name: string, overrides?: Partial<ComponentDefinition>): ComponentDefinition {
+  return {
+    component: {
+      interface: {},
+      structure: {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+      },
+    },
+    ...overrides,
+  } as ComponentDefinition;
+}
+
+/**
+ * Create a mock PageData
+ */
+export function createMockPageData(overrides?: Partial<JSONPage>): JSONPage {
+  return {
+    meta: {
+      title: 'Test Page',
+    },
+    root: {
+      type: NODE_TYPE.NODE,
+      tag: 'div',
+      children: [],
+    },
+    ...overrides,
+  } as JSONPage;
+}
+
+/**
+ * Create a mock PageDataWithComponent
+ */
+export function createMockPageDataWithComponent(overrides?: Partial<PageDataWithComponent>): PageDataWithComponent {
+  return {
+    component: {
+      interface: {},
+      structure: {
+        type: NODE_TYPE.NODE,
+        tag: 'div',
+        children: [],
+      },
+      javascript: '',
+      css: '',
+      ...overrides?.component,
+    },
+  } as PageDataWithComponent;
+}
+
+/**
+ * Create a mock HighlightManager
+ */
+export function createMockHighlightManager(): HighlightManager {
+  return {
+    highlightElements: mock(() => {}),
+    setHoveredElement: mock(() => {}),
+    clearHover: mock(() => {}),
+    clearAll: mock(() => {}),
+  } as any;
+}
+
+/**
+ * Create a mock ElementRegistry
+ */
+export function createMockElementRegistry(): ElementRegistry {
+  return {
+    register: mock(() => {}),
+    get: mock(() => null),
+    getAllComponentNames: mock(() => []),
+    getComponentRootPaths: mock(() => []),
+    getComponentProps: mock(() => undefined),
+    clear: mock(() => {}),
+  } as any;
+}
+
+/**
+ * Create a mock EditorStore
+ */
+export function createMockEditorStore() {
+  return {
+    files: [],
+    selectedFile: null,
+    pageData: null,
+    selectedTreeItem: null,
+    setFiles: mock(() => {}),
+    setSelectedFile: mock(() => {}),
+    setPageData: mock(() => {}),
+    setSelectedTreeItem: mock(() => {}),
+    updateProp: mock(() => Promise.resolve()),
+    // Async file operations are now in editorServices.fileStoreService
+  } as any;
+}
+
+/**
+ * Create a mock editorServices object with all services mocked
+ */
+export function createMockEditorServices() {
+  return {
+    fileService: {
+      loadAllFiles: mock(() => Promise.resolve({ pages: [], components: [] })),
+      loadFileData: mock(() => Promise.resolve({ component: { type: 'div', children: [] } })),
+      saveFileData: mock(() => Promise.resolve()),
+      saveComponentJS: mock(() => Promise.resolve()),
+      saveComponentCSS: mock(() => Promise.resolve()),
+    },
+    nodeService: {
+      addElement: mock(() => Promise.resolve()),
+      deleteElement: mock(() => Promise.resolve()),
+      moveElement: mock(() => Promise.resolve()),
+    },
+    componentService: {
+      loadComponentDefinition: mock(() => Promise.resolve()),
+      createFromSelection: mock(() => Promise.resolve()),
+    },
+    fileStoreService: {
+      loadFiles: mock(() => Promise.resolve()),
+      selectFile: mock(() => Promise.resolve({ component: { type: 'div', children: [] } })),
+      reloadSelectedFilePreservingSelection: mock(() => Promise.resolve({ component: { type: 'div', children: [] } })),
+    },
+  } as any;
+}
+
+/**
+ * Create a mock Window object
+ */
+export function createMockWindow(): Window {
+  return {
+    location: {
+      href: 'http://localhost/',
+      pathname: '/',
+      search: '',
+      hash: '',
+      assign: mock(() => {}),
+      replace: mock(() => {}),
+      reload: mock(() => {}),
+    },
+    history: {
+      pushState: mock(() => {}),
+      replaceState: mock(() => {}),
+      go: mock(() => {}),
+      back: mock(() => {}),
+      forward: mock(() => {}),
+      length: 1,
+      state: null,
+      scrollRestoration: 'auto',
+    },
+    addEventListener: mock(() => {}),
+    removeEventListener: mock(() => {}),
+    dispatchEvent: mock(() => true),
+  } as unknown as Window;
+}
+
+/**
+ * Create a mock Document object
+ */
+export function createMockDocument(): Document {
+  return {
+    createElement: mock(() => createMockHTMLElement()),
+    getElementById: mock(() => null),
+    querySelector: mock(() => null),
+    querySelectorAll: mock(() => []),
+    addEventListener: mock(() => {}),
+    removeEventListener: mock(() => {}),
+    dispatchEvent: mock(() => true),
+  } as unknown as Document;
+}
+
+/**
+ * Create a mock HTMLElement
+ */
+export function createMockHTMLElement(): HTMLElement {
+  return {
+    tagName: 'DIV',
+    id: '',
+    className: '',
+    textContent: '',
+    innerHTML: '',
+    style: {} as CSSStyleDeclaration,
+    getAttribute: mock(() => null),
+    setAttribute: mock(() => {}),
+    removeAttribute: mock(() => {}),
+    addEventListener: mock(() => {}),
+    removeEventListener: mock(() => {}),
+    dispatchEvent: mock(() => true),
+    getBoundingClientRect: mock(() => ({
+      top: 0,
+      left: 0,
+      bottom: 0,
+      right: 0,
+      width: 0,
+      height: 0,
+      x: 0,
+      y: 0,
+      toJSON: mock(() => ({})),
+    })),
+  } as unknown as HTMLElement;
+}
+
+/**
+ * Create a mock PageProvider for testing PageService
+ * @param pages - Initial page content map (path -> content)
+ */
+export function createMockPageProvider(pages: Record<string, string> = {}) {
+  const pageStore = { ...pages };
+
+  return {
+    loadAll: mock(async () => {
+      return new Map(Object.entries(pageStore));
+    }),
+    get: mock(async (path: string) => {
+      return pageStore[path] ?? null;
+    }),
+    save: mock(async (path: string, content: string) => {
+      pageStore[path] = content;
+    }),
+    delete: mock(async (path: string) => {
+      delete pageStore[path];
+    }),
+    exists: mock(async (path: string) => {
+      return path in pageStore;
+    }),
+    // Expose internal store for test assertions
+    _pages: pageStore,
+  };
+}
+
+/**
+ * Create a mock fs/promises module for testing file operations
+ * @param files - Initial file content map (path -> content)
+ */
+export function createMockFs(files: Record<string, string> = {}) {
+  const fileSystem = { ...files };
+
+  return {
+    readFile: mock(async (path: string, encoding?: string) => {
+      if (path in fileSystem) {
+        return fileSystem[path];
+      }
+      const error = new Error(`ENOENT: no such file or directory, open '${path}'`);
+      (error as any).code = 'ENOENT';
+      throw error;
+    }),
+    writeFile: mock(async (path: string, content: string) => {
+      fileSystem[path] = content;
+    }),
+    unlink: mock(async (path: string) => {
+      if (!(path in fileSystem)) {
+        const error = new Error(`ENOENT: no such file or directory, unlink '${path}'`);
+        (error as any).code = 'ENOENT';
+        throw error;
+      }
+      delete fileSystem[path];
+    }),
+    readdir: mock(async (dir: string) => {
+      const normalizedDir = dir.endsWith('/') ? dir : dir + '/';
+      const entries = new Set<string>();
+      for (const path of Object.keys(fileSystem)) {
+        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 fileSystem)) {
+        const error = new Error(`ENOENT: no such file or directory, access '${path}'`);
+        (error as any).code = 'ENOENT';
+        throw error;
+      }
+    }),
+    mkdir: mock(async () => {}),
+    rm: mock(async (path: string) => {
+      // Remove all files under this path
+      for (const filePath of Object.keys(fileSystem)) {
+        if (filePath.startsWith(path)) {
+          delete fileSystem[filePath];
+        }
+      }
+    }),
+    // Expose internal file system for test assertions
+    _files: fileSystem,
+  };
+}
+

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "meno-core",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "meno": "./bin/cli.ts"
+  },
+  "exports": {
+    ".": "./lib/shared/index.ts",
+    "./server": "./lib/server/index.ts",
+    "./client": "./lib/client/index.ts",
+    "./shared/*": "./lib/shared/*.ts",
+    "./test-utils": "./lib/test-utils/index.ts"
+  },
+  "scripts": {
+    "dev": "cd ../../example && bun run ../packages/core/bin/cli.ts dev",
+    "build": "vite build",
+    "build:static": "cd ../../example && bun run ../packages/core/bin/cli.ts build",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@emotion/css": "^11.13.5",
+    "isomorphic-dompurify": "^2.32.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.2.0",
+    "bun-types": "^1.0.0",
+    "happy-dom": "^20.0.11",
+    "typescript": "^5.3.0",
+    "vite": "^5.0.0"
+  }
+}

package/templates/index-router.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>YAML React Generator with Routing</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
+    }
+
+    button {
+      background: none;
+      border: none;
+    }
+
+    img {
+      width: 100%;
+      height: 100%;
+    }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+  <script src="https://cdn.jsdelivr.net/npm/cash-dom/dist/cash.min.js"></script> 
+  <script type="module" src="/client-router.tsx"></script>
+</body>
+</html>
+

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@meno/core": ["./lib/shared/index.ts"],
+      "@meno/core/*": ["./lib/*"]
+    }
+  },
+  "include": ["lib/**/*", "entries/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vite.config.ts

@@ -0,0 +1,43 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    outDir: 'dist',
+    lib: {
+      entry: {
+        'shared/index': path.resolve(__dirname, 'lib/shared/index.ts'),
+        'server/index': path.resolve(__dirname, 'lib/server/index.ts'),
+        'client/index': path.resolve(__dirname, 'lib/client/index.ts'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: [
+        'react',
+        'react-dom',
+        'bun',
+        // Node.js built-ins (server code)
+        'path',
+        'fs',
+        'fs/promises',
+        'url',
+        'crypto',
+        'stream',
+        'os',
+        'util',
+        'events',
+        'buffer',
+        // Bun-specific
+        'bun:sqlite',
+      ],
+    },
+  },
+  resolve: {
+    alias: {
+      '@meno/core': path.resolve(__dirname, 'lib/shared/index.ts'),
+    },
+  },
+})