@openelement/adapter-vite 0.41.0-alpha.1

package/src/subpath-resolver.js

@@ -0,0 +1,153 @@
+/**
+ * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).
+ *
+ * When @openelement/core is loaded from JSR (https:// import.meta.url),
+ * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.
+ * This module intercepts @openelement/core/* imports and loads source code
+ * through virtual modules, bypassing Node.js ESM loader entirely.
+ *
+ * ADR 0018 Phase 0: buildCoreSubpathAliases() DELETED.
+ * Local mode now relies on @deno/vite-plugin for bare specifier resolution.
+ * Remote JSR resolution (createCoreResolvePlugin) is retained because
+ * JSR packages are not in node_modules and require virtual module loading.
+ */ import { formatError, OpenElementError } from '@openelement/core/errors';
+/** Virtual module ID prefix for JSR remote resolution */ export const VIRTUAL_CORE_PREFIX = '\0openelement:core/src/';
+/**
+ * Mapping of @openelement/core/* subpath specifiers to source files
+ * (used by JSR remote resolution only).
+ */ export const CORE_SUBPATHS = {
+  logger: 'logger.ts',
+  'build-context': 'build-context.ts',
+  navigation: 'navigation.ts',
+  errors: 'errors.ts'
+};
+// M-08 fix: Add max size limit to prevent unbounded memory growth in long dev sessions
+const JSR_CACHE_MAX = 100;
+const jsrSourceCache = new Map();
+function cacheGet(key) {
+  return jsrSourceCache.get(key);
+}
+function cacheSet(key, value) {
+  if (jsrSourceCache.size >= JSR_CACHE_MAX) {
+    // Evict oldest entry
+    const firstKey = jsrSourceCache.keys().next().value;
+    if (firstKey !== undefined) jsrSourceCache.delete(firstKey);
+  }
+  jsrSourceCache.set(key, value);
+}
+const OPENELEMENT_PACKAGE_SRC_BASE_RE = /\/@openelement\/([^/]+)\/([^/]+)\/src\/.*$/;
+/**
+ * Extract the JSR package source base URL from import.meta.url.
+ * Handles both standard JSR paths and edge cases where the version
+ * segment differs from expectations.
+ */ function getOpenPackageSrcBase(metaUrl, packageName) {
+  const match = metaUrl.match(OPENELEMENT_PACKAGE_SRC_BASE_RE);
+  if (match) {
+    return metaUrl.replace(OPENELEMENT_PACKAGE_SRC_BASE_RE, `/@openelement/${packageName}/${match[2]}/src/`);
+  }
+  return metaUrl.replace(/\/@openelement\/[^/]+@([^/]+)\/src\/.*$/, `/@openelement/${packageName}/$1/src/`).replace(/\/src\/.*$/, '/src/');
+}
+/**
+ * Create the core subpath resolution plugin for JSR remote execution.
+ *
+ * When @openelement/core is loaded from JSR (https:// import.meta.url),
+ * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.
+ * This plugin intercepts @openelement/core/* imports and loads source code
+ * through virtual modules, bypassing Node.js ESM loader entirely.
+ */ export function createCoreResolvePlugin(metaUrl) {
+  const isRemote = metaUrl.startsWith('https://') || metaUrl.startsWith('http://');
+  // Compute JSR base URL for source fetching.
+  let jsrSrcBase = '';
+  if (isRemote) {
+    jsrSrcBase = getOpenPackageSrcBase(metaUrl, 'core');
+  }
+  return {
+    name: 'open:core-resolve',
+    enforce: 'pre',
+    resolveId (source, importer, options) {
+      if (!isRemote) return;
+      // Case 1: Bare specifier @openelement/core or @openelement/core/*
+      if (source === '@openelement/core' || source.startsWith('@openelement/core/')) {
+        const subpath = source === '@openelement/core' ? 'index.ts' : CORE_SUBPATHS[source.slice('@openelement/core/'.length)] || `${source.slice('@openelement/core/'.length)}.ts`;
+        return `${VIRTUAL_CORE_PREFIX}${subpath}`;
+      }
+      // Case 2: Relative imports from within our virtual modules
+      if (importer?.startsWith(VIRTUAL_CORE_PREFIX) && source.startsWith('./')) {
+        const importerDir = importer.replace(/[/\\][^/\\]+$/, '');
+        return `${importerDir}/${source.slice(2)}`;
+      }
+      // Case 3: Third-party bare specifiers from virtual modules
+      if (importer?.startsWith(VIRTUAL_CORE_PREFIX) && !source.startsWith('/') && !source.startsWith('.') && !source.startsWith('\0')) {
+        return this.resolve(source, undefined, {
+          ...options,
+          skipSelf: true
+        });
+      }
+      // Case 4: Already-resolved virtual IDs (re-resolve safeguard)
+      if (source.startsWith(VIRTUAL_CORE_PREFIX)) {
+        return source;
+      }
+    },
+    async load (id) {
+      if (!isRemote) return;
+      if (!id.startsWith(VIRTUAL_CORE_PREFIX)) return;
+      // Check cache
+      if (jsrSourceCache.has(id)) return cacheGet(id);
+      // Normalize .js -> .ts (Deno convention: imports use .js, files are .ts)
+      let filePath = id.slice(VIRTUAL_CORE_PREFIX.length);
+      if (filePath.endsWith('.js') && !filePath.endsWith('.ts')) {
+        filePath = filePath.slice(0, -3) + '.ts';
+      }
+      // Fetch TypeScript source from JSR
+      const url = `${jsrSrcBase}${filePath}`;
+      let tsCode;
+      // M-09 fix: Add 30s timeout for JSR fetches to prevent hanging builds
+      const controller = new AbortController();
+      const timeoutId = setTimeout(()=>controller.abort(), 30_000);
+      try {
+        const resp = await fetch(url, {
+          signal: controller.signal
+        });
+        if (!resp.ok) {
+          throw new Error(`[open:core-resolve] Failed to fetch ${url}: HTTP ${resp.status}`);
+        }
+        tsCode = await resp.text();
+        clearTimeout(timeoutId);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        throw new OpenElementError(`Failed to load @openelement/core module from JSR: ${filePath}. ` + `URL: ${url}. Error: ${formatError(err)}`, {
+          code: 'JSR_FETCH_ERROR',
+          statusCode: 500,
+          recoverable: false
+        });
+      }
+      // Compile TypeScript -> JavaScript via Vite's bundled esbuild transform
+      let jsCode;
+      try {
+        const { transformWithEsbuild } = await import('vite');
+        const result = await transformWithEsbuild(tsCode, filePath, {
+          loader: 'ts',
+          target: 'esnext',
+          format: 'esm'
+        });
+        jsCode = result.code;
+      } catch (err) {
+        throw new OpenElementError(`Failed to compile @openelement/core module from JSR: ${filePath}. ` + `Error: ${formatError(err)}`, {
+          code: 'JSR_COMPILE_ERROR',
+          statusCode: 500,
+          recoverable: false
+        });
+      }
+      // Post-process: rewrite npm: specifiers to bare specifiers.
+      jsCode = jsCode.replace(/(["'])npm:([^"']+)\1/g, (_, quote, specifier)=>{
+        const isScoped = specifier.startsWith('@');
+        const withoutScope = isScoped ? specifier.slice(1) : specifier;
+        const namePart = withoutScope.split('@')[0];
+        return `${quote}${isScoped ? '@' : ''}${namePart}${quote}`;
+      });
+      cacheSet(id, jsCode);
+      return jsCode;
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/subpath-resolver.ts"],"sourcesContent":["/**\n * Extracted from index.ts in v0.22 (SOP-004: adapter-vite decomposition).\n *\n * When @openelement/core is loaded from JSR (https:// import.meta.url),\n * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.\n * This module intercepts @openelement/core/* imports and loads source code\n * through virtual modules, bypassing Node.js ESM loader entirely.\n *\n * ADR 0018 Phase 0: buildCoreSubpathAliases() DELETED.\n * Local mode now relies on @deno/vite-plugin for bare specifier resolution.\n * Remote JSR resolution (createCoreResolvePlugin) is retained because\n * JSR packages are not in node_modules and require virtual module loading.\n */\n\nimport type { Plugin } from 'vite';\n\nimport { formatError, OpenElementError } from '@openelement/core/errors';\n\n/** Virtual module ID prefix for JSR remote resolution */\nexport const VIRTUAL_CORE_PREFIX = '\\0openelement:core/src/';\n\n/**\n * Mapping of @openelement/core/* subpath specifiers to source files\n * (used by JSR remote resolution only).\n */\nexport const CORE_SUBPATHS: Record<string, string> = {\n  logger: 'logger.ts',\n  'build-context': 'build-context.ts',\n  navigation: 'navigation.ts',\n  errors: 'errors.ts',\n};\n\n// M-08 fix: Add max size limit to prevent unbounded memory growth in long dev sessions\n\nconst JSR_CACHE_MAX = 100;\nconst jsrSourceCache = new Map<string, string>();\n\nfunction cacheGet(key: string): string | undefined {\n  return jsrSourceCache.get(key);\n}\n\nfunction cacheSet(key: string, value: string): void {\n  if (jsrSourceCache.size >= JSR_CACHE_MAX) {\n    // Evict oldest entry\n    const firstKey = jsrSourceCache.keys().next().value;\n    if (firstKey !== undefined) jsrSourceCache.delete(firstKey);\n  }\n  jsrSourceCache.set(key, value);\n}\n\nconst OPENELEMENT_PACKAGE_SRC_BASE_RE = /\\/@openelement\\/([^/]+)\\/([^/]+)\\/src\\/.*$/;\n\n/**\n * Extract the JSR package source base URL from import.meta.url.\n * Handles both standard JSR paths and edge cases where the version\n * segment differs from expectations.\n */\nfunction getOpenPackageSrcBase(metaUrl: string, packageName: string): string {\n  const match = metaUrl.match(OPENELEMENT_PACKAGE_SRC_BASE_RE);\n  if (match) {\n    return metaUrl.replace(\n      OPENELEMENT_PACKAGE_SRC_BASE_RE,\n      `/@openelement/${packageName}/${match[2]}/src/`,\n    );\n  }\n  return metaUrl\n    .replace(/\\/@openelement\\/[^/]+@([^/]+)\\/src\\/.*$/, `/@openelement/${packageName}/$1/src/`)\n    .replace(/\\/src\\/.*$/, '/src/');\n}\n\n/**\n * Create the core subpath resolution plugin for JSR remote execution.\n *\n * When @openelement/core is loaded from JSR (https:// import.meta.url),\n * Vite's SSR runner cannot load https:// URLs via Node.js ESM loader.\n * This plugin intercepts @openelement/core/* imports and loads source code\n * through virtual modules, bypassing Node.js ESM loader entirely.\n */\nexport function createCoreResolvePlugin(metaUrl: string): Plugin {\n  const isRemote = metaUrl.startsWith('https://') || metaUrl.startsWith('http://');\n\n  // Compute JSR base URL for source fetching.\n  let jsrSrcBase = '';\n  if (isRemote) {\n    jsrSrcBase = getOpenPackageSrcBase(metaUrl, 'core');\n  }\n\n  return {\n    name: 'open:core-resolve',\n    enforce: 'pre',\n\n    resolveId(source, importer, options) {\n      if (!isRemote) return;\n\n      // Case 1: Bare specifier @openelement/core or @openelement/core/*\n      if (source === '@openelement/core' || source.startsWith('@openelement/core/')) {\n        const subpath = source === '@openelement/core'\n          ? 'index.ts'\n          : CORE_SUBPATHS[source.slice('@openelement/core/'.length)] ||\n            `${source.slice('@openelement/core/'.length)}.ts`;\n        return `${VIRTUAL_CORE_PREFIX}${subpath}`;\n      }\n\n      // Case 2: Relative imports from within our virtual modules\n      if (\n        importer?.startsWith(VIRTUAL_CORE_PREFIX) &&\n        source.startsWith('./')\n      ) {\n        const importerDir = importer.replace(/[/\\\\][^/\\\\]+$/, '');\n        return `${importerDir}/${source.slice(2)}`;\n      }\n\n      // Case 3: Third-party bare specifiers from virtual modules\n      if (\n        importer?.startsWith(VIRTUAL_CORE_PREFIX) &&\n        !source.startsWith('/') &&\n        !source.startsWith('.') &&\n        !source.startsWith('\\0')\n      ) {\n        return this.resolve(source, undefined, { ...options, skipSelf: true });\n      }\n\n      // Case 4: Already-resolved virtual IDs (re-resolve safeguard)\n      if (source.startsWith(VIRTUAL_CORE_PREFIX)) {\n        return source;\n      }\n    },\n\n    async load(id) {\n      if (!isRemote) return;\n      if (!id.startsWith(VIRTUAL_CORE_PREFIX)) return;\n\n      // Check cache\n      if (jsrSourceCache.has(id)) return cacheGet(id);\n\n      // Normalize .js -> .ts (Deno convention: imports use .js, files are .ts)\n      let filePath = id.slice(VIRTUAL_CORE_PREFIX.length);\n      if (filePath.endsWith('.js') && !filePath.endsWith('.ts')) {\n        filePath = filePath.slice(0, -3) + '.ts';\n      }\n\n      // Fetch TypeScript source from JSR\n      const url = `${jsrSrcBase}${filePath}`;\n      let tsCode: string;\n      // M-09 fix: Add 30s timeout for JSR fetches to prevent hanging builds\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), 30_000);\n      try {\n        const resp = await fetch(url, { signal: controller.signal });\n        if (!resp.ok) {\n          throw new Error(\n            `[open:core-resolve] Failed to fetch ${url}: HTTP ${resp.status}`,\n          );\n        }\n        tsCode = await resp.text();\n        clearTimeout(timeoutId);\n      } catch (err) {\n        clearTimeout(timeoutId);\n        throw new OpenElementError(\n          `Failed to load @openelement/core module from JSR: ${filePath}. ` +\n            `URL: ${url}. Error: ${formatError(err)}`,\n          {\n            code: 'JSR_FETCH_ERROR',\n            statusCode: 500,\n            recoverable: false,\n          },\n        );\n      }\n\n      // Compile TypeScript -> JavaScript via Vite's bundled esbuild transform\n      let jsCode: string;\n      try {\n        const { transformWithEsbuild } = await import('vite');\n        const result = await transformWithEsbuild(tsCode, filePath, {\n          loader: 'ts',\n          target: 'esnext',\n          format: 'esm',\n        });\n        jsCode = result.code;\n      } catch (err) {\n        throw new OpenElementError(\n          `Failed to compile @openelement/core module from JSR: ${filePath}. ` +\n            `Error: ${formatError(err)}`,\n          {\n            code: 'JSR_COMPILE_ERROR',\n            statusCode: 500,\n            recoverable: false,\n          },\n        );\n      }\n\n      // Post-process: rewrite npm: specifiers to bare specifiers.\n      jsCode = jsCode.replace(\n        /([\"'])npm:([^\"']+)\\1/g,\n        (_: string, quote: string, specifier: string) => {\n          const isScoped = specifier.startsWith('@');\n          const withoutScope = isScoped ? specifier.slice(1) : specifier;\n          const namePart = withoutScope.split('@')[0];\n          return `${quote}${isScoped ? '@' : ''}${namePart}${quote}`;\n        },\n      );\n\n      cacheSet(id, jsCode);\n      return jsCode;\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/src/workspace-alias.js

@@ -0,0 +1,113 @@
+import { Deno } from "@deno/shim-deno";
+/**
+ * @openelement/adapter-vite - Workspace alias auto-generation
+ *
+ * Reads Deno workspace deno.json exports and generates
+ * Vite resolve.alias entries. Uses sync Deno APIs so it
+ * can run in synchronous plugin hooks (config, configResolved).
+ */ import { resolve } from 'node:path';
+function tryReadJson(path) {
+  try {
+    // H-12 fix: Use platform-appropriate file reading API
+    // Deno.readTextFileSync in Deno environments, node:fs in Node.js (Vite)
+    const content = typeof Deno !== 'undefined' ? Deno.readTextFileSync(path) : require('node:fs').readFileSync(path, 'utf-8');
+    // deno.json files may contain comments - strip them before JSON.parse.
+    // Naive regex breaks URLs (https:// -> https:), so we walk character by character,
+    // tracking whether we're inside a string literal.
+    let result = '';
+    let inString = false;
+    let escape = false;
+    for(let i = 0; i < content.length; i++){
+      const ch = content[i];
+      if (escape) {
+        result += ch;
+        escape = false;
+        continue;
+      }
+      if (ch === '\\') {
+        result += ch;
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        result += ch;
+        continue;
+      }
+      if (!inString && ch === '/' && content[i + 1] === '/') {
+        // Skip until end of line
+        while(i < content.length && content[i] !== '\n')i++;
+        result += '\n';
+        continue;
+      }
+      if (!inString && ch === '/' && content[i + 1] === '*') {
+        // Skip until */
+        i += 2;
+        while(i < content.length && !(content[i] === '*' && content[i + 1] === '/'))i++;
+        i++; // skip past */
+        result += ' ';
+        continue;
+      }
+      result += ch;
+    }
+    return JSON.parse(result);
+  } catch  {
+    return null;
+  }
+}
+/**
+ * Walk up from startDir to find a deno.json with a "workspace" field.
+ */ export function findWorkspaceRoot(startDir) {
+  let dir = resolve(startDir);
+  const fsRoot = resolve('/');
+  while(dir !== fsRoot && dir !== resolve(dir, '..')){
+    const cfg = tryReadJson(resolve(dir, 'deno.json'));
+    if (cfg?.workspace && Array.isArray(cfg.workspace)) return dir;
+    dir = resolve(dir, '..');
+  }
+  return null;
+}
+/**
+ * Generate Vite resolve.alias from workspace packages' deno.json exports.
+ * Subpath aliases come before parent (Vite prefix matching rule).
+ */ export function generateWorkspaceAliases(workspaceRoot) {
+  const rootCfg = tryReadJson(resolve(workspaceRoot, 'deno.json'));
+  if (!rootCfg) return [];
+  const members = rootCfg.workspace || [];
+  const aliases = [];
+  for (const member of members){
+    const memberDir = resolve(workspaceRoot, member);
+    const memberCfg = tryReadJson(resolve(memberDir, 'deno.json'));
+    if (!memberCfg) continue;
+    const name = memberCfg.name;
+    const exports = memberCfg.exports;
+    if (!name || !exports) continue;
+    if (typeof exports === 'string') {
+      aliases.push({
+        find: name,
+        replacement: resolve(memberDir, exports)
+      });
+      continue;
+    }
+    // Subpath aliases first (Vite prefix matching)
+    for (const [exportPath, sourcePath] of Object.entries(exports)){
+      if (exportPath === '.') continue;
+      const subpath = exportPath.replace(/^\.\//, '/');
+      aliases.push({
+        find: `${name}${subpath}`,
+        replacement: resolve(memberDir, sourcePath)
+      });
+    }
+    // Parent alias last. Subpath aliases above already handle every exported
+    // subpath, so a direct import of the package name resolves to the "./"
+    // export entry without falling through to directory-index heuristics.
+    if (exports['.']) {
+      aliases.push({
+        find: name,
+        replacement: resolve(memberDir, exports['.'])
+      });
+    }
+  }
+  return aliases;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["file:///home/runner/work/openelement/openelement/packages/adapter-vite/src/workspace-alias.ts"],"sourcesContent":["import { Deno } from \"@deno/shim-deno\";\n/**\n * @openelement/adapter-vite - Workspace alias auto-generation\n *\n * Reads Deno workspace deno.json exports and generates\n * Vite resolve.alias entries. Uses sync Deno APIs so it\n * can run in synchronous plugin hooks (config, configResolved).\n */\n\nimport { resolve } from 'node:path';\n\nexport interface AliasEntry {\n  find: string;\n  replacement: string;\n}\n\nfunction tryReadJson(path: string): Record<string, unknown> | null {\n  try {\n    // H-12 fix: Use platform-appropriate file reading API\n    // Deno.readTextFileSync in Deno environments, node:fs in Node.js (Vite)\n    const content = typeof Deno !== 'undefined'\n      ? Deno.readTextFileSync(path)\n      : require('node:fs').readFileSync(path, 'utf-8');\n    // deno.json files may contain comments - strip them before JSON.parse.\n    // Naive regex breaks URLs (https:// -> https:), so we walk character by character,\n    // tracking whether we're inside a string literal.\n    let result = '';\n    let inString = false;\n    let escape = false;\n    for (let i = 0; i < content.length; i++) {\n      const ch = content[i];\n      if (escape) {\n        result += ch;\n        escape = false;\n        continue;\n      }\n      if (ch === '\\\\') {\n        result += ch;\n        escape = true;\n        continue;\n      }\n      if (ch === '\"') {\n        inString = !inString;\n        result += ch;\n        continue;\n      }\n      if (!inString && ch === '/' && content[i + 1] === '/') {\n        // Skip until end of line\n        while (i < content.length && content[i] !== '\\n') i++;\n        result += '\\n';\n        continue;\n      }\n      if (!inString && ch === '/' && content[i + 1] === '*') {\n        // Skip until */\n        i += 2;\n        while (i < content.length && !(content[i] === '*' && content[i + 1] === '/')) i++;\n        i++; // skip past */\n        result += ' ';\n        continue;\n      }\n      result += ch;\n    }\n    return JSON.parse(result);\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Walk up from startDir to find a deno.json with a \"workspace\" field.\n */\nexport function findWorkspaceRoot(startDir: string): string | null {\n  let dir = resolve(startDir);\n  const fsRoot = resolve('/');\n  while (dir !== fsRoot && dir !== resolve(dir, '..')) {\n    const cfg = tryReadJson(resolve(dir, 'deno.json'));\n    if (cfg?.workspace && Array.isArray(cfg.workspace)) return dir;\n    dir = resolve(dir, '..');\n  }\n  return null;\n}\n\n/**\n * Generate Vite resolve.alias from workspace packages' deno.json exports.\n * Subpath aliases come before parent (Vite prefix matching rule).\n */\nexport function generateWorkspaceAliases(workspaceRoot: string): AliasEntry[] {\n  const rootCfg = tryReadJson(resolve(workspaceRoot, 'deno.json'));\n  if (!rootCfg) return [];\n\n  const members: string[] = (rootCfg.workspace as string[]) || [];\n  const aliases: AliasEntry[] = [];\n\n  for (const member of members) {\n    const memberDir = resolve(workspaceRoot, member);\n    const memberCfg = tryReadJson(resolve(memberDir, 'deno.json'));\n    if (!memberCfg) continue;\n\n    const name = memberCfg.name as string | undefined;\n    const exports = memberCfg.exports as\n      | Record<string, string>\n      | string\n      | undefined;\n    if (!name || !exports) continue;\n\n    if (typeof exports === 'string') {\n      aliases.push({ find: name, replacement: resolve(memberDir, exports) });\n      continue;\n    }\n\n    // Subpath aliases first (Vite prefix matching)\n    for (const [exportPath, sourcePath] of Object.entries(exports)) {\n      if (exportPath === '.') continue;\n      const subpath = exportPath.replace(/^\\.\\//, '/');\n      aliases.push({\n        find: `${name}${subpath}`,\n        replacement: resolve(memberDir, sourcePath as string),\n      });\n    }\n    // Parent alias last. Subpath aliases above already handle every exported\n    // subpath, so a direct import of the package name resolves to the \"./\"\n    // export entry without falling through to directory-index heuristics.\n    if (exports['.']) {\n      aliases.push({\n        find: name,\n        replacement: resolve(memberDir, exports['.'] as string),\n      });\n    }\n  }\n  return aliases;\n}\n"],"names":[],"mappings":"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"}