@esmx/import 3.0.0-rc.116 → 3.0.0-rc.118

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Esmx Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -55,6 +55,13 @@ yarn add @esmx/import
 import { createVmImport } from '@esmx/import';
 import { pathToFileURL } from 'node:url';
 
+const baseURL = pathToFileURL('/project');
+const importMap = {
+    imports: {
+        'my-app/src/utils': '/project/src/utils.mjs'
+    }
+};
+
 const vmImport = createVmImport(baseURL, importMap);
 const module = await vmImport('my-app/src/utils', import.meta.url);
 ```
@@ -124,7 +131,7 @@ const loaderImport = createLoaderImport(baseURL, importMap);
 const module = await loaderImport(specifier);
 ```
 
-### ImportMap Format
+### Import Map Format
 ```typescript
 interface ImportMap {
   imports?: Record<string, string>;

package/README.zh-CN.md

@@ -20,7 +20,7 @@
     </a>
   </div>
   
-  <p>为 Esmx 框架提供 Import Maps 的 Node.js 服务端实现</p>
+  <p>为 Esmx 框架提供 Import Map 的 Node.js 服务端实现</p>
   
   <p>
     <a href="https://github.com/esmnext/esmx/blob/master/packages/import/README.md">English</a> | 中文
@@ -31,10 +31,10 @@
 
 - **双重实现** - 开发环境使用 VM 模式，生产环境使用 Loader 模式
 - **热重载支持** - VM 模式支持多次创建，提供开发灵活性
-- **高性能** - Loader 模式为生产部署优化
+- **高性能** - Loader 模式针对生产环境优化
 - **Node.js 专注** - 专为 Node.js 服务端环境设计
-- **TypeScript 就绪** - 完整的 TypeScript 支持，出色的类型安全
-- **ESM 标准** - 完全符合 Import Maps 规范
+- **TypeScript 支持** - 完整的 TypeScript 类型安全
+- **ESM 标准** - 完全符合 Import Map 规范
 
 ## 📦 安装
 
@@ -55,13 +55,20 @@ yarn add @esmx/import
 import { createVmImport } from '@esmx/import';
 import { pathToFileURL } from 'node:url';
 
+const baseURL = pathToFileURL('/project');
+const importMap = {
+    imports: {
+        'my-app/src/utils': '/project/src/utils.mjs'
+    }
+};
+
 const vmImport = createVmImport(baseURL, importMap);
 const module = await vmImport('my-app/src/utils', import.meta.url);
 ```
 
 ## 📖 模式对比
 
-`@esmx/import` 提供两种不同的 Import Maps 实现方式：
+`@esmx/import` 提供两种不同的 Import Map 实现方式：
 
 | 特性 | VM 模式 | Loader 模式 |
 |------|---------|-------------|
@@ -124,7 +131,7 @@ const loaderImport = createLoaderImport(baseURL, importMap);
 const module = await loaderImport(specifier);
 ```
 
-### ImportMap 格式
+### Import Map 格式
 ```typescript
 interface ImportMap {
   imports?: Record<string, string>;

package/dist/error.test.mjs

@@ -163,5 +163,43 @@ describe("Module Loading Errors", () => {
         `        \u2514\u2500 ${relativeE} \u274C Loading failed`
       );
     });
+    it("should handle formatModuleChain with original error", () => {
+      const moduleIds = [];
+      const targetModule = "/src/error.js";
+      const originalError = new Error("Original error message");
+      const formatted = formatModuleChain(
+        moduleIds,
+        targetModule,
+        originalError
+      );
+      expect(formatted).toContain("Error details:");
+      expect(formatted).toContain("Original error message");
+    });
+  });
+  describe("ModuleLoadingError base class", () => {
+    it("should create base error with all properties", () => {
+      const moduleIds = ["/src/a.js"];
+      const targetModule = "/src/b.js";
+      const originalError = new Error("cause");
+      const error = new ModuleLoadingError(
+        "Base error",
+        moduleIds,
+        targetModule,
+        originalError
+      );
+      expect(error.name).toBe("ModuleLoadingError");
+      expect(error.message).toBe("Base error");
+      expect(error.moduleIds).toEqual(moduleIds);
+      expect(error.targetModule).toBe(targetModule);
+      expect(error.originalError).toBe(originalError);
+    });
+    it("should create base error without original error", () => {
+      const error = new ModuleLoadingError(
+        "Simple error",
+        [],
+        "/src/x.js"
+      );
+      expect(error.originalError).toBeUndefined();
+    });
   });
 });

package/dist/import-loader.mjs

