@esmx/import 3.0.0-rc.10

package/dist/import-loader.d.ts

@@ -0,0 +1,12 @@
+import type { ImportMap } from './types';
+interface Data {
+    baseURL: string;
+    importMap: ImportMap;
+}
+/**
+ * 创建一个使用 loader 实现的 importmap 的 import 函数，只能创建一次，无热更新，适合生产使用。
+ */
+export declare function createLoaderImport(baseURL: URL, importMap?: ImportMap): (specifier: string) => Promise<Record<string, any>>;
+export declare function initialize(data: Data): void;
+export declare function resolve(specifier: string, context: Record<string, any>, nextResolve: Function): any;
+export {};

package/dist/import-loader.mjs

@@ -0,0 +1,37 @@
+import module from "node:module";
+import { fileURLToPath } from "node:url";
+import IM from "@import-maps/resolve";
+let registered = "";
+export function createLoaderImport(baseURL, importMap = {}) {
+  if (!registered) {
+    module.register(fileURLToPath(import.meta.url), {
+      parentURL: baseURL,
+      data: {
+        baseURL: baseURL.href,
+        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`
+    );
+  }
+  return (specifier) => {
+    return import(specifier);
+  };
+}
+let loaderBaseURL = new URL("file:");
+let loaderParsedImportMap = {};
+export function initialize(data) {
+  loaderBaseURL = new URL(data.baseURL);
+  loaderParsedImportMap = IM.parse(data.importMap, loaderBaseURL);
+}
+export function resolve(specifier, context, nextResolve) {
+  const scriptURL = new URL(context.parentURL);
+  const result = IM.resolve(specifier, loaderParsedImportMap, scriptURL);
+  if (result.matched && result.resolvedImport) {
+    return nextResolve(result.resolvedImport.href);
+  }
+  return nextResolve(specifier, context);
+}

package/dist/import-vm.d.ts

@@ -0,0 +1,6 @@
+import vm from 'node:vm';
+import type { ImportMap } from './types';
+/**
+ * 创建一个使用 vm 实现的 importmap 的 import 函数，可以创建多次来实现热更新效果，适合开发使用。
+ */
+export declare function createVmImport(baseURL: URL, importMap?: ImportMap): (specifier: string, parent: string, sandbox?: vm.Context, options?: vm.CreateContextOptions) => Promise<Record<string, any>>;

package/dist/import-vm.mjs

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import { isBuiltin } from "node:module";
+import path from "node:path";
+import vm from "node:vm";
+import IM from "@import-maps/resolve";
+async function importBuiltinModule(specifier, context) {
+  const nodeModule = await import(specifier);
+  const keys = Object.keys(nodeModule);
+  const module = new vm.SyntheticModule(
+    keys,
+    function evaluateCallback() {
+      keys.forEach((key) => {
+        this.setExport(key, nodeModule[key]);
+      });
+    },
+    {
+      identifier: specifier,
+      context
+    }
+  );
+  await module.link(() => {
+    throw new TypeError(`Native modules should not be linked`);
+  });
+  await module.evaluate();
+  return module;
+}
+export function createVmImport(baseURL, importMap = {}) {
+  const parsedImportMap = IM.parse(importMap, baseURL);
+  const parse = (specifier, parent) => {
+    const result = IM.resolve(specifier, parsedImportMap, new URL(parent));
+    let filename;
+    if (result.matched && result.resolvedImport) {
+      filename = result.resolvedImport.href;
+    } else {
+      filename = import.meta.resolve(specifier, parent);
+    }
+    const url = new URL(filename);
+    return {
+      filename,
+      url,
+      pathname: url.pathname
+    };
+  };
+  async function moduleLinker(specifier, parent, context, cache, moduleIds) {
+    if (isBuiltin(specifier)) {
+      return importBuiltinModule(specifier, context);
+    }
+    const parsed = parse(specifier, parent);
+    if (moduleIds.includes(parsed.pathname)) {
+      throw new RangeError(
+        `Module circular reference: 
+ ${JSON.stringify([...moduleIds, parsed.pathname], null, 4)}`
+      );
+    }
+    const module = cache.get(parsed.pathname);
+    if (module) {
+      return module;
+    }
+    const pe = new Promise((resolve) => {
+      process.nextTick(() => {
+        moduleBuild().then(resolve);
+      });
+    });
+    const dirname = path.dirname(parsed.filename);
+    cache.set(parsed.pathname, pe);
+    return pe;
+    async function moduleBuild() {
+      let text;
+      try {
+        text = fs.readFileSync(parsed.pathname, "utf-8");
+      } catch {
+        throw new Error(`Failed to read module: ${parsed.pathname}`);
+      }
+      const module2 = new vm.SourceTextModule(text, {
+        initializeImportMeta: (meta) => {
+          meta.filename = parsed.filename;
+          meta.dirname = dirname;
+          meta.resolve = (specifier2, parent2 = parsed.url) => {
+            return import.meta.resolve(specifier2, parent2);
+          };
+          meta.url = parsed.url.toString();
+        },
+        identifier: specifier,
+        context,
+        // @ts-ignore
+        importModuleDynamically: (specifier2, referrer) => {
+          return moduleLinker(
+            specifier2,
+            parsed.filename,
+            // @ts-ignore
+            referrer.context,
+            cache,
+            [...moduleIds, parsed.pathname]
+          );
+        }
+      });
+      await module2.link((specifier2, referrer) => {
+        return moduleLinker(
+          specifier2,
+          parsed.filename,
+          referrer.context,
+          cache,
+          [...moduleIds, parsed.pathname]
+        );
+      });
+      await module2.evaluate();
+      return module2;
+    }
+  }
+  return async (specifier, parent, sandbox, options) => {
+    const context = vm.createContext(sandbox, options);
+    const module = await moduleLinker(
+      specifier,
+      parent,
+      context,
+      /* @__PURE__ */ new Map(),
+      []
+    );
+    return module.namespace;
+  };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createVmImport } from './import-vm';
+export { createLoaderImport } from './import-loader';
+export type { ImportMap, SpecifierMap, ScopesMap } from './types';

package/dist/index.mjs

@@ -0,0 +1,2 @@
+export { createVmImport } from "./import-vm.mjs";
+export { createLoaderImport } from "./import-loader.mjs";

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export type SpecifierMap = Record<string, string>;
+export type ScopesMap = Record<string, SpecifierMap>;
+export interface ImportMap {
+    imports?: SpecifierMap;
+    scopes?: ScopesMap;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@esmx/import",
+    "template": "library-node",
+    "license": "MIT",
+    "scripts": {
+        "lint:js": "biome check --write --no-errors-on-unmatched",
+        "lint:css": "stylelint '**/*.{css,vue}' --fix --aei",
+        "lint:type": "tsc --noEmit",
+        "test": "vitest run --pass-with-no-tests",
+        "coverage": "vitest run --coverage --pass-with-no-tests",
+        "build": "unbuild"
+    },
+    "dependencies": {
+        "@import-maps/resolve": "^2.0.0"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "1.9.4",
+        "@esmx/lint": "3.0.0-rc.10",
+        "@types/node": "22.13.10",
+        "@vitest/coverage-v8": "3.0.8",
+        "stylelint": "16.15.0",
+        "typescript": "5.8.2",
+        "unbuild": "2.0.0",
+        "vitest": "3.0.8"
+    },
+    "version": "3.0.0-rc.10",
+    "type": "module",
+    "private": false,
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "module": "dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "lib",
+        "src",
+        "dist",
+        "*.mjs",
+        "template",
+        "public"
+    ],
+    "gitHead": "4a528ffecfdc6f2c6e7d97bc952427745f467691"
+}

package/src/import-loader.ts

@@ -0,0 +1,56 @@
+import module from 'node:module';
+import { fileURLToPath } from 'node:url';
+import IM from '@import-maps/resolve';
+import type { ImportMap } from './types';
+
+interface Data {
+    baseURL: string;
+    importMap: ImportMap;
+}
+
+let registered = '';
+/**
+ * 创建一个使用 loader 实现的 importmap 的 import 函数，只能创建一次，无热更新，适合生产使用。
+ */
+export function createLoaderImport(baseURL: URL, importMap: ImportMap = {}) {
+    if (!registered) {
+        module.register<Data>(fileURLToPath(import.meta.url), {
+            parentURL: baseURL,
+            data: {
+                baseURL: baseURL.href,
+                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`
+        );
+    }
+    return (specifier: string): Promise<Record<string, any>> => {
+        return import(specifier);
+    };
+}
+
+// loader 线程时的处理逻辑
+let loaderBaseURL: URL = new URL('file:');
+let loaderParsedImportMap: IM.ParsedImportMap = {};
+
+export function initialize(data: Data) {
+    loaderBaseURL = new URL(data.baseURL);
+    loaderParsedImportMap = IM.parse(data.importMap, loaderBaseURL);
+}
+
+export function resolve(
+    specifier: string,
+    context: Record<string, any>,
+    nextResolve: Function
+) {
+    const scriptURL = new URL(context.parentURL);
+    const result = IM.resolve(specifier, loaderParsedImportMap, scriptURL);
+
+    if (result.matched && result.resolvedImport) {
+        return nextResolve(result.resolvedImport.href);
+    }
+    return nextResolve(specifier, context);
+}

package/src/import-vm.ts

@@ -0,0 +1,146 @@
+import fs from 'node:fs';
+import { isBuiltin } from 'node:module';
+import path from 'node:path';
+import vm from 'node:vm';
+import IM from '@import-maps/resolve';
+import type { ImportMap } from './types';
+
+async function importBuiltinModule(specifier: string, context: vm.Context) {
+    const nodeModule = await import(specifier);
+    const keys = Object.keys(nodeModule);
+    const module = new vm.SyntheticModule(
+        keys,
+        function evaluateCallback() {
+            keys.forEach((key) => {
+                this.setExport(key, nodeModule[key]);
+            });
+        },
+        {
+            identifier: specifier,
+            context: context
+        }
+    );
+    await module.link(() => {
+        throw new TypeError(`Native modules should not be linked`);
+    });
+    await module.evaluate();
+    return module;
+}
+
+/**
+ * 创建一个使用 vm 实现的 importmap 的 import 函数，可以创建多次来实现热更新效果，适合开发使用。
+ */
+export function createVmImport(baseURL: URL, importMap: ImportMap = {}) {
+    const parsedImportMap = IM.parse(importMap, baseURL);
+    const parse = (specifier: string, parent: string) => {
+        const result = IM.resolve(specifier, parsedImportMap, new URL(parent));
+
+        let filename: string;
+        if (result.matched && result.resolvedImport) {
+            filename = result.resolvedImport.href;
+        } else {
+            filename = import.meta.resolve(specifier, parent);
+        }
+        const url = new URL(filename);
+        return {
+            filename,
+            url,
+            pathname: url.pathname
+        };
+    };
+    async function moduleLinker(
+        specifier: string,
+        parent: string,
+        context: vm.Context,
+        cache: Map<string, Promise<vm.SourceTextModule>>,
+        moduleIds: string[]
+    ) {
+        if (isBuiltin(specifier)) {
+            return importBuiltinModule(specifier, context);
+        }
+        const parsed = parse(specifier, parent);
+
+        if (moduleIds.includes(parsed.pathname)) {
+            throw new RangeError(
+                `Module circular reference: \n ${JSON.stringify([...moduleIds, parsed.pathname], null, 4)}`
+            );
+        }
+
+        const module = cache.get(parsed.pathname);
+        if (module) {
+            return module;
+        }
+        const pe = new Promise<vm.SourceTextModule>((resolve) => {
+            process.nextTick(() => {
+                moduleBuild().then(resolve);
+            });
+        });
+
+        const dirname = path.dirname(parsed.filename);
+        cache.set(parsed.pathname, pe);
+        return pe;
+
+        async function moduleBuild(): Promise<vm.SourceTextModule> {
+            let text: string;
+            try {
+                text = fs.readFileSync(parsed.pathname, 'utf-8');
+            } catch {
+                throw new Error(`Failed to read module: ${parsed.pathname}`);
+            }
+            const module = new vm.SourceTextModule(text, {
+                initializeImportMeta: (meta) => {
+                    meta.filename = parsed.filename;
+                    meta.dirname = dirname;
+                    meta.resolve = (
+                        specifier: string,
+                        parent: string | URL = parsed.url
+                    ) => {
+                        return import.meta.resolve(specifier, parent);
+                    };
+                    meta.url = parsed.url.toString();
+                },
+                identifier: specifier,
+                context: context,
+                // @ts-ignore
+                importModuleDynamically: (specifier, referrer) => {
+                    return moduleLinker(
+                        specifier,
+                        parsed.filename,
+                        // @ts-ignore
+                        referrer.context,
+                        cache,
+                        [...moduleIds, parsed.pathname]
+                    );
+                }
+            });
+            await module.link((specifier: string, referrer) => {
+                return moduleLinker(
+                    specifier,
+                    parsed.filename,
+                    referrer.context,
+                    cache,
+                    [...moduleIds, parsed.pathname]
+                );
+            });
+            await module.evaluate();
+            return module;
+        }
+    }
+    return async (
+        specifier: string,
+        parent: string,
+        sandbox?: vm.Context,
+        options?: vm.CreateContextOptions
+    ) => {
+        const context = vm.createContext(sandbox, options);
+        const module = await moduleLinker(
+            specifier,
+            parent,
+            context,
+            new Map(),
+            []
+        );
+
+        return module.namespace as Record<string, any>;
+    };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createVmImport } from './import-vm';
+export { createLoaderImport } from './import-loader';
+export type { ImportMap, SpecifierMap, ScopesMap } from './types';

package/src/types.ts

@@ -0,0 +1,8 @@
+export type SpecifierMap = Record<string, string>;
+
+export type ScopesMap = Record<string, SpecifierMap>;
+
+export interface ImportMap {
+    imports?: SpecifierMap;
+    scopes?: ScopesMap;
+}