rollup-plugin-import-meta-resolve
Version:
Another Rollup resolver plugin
136 lines • 17.2 kB
JavaScript
import { lstatSync, realpathSync } from "fs";
import { extname } from "path";
import { fileURLToPath, pathToFileURL } from "url";
import { moduleResolve } from "import-meta-resolve";
/**
* A resolver plugin using the import.meta.resolve algorithm provided by
* Node.js.
*
* This plugin is (more-or-less) a drop-in replacement for the
* `@rollup/plugin-node-resolve` plugin.
*
* There are a few differences between this plugin and the Node.js resolver:
*
* 1. We allow importing modules without an extension. This is a common
* practice in Node.js, but it is not allowed in ESM. We allow it here to
* maintain compatibility with a large number of modules.
* 2. We allow importing directories. This is not allowed in ESM, but it is
* common in Node.js. We allow it here to maintain compatibility with a
* large number of modules.
* 3. We only allow `import` conditions. This is to ensure that ESM-modules are
* consumed first. This doesn't imply that CommonJS modules are not consumed
* as `default` conditions and packages without `export` conditions may
* still resolve to a CommonJS module.
*
* You can use `strict` to disable (1) and (2) (which is recommended), but
* you may need to fix some modules that are not compliant with the ESM spec.
*
* This plugin is restrictive by default (e.g. no module roots, no `require`
* exports, etc.). This ensures projects are up-to-date and compliant across the
* board. If you have custom file tree requirements, it's recommended to use
* symlinked directories.
*/
export default function importMetaResolve(options = {}) {
const settings = {
strict: options.strict ?? false,
allowJson: options.allowJson ?? false,
allowNode: options.allowNode ?? false,
};
const conditions = new Set(["import"]);
const extensions = [".mjs", ".js"];
function resolve(source, importer) {
try {
return fileURLToPath(moduleResolve(source, pathToFileURL(importer), new Set(conditions), true));
}
catch (error) {
if (lstatSync(importer).isSymbolicLink()) {
return resolve(source, realpathSync(importer));
}
else {
throw error;
}
}
}
function handler(source, importer) {
try {
// Try to resolve an ESM-compliant import.
return resolve(source, importer);
}
catch (error) {
if (settings.strict) {
return;
}
// The module is probably broken, but perhaps another resolver can handle
// it.
if (!isUnsupportedDirImportError(error) &&
!isUnsupportedEsmImportError(error)) {
return;
}
// At this point, we know the import is not ESM-compliant but may use a
// legacy heuristics. In Node.js, this is
//
// We allow the following heuristics (in order):
//
// 1. If the import has no extension, we try to guess it.
// 2. If the import is a directory, we try to resolve the import with
// `index` appended and start over.
//
if (extname(source) === "") {
for (const extension of extensions) {
try {
const resolved = resolve(`${source}${extension}`, importer);
if (resolved !== undefined) {
return resolved;
}
}
catch { }
}
if (settings.allowJson) {
try {
const resolved = resolve(`${source}.json`, importer);
if (resolved !== undefined) {
return resolved;
}
}
catch { }
}
if (settings.allowNode) {
try {
const resolved = resolve(`${source}.node`, importer);
if (resolved !== undefined) {
return resolved;
}
}
catch { }
}
}
if (isUnsupportedDirImportError(error)) {
return handler(`${source}/index`, importer);
}
}
return undefined;
}
return {
name: "import-meta-resolve",
resolveId: {
order: "post",
handler(source, importer) {
// If there is no importer, leave it to the next resolver.
if (importer === undefined) {
return;
}
return handler(source, importer);
},
},
};
}
function isUnsupportedDirImportError(error) {
return isErrNoError(error) && error.code === "ERR_UNSUPPORTED_DIR_IMPORT";
}
function isUnsupportedEsmImportError(error) {
return isErrNoError(error) && error.code === "ERR_UNSUPPORTED_ESM_IMPORT";
}
function isErrNoError(error) {
return error instanceof Object && "code" in error;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rollup-plugin-import-meta-resolve.js","sourceRoot":"","sources":["rollup-plugin-import-meta-resolve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAC,MAAM,IAAI,CAAC;AAC3C,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,KAAK,CAAC;AAEjD,OAAO,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAgClD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,UAAU,iBAAiB,CACvC,UAAmD,EAAE;IAErD,MAAM,QAAQ,GAAG;QACf,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,KAAK;QAC/B,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;QACrC,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;KACG,CAAC;IAE3C,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvC,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAEnC,SAAS,OAAO,CAAC,MAAc,EAAE,QAAgB;QAC/C,IAAI,CAAC;YACH,OAAO,aAAa,CAClB,aAAa,CACX,MAAM,EACN,aAAa,CAAC,QAAQ,CAAC,EACvB,IAAI,GAAG,CAAC,UAAU,CAAC,EACnB,IAAI,CACL,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,SAAS,CAAC,QAAQ,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC;gBACzC,OAAO,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;IAED,SAAS,OAAO,CAAC,MAAc,EAAE,QAAgB;QAC/C,IAAI,CAAC;YACH,0CAA0C;YAC1C,OAAO,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACnC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACpB,OAAO;YACT,CAAC;YAED,yEAAyE;YACzE,MAAM;YACN,IACE,CAAC,2BAA2B,CAAC,KAAK,CAAC;gBACnC,CAAC,2BAA2B,CAAC,KAAK,CAAC,EACnC,CAAC;gBACD,OAAO;YACT,CAAC;YAED,uEAAuE;YACvE,yCAAyC;YACzC,EAAE;YACF,gDAAgD;YAChD,EAAE;YACF,0DAA0D;YAC1D,sEAAsE;YACtE,uCAAuC;YACvC,EAAE;YACF,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;gBAC3B,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;oBACnC,IAAI,CAAC;wBACH,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,EAAE,EAAE,QAAQ,CAAC,CAAC;wBAC5D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;4BAC3B,OAAO,QAAQ,CAAC;wBAClB,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC,CAAA,CAAC;gBACZ,CAAC;gBACD,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;oBACvB,IAAI,CAAC;wBACH,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,MAAM,OAAO,EAAE,QAAQ,CAAC,CAAC;wBACrD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;4BAC3B,OAAO,QAAQ,CAAC;wBAClB,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC,CAAA,CAAC;gBACZ,CAAC;gBACD,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;oBACvB,IAAI,CAAC;wBACH,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,MAAM,OAAO,EAAE,QAAQ,CAAC,CAAC;wBACrD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;4BAC3B,OAAO,QAAQ,CAAC;wBAClB,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC,CAAA,CAAC;gBACZ,CAAC;YACH,CAAC;YACD,IAAI,2BAA2B,CAAC,KAAK,CAAC,EAAE,CAAC;gBACvC,OAAO,OAAO,CAAC,GAAG,MAAM,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,IAAI,EAAE,qBAAqB;QAC3B,SAAS,EAAE;YACT,KAAK,EAAE,MAAM;YACb,OAAO,CAAC,MAAM,EAAE,QAAQ;gBACtB,0DAA0D;gBAC1D,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;oBAC3B,OAAO;gBACT,CAAC;gBACD,OAAO,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACnC,CAAC;SACF;KACF,CAAC;AACJ,CAAC;AAED,SAAS,2BAA2B,CAAC,KAAc;IACjD,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,4BAA4B,CAAC;AAC5E,CAAC;AAED,SAAS,2BAA2B,CAAC,KAAc;IACjD,OAAO,YAAY,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,4BAA4B,CAAC;AAC5E,CAAC;AAED,SAAS,YAAY,CAAC,KAAc;IAClC,OAAO,KAAK,YAAY,MAAM,IAAI,MAAM,IAAI,KAAK,CAAC;AACpD,CAAC","sourcesContent":["import {lstatSync, realpathSync} from \"fs\";\nimport {extname} from \"path\";\nimport {fileURLToPath, pathToFileURL} from \"url\";\n\nimport {moduleResolve} from \"import-meta-resolve\";\nimport type {Plugin} from \"rollup\";\n\ninterface ImportMetaResolvePluginOptions {\n  /**\n   * Whether we should strictly follow Node resolution.\n   *\n   * Usually you will have some deviant modules that do use some legacy\n   * resolution algorithm. Since this is generally the case, this is set to\n   * false, but if you can get away with turning this on, then keep it on since\n   * that implies all your modules are compliant with Node resolution!\n   *\n   * @defaultValue `false`\n   */\n  strict: boolean;\n  /**\n   * Whether we should allow importing JSON files.\n   *\n   * We default to `false` to follow the ESM spec. Once native JSON modules are\n   * supported, this may change.\n   *\n   * @defaultValue `false`\n   */\n  allowJson: boolean;\n  /**\n   * Whether we should allow importing `.node` files.\n   *\n   * @defaultValue `false`\n   */\n  allowNode: boolean;\n}\n\n/**\n * A resolver plugin using the import.meta.resolve algorithm provided by\n * Node.js.\n *\n * This plugin is (more-or-less) a drop-in replacement for the\n * `@rollup/plugin-node-resolve` plugin.\n *\n * There are a few differences between this plugin and the Node.js resolver:\n *\n *  1. We allow importing modules without an extension. This is a common\n *     practice in Node.js, but it is not allowed in ESM. We allow it here to\n *     maintain compatibility with a large number of modules.\n *  2. We allow importing directories. This is not allowed in ESM, but it is\n *     common in Node.js. We allow it here to maintain compatibility with a\n *     large number of modules.\n *  3. We only allow `import` conditions. This is to ensure that ESM-modules are\n *     consumed first. This doesn't imply that CommonJS modules are not consumed\n *     as `default` conditions and packages without `export` conditions may\n *     still resolve to a CommonJS module.\n *\n * You can use `strict` to disable (1) and (2) (which is recommended), but\n * you may need to fix some modules that are not compliant with the ESM spec.\n *\n * This plugin is restrictive by default (e.g. no module roots, no `require`\n * exports, etc.). This ensures projects are up-to-date and compliant across the\n * board. If you have custom file tree requirements, it's recommended to use\n * symlinked directories.\n */\nexport default function importMetaResolve(\n  options: Partial<ImportMetaResolvePluginOptions> = {},\n): Plugin {\n  const settings = {\n    strict: options.strict ?? false,\n    allowJson: options.allowJson ?? false,\n    allowNode: options.allowNode ?? false,\n  } satisfies ImportMetaResolvePluginOptions;\n\n  const conditions = new Set([\"import\"]);\n  const extensions = [\".mjs\", \".js\"];\n\n  function resolve(source: string, importer: string) {\n    try {\n      return fileURLToPath(\n        moduleResolve(\n          source,\n          pathToFileURL(importer),\n          new Set(conditions),\n          true,\n        ),\n      );\n    } catch (error) {\n      if (lstatSync(importer).isSymbolicLink()) {\n        return resolve(source, realpathSync(importer));\n      } else {\n        throw error;\n      }\n    }\n  }\n\n  function handler(source: string, importer: string) {\n    try {\n      // Try to resolve an ESM-compliant import.\n      return resolve(source, importer);\n    } catch (error) {\n      if (settings.strict) {\n        return;\n      }\n\n      // The module is probably broken, but perhaps another resolver can handle\n      // it.\n      if (\n        !isUnsupportedDirImportError(error) &&\n        !isUnsupportedEsmImportError(error)\n      ) {\n        return;\n      }\n\n      // At this point, we know the import is not ESM-compliant but may use a\n      // legacy heuristics. In Node.js, this is\n      //\n      // We allow the following heuristics (in order):\n      //\n      //  1. If the import has no extension, we try to guess it.\n      //  2. If the import is a directory, we try to resolve the import with\n      //     `index` appended and start over.\n      //\n      if (extname(source) === \"\") {\n        for (const extension of extensions) {\n          try {\n            const resolved = resolve(`${source}${extension}`, importer);\n            if (resolved !== undefined) {\n              return resolved;\n            }\n          } catch {}\n        }\n        if (settings.allowJson) {\n          try {\n            const resolved = resolve(`${source}.json`, importer);\n            if (resolved !== undefined) {\n              return resolved;\n            }\n          } catch {}\n        }\n        if (settings.allowNode) {\n          try {\n            const resolved = resolve(`${source}.node`, importer);\n            if (resolved !== undefined) {\n              return resolved;\n            }\n          } catch {}\n        }\n      }\n      if (isUnsupportedDirImportError(error)) {\n        return handler(`${source}/index`, importer);\n      }\n    }\n    return undefined;\n  }\n\n  return {\n    name: \"import-meta-resolve\",\n    resolveId: {\n      order: \"post\",\n      handler(source, importer) {\n        // If there is no importer, leave it to the next resolver.\n        if (importer === undefined) {\n          return;\n        }\n        return handler(source, importer);\n      },\n    },\n  };\n}\n\nfunction isUnsupportedDirImportError(error: unknown) {\n  return isErrNoError(error) && error.code === \"ERR_UNSUPPORTED_DIR_IMPORT\";\n}\n\nfunction isUnsupportedEsmImportError(error: unknown) {\n  return isErrNoError(error) && error.code === \"ERR_UNSUPPORTED_ESM_IMPORT\";\n}\n\nfunction isErrNoError(error: unknown): error is {code: string} {\n  return error instanceof Object && \"code\" in error;\n}\n"]}