@@ -13,14 +13,17 @@ export function createLoaderImport(baseURL, importMap = {}) {
     registered = JSON.stringify(importMap);
   } else if (registered !== JSON.stringify(importMap)) {
     throw new Error(
-      `'createLoaderImport()' can only be created once and cannot be created repeatedly`
+      `[@esmx/import] createLoaderImport() is a per-process singleton and was called twice with different importMap data. Ensure your app initializes the loader exactly once at startup.`
     );
   }
   return (specifier) => {
     try {
       return import(specifier);
     } catch (e) {
-      throw new Error(`Failed to import '${specifier}'`);
+      const cause = e instanceof Error ? e.message : String(e);
+      throw new Error(
+        `[@esmx/import] Failed to import '${specifier}'. Verify the specifier is declared in the importMap (modules.imports in entry.node.ts) or matches a federated module name. Original error: ${cause}`
+      );
     }
   };
 }

package/dist/import-vm.d.ts

@@ -1,3 +1,6 @@
 import vm from 'node:vm';
 import type { ImportMap } from './types';
-export declare function createVmImport(baseURL: URL, importMap?: ImportMap): (specifier: string, parent: string, sandbox?: vm.Context, options?: vm.CreateContextOptions) => Promise<any>;
+export interface VmImportOptions {
+    readFileSync?: (path: string) => string;
+}
+export declare function createVmImport(baseURL: URL, importMap?: ImportMap, options?: VmImportOptions): (specifier: string, parent: string, sandbox?: vm.Context, options?: vm.CreateContextOptions) => Promise<Record<string, any>>;

package/dist/import-vm.mjs

@@ -1,10 +1,23 @@
 import fs from "node:fs";
-import { isBuiltin } from "node:module";
+import { createRequire, isBuiltin } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import vm from "node:vm";
-import { CircularDependencyError, FileReadError } from "./error.mjs";
+import { FileReadError } from "./error.mjs";
 import { createImportMapResolver } from "./import-map-resolve.mjs";
