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

package/dist/import-vm.test.mjs

@@ -0,0 +1,653 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createVmImport } from "./import-vm.mjs";
+describe("createVmImport", () => {
+  let tempDir;
+  let vmImport;
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "import-vm-test-"));
+    vmImport = createVmImport(new URL(`file://${tempDir}/`));
+  });
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+  describe("basic module loading", () => {
+    it("should load a simple ES module", async () => {
+      const modulePath = path.join(tempDir, "simple.mjs");
+      fs.writeFileSync(
+        modulePath,
+        `export const value = 42;
+export default 'hello';`
+      );
+      const namespace = await vmImport(
+        "./simple.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.value).toBe(42);
+      expect(namespace.default).toBe("hello");
+    });
+    it("should load a module with multiple exports", async () => {
+      const modulePath = path.join(tempDir, "math.mjs");
+      fs.writeFileSync(
+        modulePath,
+        `export const add = (a, b) => a + b;
+export const mul = (a, b) => a * b;`
+      );
+      const namespace = await vmImport(
+        "./math.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.add(2, 3)).toBe(5);
+      expect(namespace.mul(4, 5)).toBe(20);
+    });
+    it("should provide correct import.meta", async () => {
+      const modulePath = path.join(tempDir, "meta.mjs");
+      fs.writeFileSync(
+        modulePath,
+        `export const url = import.meta.url;
+export const filename = import.meta.filename;`
+      );
+      const namespace = await vmImport(
+        "./meta.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.url).toMatch(/^file:\/\/\//);
+      expect(namespace.url).toContain("meta.mjs");
+      expect(namespace.filename).toBe(modulePath);
+    });
+  });
+  describe("module dependencies", () => {
+    it("should load a module that imports another module", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "helper.mjs"),
+        `export const helper = () => 'helper-value';`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "main.mjs"),
+        `import { helper } from './helper.mjs';
+export const result = helper();`
+      );
+      const namespace = await vmImport(
+        "./main.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.result).toBe("helper-value");
+    });
+    it("should load deeply nested module chains", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "a.mjs"),
+        `export const a = 'A';`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "b.mjs"),
+        `import { a } from './a.mjs';
+export const b = a + 'B';`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "c.mjs"),
+        `import { b } from './b.mjs';
+export const c = b + 'C';`
+      );
+      const namespace = await vmImport(
+        "./c.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.c).toBe("ABC");
+    });
+  });
+  describe("circular dependencies", () => {
+    it("should handle A -> B -> A circular reference", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "a.mjs"),
+        `import * as b from './b.mjs';
+export const a = 'A';
+export const getB = () => b.b;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "b.mjs"),
+        `import * as a from './a.mjs';
+export const b = 'B';
+export const getA = () => a.a;`
+      );
+      const namespace = await vmImport(
+        "./a.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.a).toBe("A");
+      expect(namespace.getB()).toBe("B");
+    });
+    it("should handle self-reference (A -> A)", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "self.mjs"),
+        `import * as self from './self.mjs';
+export const foo = 'bar';
+export const hasSelf = () => typeof self === 'object';`
+      );
+      const namespace = await vmImport(
+        "./self.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.foo).toBe("bar");
+      expect(namespace.hasSelf()).toBe(true);
+    });
+    it("should handle three-way circular reference", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "x.mjs"),
+        `import * as y from './y.mjs';
+export const x = 'X';
+export const getY = () => y.y;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "y.mjs"),
+        `import * as z from './z.mjs';
+export const y = 'Y';
+export const getZ = () => z.z;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "z.mjs"),
+        `import * as x from './x.mjs';
+export const z = 'Z';
+export const getX = () => x.x;`
+      );
+      const namespace = await vmImport(
+        "./x.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.x).toBe("X");
+      expect(namespace.getY()).toBe("Y");
+    });
+  });
+  describe("builtin modules", () => {
+    it("should load node:path module", async () => {
+      const namespace = await vmImport(
+        "node:path",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(typeof namespace.join).toBe("function");
+      expect(namespace.join("/a", "b")).toBe(path.join("/a", "b"));
+    });
+    it("should load node:fs module", async () => {
+      const namespace = await vmImport(
+        "node:fs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(typeof namespace.readFileSync).toBe("function");
+    });
+    it("should load node:os module", async () => {
+      const namespace = await vmImport(
+        "node:os",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(typeof namespace.platform).toBe("function");
+    });
+    it("should load builtin module as dependency of user module", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "uses-path.mjs"),
+        `import { join } from 'node:path';
+export const result = join('/test', 'file.txt');`
+      );
+      const namespace = await vmImport(
+        "./uses-path.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.result).toBe(path.join("/test", "file.txt"));
+    });
+  });
+  describe("caching", () => {
+    it("should cache loaded modules within a single vmImport call", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "counter.mjs"),
+        `export let count = 0;
+export const increment = () => ++count;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "consumer.mjs"),
+        `import { count, increment } from './counter.mjs';
+export const getCount = () => count;
+export const inc = increment;`
+      );
+      const ns = await vmImport(
+        "./consumer.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(ns.getCount()).toBe(0);
+      ns.inc();
+      expect(ns.getCount()).toBe(1);
+    });
+    it("should not share cache across separate vmImport calls", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "state.mjs"),
+        `export let value = Math.random();`
+      );
+      const ns1 = await vmImport(
+        "./state.mjs",
+        `file://${tempDir}/a.mjs`
+      );
+      const ns2 = await vmImport(
+        "./state.mjs",
+        `file://${tempDir}/b.mjs`
+      );
+      expect(ns1.value).not.toBe(ns2.value);
+    });
+    it("should cache shared dependencies within single vmImport call", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "shared-dep.mjs"),
+        `export let counter = 0;
+export const inc = () => ++counter;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "user-a.mjs"),
+        `import { counter, inc } from './shared-dep.mjs';
+export const getCount = () => counter;
+export const increment = inc;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "user-b.mjs"),
+        `import { counter, inc } from './shared-dep.mjs';
+export const getCount = () => counter;
+export const increment = inc;`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "main-cache.mjs"),
+        `import * as a from './user-a.mjs';
+import * as b from './user-b.mjs';
+export const aCount = a.getCount;
+export const bCount = b.getCount;
+export const aInc = a.increment;
+export const bInc = b.increment;`
+      );
+      const ns = await vmImport(
+        "./main-cache.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(ns.aCount()).toBe(0);
+      expect(ns.bCount()).toBe(0);
+      ns.aInc();
+      expect(ns.aCount()).toBe(1);
+      expect(ns.bCount()).toBe(1);
+      ns.bInc();
+      expect(ns.aCount()).toBe(2);
+      expect(ns.bCount()).toBe(2);
+    });
+  });
+  describe("dynamic import", () => {
+    it("should handle dynamic import() inside VM module", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "lazy.mjs"),
+        `export const lazy = 'lazy-value';`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "dynamic.mjs"),
+        `export const result = await import('./lazy.mjs').then(m => m.lazy);`
+      );
+      const namespace = await vmImport(
+        "./dynamic.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.result).toBe("lazy-value");
+    });
+    it("should handle dynamic import of already cached module", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "dep.mjs"),
+        `export const value = 'dep-value';`
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "dynamic-cache.mjs"),
+        `import { value } from './dep.mjs';
+export const staticValue = value;
+export const dynamicValue = await import('./dep.mjs').then(m => m.value);`
+      );
+      const namespace = await vmImport(
+        "./dynamic-cache.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.staticValue).toBe("dep-value");
+      expect(namespace.dynamicValue).toBe("dep-value");
+    });
+  });
+  describe("error handling", () => {
+    it("should throw FileReadError for non-existent module", async () => {
+      await expect(
+        vmImport("./non-existent.mjs", `file://${tempDir}/entry.mjs`)
+      ).rejects.toThrow("Failed to read module");
+    });
+    it("should throw for syntax errors in module", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "bad-syntax.mjs"),
+        `export const x = {`
+        // 语法错误
+      );
+      await expect(
+        vmImport("./bad-syntax.mjs", `file://${tempDir}/entry.mjs`)
+      ).rejects.toThrow();
+    });
+    it("should throw for runtime errors during module evaluation", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "runtime-error.mjs"),
+        `throw new Error('Runtime error');`
+      );
+      await expect(
+        vmImport("./runtime-error.mjs", `file://${tempDir}/entry.mjs`)
+      ).rejects.toThrow("Runtime error");
+    });
+  });
+  describe("sandbox", () => {
+    it("should create isolated context", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "global.mjs"),
+        `if (typeof globalThis.customVar === 'undefined') {
+  globalThis.customVar = 'set';
+}
+export const hasVar = globalThis.customVar;`
+      );
+      const ns1 = await vmImport(
+        "./global.mjs",
+        `file://${tempDir}/entry.mjs`,
+        {}
+      );
+      expect(ns1.hasVar).toBe("set");
+      const ns2 = await vmImport(
+        "./global.mjs",
+        `file://${tempDir}/entry.mjs`,
+        {}
+      );
+      expect(ns2.hasVar).toBe("set");
+    });
+  });
+  describe("import map", () => {
+    it("should resolve specifiers using import map", async () => {
+      fs.writeFileSync(
+        path.join(tempDir, "lib.mjs"),
+        `export const lib = 'library';`
+      );
+      const importMap = {
+        imports: {
+          "#lib": `file://${tempDir}/lib.mjs`
+        }
+      };
+      const vmImportWithMap = createVmImport(
+        new URL(`file://${tempDir}/`),
+        importMap
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "app.mjs"),
+        `import { lib } from '#lib';
+export const result = lib;`
+      );
+      const namespace = await vmImportWithMap(
+        "./app.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.result).toBe("library");
+    });
+  });
+  describe("in-memory filesystem", () => {
+    let memfs;
+    let memImport;
+    const memBase = process.platform === "win32" ? "C:\\project" : "/project";
+    const memBaseURL = new URL(`file://${memBase}/`);
+    const memEntry = `file://${memBase}/entry.mjs`;
+    const memPath = (filename) => path.join(memBase, filename);
+    const createMemRead = () => (filepath) => {
+      const content = memfs.get(filepath);
+      if (content === void 0) {
+        const err = new Error(
+          `ENOENT: no such file or directory, open '${filepath}'`
+        );
+        err.code = "ENOENT";
+        throw err;
+      }
+      return content;
+    };
+    beforeEach(() => {
+      memfs = /* @__PURE__ */ new Map();
+      memImport = createVmImport(
+        memBaseURL,
+        {},
+        {
+          readFileSync: createMemRead()
+        }
+      );
+    });
+    it("should load a simple ES module from memory", async () => {
+      memfs.set(memPath("simple.mjs"), `export const value = 42;`);
+      const namespace = await memImport("./simple.mjs", memEntry);
+      expect(namespace.value).toBe(42);
+    });
+    it("should load a module with multiple exports from memory", async () => {
+      memfs.set(
+        memPath("math.mjs"),
+        `export const add = (a, b) => a + b;
+export const mul = (a, b) => a * b;`
+      );
+      const namespace = await memImport("./math.mjs", memEntry);
+      expect(namespace.add(2, 3)).toBe(5);
+      expect(namespace.mul(4, 5)).toBe(20);
+    });
+    it("should load a module that imports another module from memory", async () => {
+      memfs.set(
+        memPath("helper.mjs"),
+        `export const helper = () => 'helper-value';`
+      );
+      memfs.set(
+        memPath("main.mjs"),
+        `import { helper } from './helper.mjs';
+export const result = helper();`
+      );
+      const namespace = await memImport("./main.mjs", memEntry);
+      expect(namespace.result).toBe("helper-value");
+    });
+    it("should handle deeply nested module chains from memory", async () => {
+      memfs.set(memPath("a.mjs"), `export const a = 'A';`);
+      memfs.set(
+        memPath("b.mjs"),
+        `import { a } from './a.mjs';
+export const b = a + 'B';`
+      );
+      memfs.set(
+        memPath("c.mjs"),
+        `import { b } from './b.mjs';
+export const c = b + 'C';`
+      );
+      const namespace = await memImport("./c.mjs", memEntry);
+      expect(namespace.c).toBe("ABC");
+    });
+    it("should handle A -> B -> A circular reference from memory", async () => {
+      memfs.set(
+        memPath("a.mjs"),
+        `import * as b from './b.mjs';
+export const a = 'A';
+export const getB = () => b.b;`
+      );
+      memfs.set(
+        memPath("b.mjs"),
+        `import * as a from './a.mjs';
+export const b = 'B';
+export const getA = () => a.a;`
+      );
+      const namespace = await memImport("./a.mjs", memEntry);
+      expect(namespace.a).toBe("A");
+      expect(namespace.getB()).toBe("B");
+    });
+    it("should cache loaded modules within a single memImport call", async () => {
+      memfs.set(
+        memPath("counter.mjs"),
+        `export let count = 0;
+export const increment = () => ++count;`
+      );
+      memfs.set(
+        memPath("consumer.mjs"),
+        `import { count, increment } from './counter.mjs';
+export const getCount = () => count;
+export const inc = increment;`
+      );
+      const ns = await memImport("./consumer.mjs", memEntry);
+      expect(ns.getCount()).toBe(0);
+      ns.inc();
+      expect(ns.getCount()).toBe(1);
+    });
+    it("should handle dynamic import() inside VM module from memory", async () => {
+      memfs.set(memPath("lazy.mjs"), `export const lazy = 'lazy-value';`);
+      memfs.set(
+        memPath("dynamic.mjs"),
+        `export const result = await import('./lazy.mjs').then(m => m.lazy);`
+      );
+      const namespace = await memImport("./dynamic.mjs", memEntry);
+      expect(namespace.result).toBe("lazy-value");
+    });
+    it("should throw FileReadError for non-existent module in memory", async () => {
+      await expect(
+        memImport("./non-existent.mjs", memEntry)
+      ).rejects.toThrow("Failed to read module");
+    });
+    it("should resolve specifiers using import map with memory fs", async () => {
+      memfs.set(memPath("lib.mjs"), `export const lib = 'library';`);
+      const importMap = {
+        imports: {
+          "#lib": `file://${memBase}/lib.mjs`
+        }
+      };
+      const vmImportWithMap = createVmImport(memBaseURL, importMap, {
+        readFileSync: createMemRead()
+      });
+      memfs.set(
+        memPath("app.mjs"),
+        `import { lib } from '#lib';
+export const result = lib;`
+      );
+      const namespace = await vmImportWithMap("./app.mjs", memEntry);
+      expect(namespace.result).toBe("library");
+    });
+    it("should provide correct import.meta with memory fs", async () => {
+      memfs.set(
+        memPath("meta.mjs"),
+        `export const url = import.meta.url;
+export const filename = import.meta.filename;`
+      );
+      const namespace = await memImport("./meta.mjs", memEntry);
+      expect(namespace.url).toBe(new URL("meta.mjs", memBaseURL).href);
+      expect(namespace.filename).toBe(memPath("meta.mjs"));
+    });
+  });
+  describe("style asset imports", () => {
+    it("does not parse .css as JS \u2014 side-effect import resolves cleanly", async () => {
+      const cssPath = path.join(tempDir, "styles.css");
+      fs.writeFileSync(
+        cssPath,
+        "/* contains a dot selector \u2014 would crash the JS parser */\n.btn { color: red; }"
+      );
+      const consumerPath = path.join(tempDir, "consumer.mjs");
+      fs.writeFileSync(
+        consumerPath,
+        `import './styles.css';
+export const ok = true;`
+      );
+      const namespace = await vmImport(
+        "./consumer.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.ok).toBe(true);
+    });
+    it("exposes the asset URL as default + href named export", async () => {
+      const cssPath = path.join(tempDir, "theme.css");
+      fs.writeFileSync(cssPath, ":root { --x: 1; }");
+      const consumerPath = path.join(tempDir, "consumer.mjs");
+      fs.writeFileSync(
+        consumerPath,
+        `import url, { href } from './theme.css';
+export { url, href };`
+      );
+      const namespace = await vmImport(
+        "./consumer.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      const expected = new URL("theme.css", `file://${tempDir}/`).href;
+      expect(namespace.url).toBe(expected);
+      expect(namespace.href).toBe(expected);
+    });
+    it.each([
+      "scss",
+      "sass",
+      "less",
+      "stylus",
+      "styl",
+      "pcss",
+      "postcss"
+    ])("treats .%s as a style asset", async (ext) => {
+      const assetPath = path.join(tempDir, `styles.${ext}`);
+      fs.writeFileSync(
+        assetPath,
+        ".x { color: red; } // would crash JS parser"
+      );
+      const consumerPath = path.join(tempDir, `c-${ext}.mjs`);
+      fs.writeFileSync(
+        consumerPath,
+        `import './styles.${ext}';
+export const ok = true;`
+      );
+      const namespace = await vmImport(
+        `./c-${ext}.mjs`,
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.ok).toBe(true);
+    });
+    it("tolerates query-string suffixes (?inline, ?url)", async () => {
+      const cssPath = path.join(tempDir, "q.css");
+      fs.writeFileSync(cssPath, ".q {}");
+      const consumerPath = path.join(tempDir, "qc.mjs");
+      fs.writeFileSync(
+        consumerPath,
+        `import './q.css?inline';
+export const ok = true;`
+      );
+      const namespace = await vmImport(
+        "./qc.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.ok).toBe(true);
+    });
+    it("caches style modules \u2014 same URL imported twice yields one module", async () => {
+      const cssPath = path.join(tempDir, "shared.css");
+      fs.writeFileSync(cssPath, ".s {}");
+      const aPath = path.join(tempDir, "a.mjs");
+      const bPath = path.join(tempDir, "b.mjs");
+      const rootPath = path.join(tempDir, "root.mjs");
+      fs.writeFileSync(
+        aPath,
+        `import url from './shared.css';
+export { url as a };`
+      );
+      fs.writeFileSync(
+        bPath,
+        `import url from './shared.css';
+export { url as b };`
+      );
+      fs.writeFileSync(
+        rootPath,
+        `export { a } from './a.mjs';
+export { b } from './b.mjs';`
+      );
+      const namespace = await vmImport(
+        "./root.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.a).toBeDefined();
+      expect(namespace.a).toBe(namespace.b);
+    });
+    it("does not affect non-style imports", async () => {
+      const jsPath = path.join(tempDir, "normal.mjs");
+      fs.writeFileSync(
+        jsPath,
+        'export const value = 42;\nexport default "x";'
+      );
+      const namespace = await vmImport(
+        "./normal.mjs",
+        `file://${tempDir}/entry.mjs`
+      );
+      expect(namespace.value).toBe(42);
+      expect(namespace.default).toBe("x");
+    });
+  });
+});

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { CircularDependencyError, FileReadError, formatCircularDependency, formatModuleChain, ModuleLoadingError } from './error';
 export { createLoaderImport } from './import-loader';
-export { createVmImport } from './import-vm';
-export type { ImportMap, ScopesMap, SpecifierMap } from './types';
+export { createVmImport, type VmImportOptions } from './import-vm';
+export type { ImportMap, IntegrityMap, ScopesMap, SpecifierMap } from './types';

package/dist/types.d.ts

@@ -1,7 +1,14 @@
 export type SpecifierMap = Record<string, string>;
 export type ScopesMap = Record<string, SpecifierMap>;
+export type IntegrityMap = Record<string, string>;
 export interface ImportMap {
     imports?: SpecifierMap;
     scopes?: ScopesMap;
+    /**
+     * Subresource Integrity metadata, mapping module URLs to integrity hashes.
+     * Part of the Import Maps specification; ignored by browsers that do not
+     * support it.
+     */
+    integrity?: IntegrityMap;
 }
 export type ImportMapResolver = (specifier: string, parent: string) => string | null;