+const requireSync = createRequire(import.meta.url);
+const STYLE_ASSET_RE = /\.(?:css|scss|sass|less|stylus|styl|pcss|postcss)(?:\?.*)?$/i;
+function isStyleAsset(url) {
+  return STYLE_ASSET_RE.test(url);
+}
+let lazyGlobalsMaterialized = false;
+function materializeLazyGlobals() {
+  if (lazyGlobalsMaterialized) {
+    return;
+  }
+  lazyGlobalsMaterialized = true;
+  void globalThis.DOMException;
+}
 async function importBuiltinModule(specifier, context) {
   const nodeModule = await import(specifier);
   const keys = Object.keys(nodeModule);
@@ -26,7 +39,8 @@ async function importBuiltinModule(specifier, context) {
   await module.evaluate();
   return module;
 }
-export function createVmImport(baseURL, importMap = {}) {
+export function createVmImport(baseURL, importMap = {}, options) {
+  const readFileSync = options?.readFileSync ?? ((path2) => fs.readFileSync(path2, "utf-8"));
   const importMapResolver = createImportMapResolver(baseURL.href, importMap);
   const buildMeta = (specifier, parent) => {
     const result = importMapResolver(specifier, parent);
@@ -42,77 +56,141 @@ export function createVmImport(baseURL, importMap = {}) {
       }
     };
   };
-  async function moduleLinker(specifier, parent, context, cache, moduleIds) {
+  function syncLinker(specifier, parent, context, cache, linkStatus, moduleIds) {
     if (isBuiltin(specifier)) {
-      return importBuiltinModule(specifier, context);
-    }
-    const meta = buildMeta(specifier, parent);
-    if (moduleIds.includes(meta.url)) {
-      throw new CircularDependencyError(
-        "Circular dependency detected",
-        moduleIds,
-        meta.filename
+      const nodeModule = requireSync(specifier);
+      const keys = Object.keys(nodeModule);
+      const hasDefault = keys.includes("default");
+      if (!hasDefault) {
+        keys.push("default");
+      }
+      const module2 = new vm.SyntheticModule(
+        keys,
+        function evaluateCallback() {
+          keys.forEach((key) => {
+            this.setExport(
+              key,
+              key === "default" && !hasDefault ? nodeModule : nodeModule[key]
+            );
+          });
+        },
+        {
+          identifier: specifier,
+          context
+        }
       );
+      const linkResult = module2.link(() => {
+        throw new TypeError(`Native modules should not be linked`);
+      });
+      const linkPromise2 = linkResult && typeof linkResult.then === "function" ? linkResult.then(() => module2.evaluate()) : module2.evaluate();
+      linkStatus.set(specifier, linkPromise2);
+      return module2;
     }
-    const module = cache.get(meta.url);
-    if (module) {
-      return module;
+    const meta = buildMeta(specifier, parent);
+    const cachedModule = cache.get(meta.url);
+    if (cachedModule) {
+      return cachedModule;
     }
-    const modulePromise = new Promise((resolve) => {
-      process.nextTick(() => {
-        moduleBuild().then(resolve);
-      });
-    });
-    cache.set(meta.url, modulePromise);
-    return modulePromise;
-    async function moduleBuild() {
-      let text;
-      try {
-        text = fs.readFileSync(meta.filename, "utf-8");
-      } catch (error) {
-        throw new FileReadError(
-          `Failed to read module: ${meta.filename}`,
-          moduleIds,
-          meta.filename,
-          error
-        );
-      }
-      const module2 = new vm.SourceTextModule(text, {
-        initializeImportMeta: (importMeta) => {
-          Object.assign(importMeta, meta);
+    if (isStyleAsset(meta.url)) {
+      const exportNames = ["default", "href"];
+      const styleModule = new vm.SyntheticModule(
+        exportNames,
+        function evaluateCallback() {
+          this.setExport("default", meta.url);
+          this.setExport("href", meta.url);
         },
-        identifier: specifier,
-        context,
-        importModuleDynamically: (specifier2, referrer) => {
-          return moduleLinker(
-            specifier2,
-            meta.url,
-            referrer.context,
-            cache,
-            [...moduleIds, meta.filename]
-          );
-        }
+        { identifier: specifier, context }
+      );
+      cache.set(meta.url, styleModule);
+      const linkResult = styleModule.link(() => {
+        throw new TypeError(
+          `Style modules should not be linked: ${specifier}`
+        );
       });
-      await module2.link((specifier2, referrer) => {
+      const linkPromise2 = linkResult && typeof linkResult.then === "function" ? linkResult.then(() => styleModule.evaluate()) : styleModule.evaluate();
+      linkStatus.set(meta.url, linkPromise2);
+      return styleModule;
+    }
+    let text;
+    try {
+      text = readFileSync(meta.filename);
+    } catch (error) {
+      throw new FileReadError(
+        `Failed to read module: ${meta.filename}`,
+        moduleIds,
+        meta.filename,
+        error
+      );
+    }
+    const module = new vm.SourceTextModule(text, {
+      initializeImportMeta: (importMeta) => {
+        Object.assign(importMeta, meta);
+      },
+      identifier: specifier,
+      context,
+      importModuleDynamically: (specifier2, referrer) => {
         return moduleLinker(
           specifier2,
           meta.url,
           referrer.context,
           cache,
+          linkStatus,
           [...moduleIds, meta.filename]
         );
-      });
-      await module2.evaluate();
-      return module2;
+      }
+    });
+    cache.set(meta.url, module);
+    const linkPromise = module.link((specifier2, referrer) => {
+      return syncLinker(
+        specifier2,
+        meta.url,
+        referrer.context,
+        cache,
+        linkStatus,
+        [...moduleIds, meta.filename]
+      );
+    }).then(() => module.evaluate());
+    linkStatus.set(meta.url, linkPromise);
+    return module;
+  }
+  async function moduleLinker(specifier, parent, context, cache, linkStatus, moduleIds) {
+    if (isBuiltin(specifier)) {
+      return importBuiltinModule(specifier, context);
+    }
+    const meta = buildMeta(specifier, parent);
+    const cachedModule = cache.get(meta.url);
+    if (cachedModule) {
+      const status2 = linkStatus.get(meta.url);
+      if (status2) {
+        await status2;
+      }
+      return cachedModule;
+    }
+    const module = syncLinker(
+      specifier,
+      parent,
+      context,
+      cache,
+      linkStatus,
+      moduleIds
+    );
+    const status = linkStatus.get(meta.url);
+    if (status) {
+      await status;
     }
+    return module;
   }
-  return async (specifier, parent, sandbox, options) => {
-    const context = vm.createContext(sandbox, options);
+  return async (specifier, parent, sandbox, options2) => {
+    materializeLazyGlobals();
+    const context = vm.createContext(sandbox, options2);
+    const cache = /* @__PURE__ */ new Map();
+    const linkStatus = /* @__PURE__ */ new Map();
     const module = await moduleLinker(
       specifier,
       parent,
       context,
-      /* @__PURE__ */ new Map(),
+      cache,
+      linkStatus,
       []
     );
     return module.namespace;

package/dist/import-vm.test.d.ts

@@ -0,0 +1 @@
+export {};