@modern-js/module-tools 2.35.0 → 2.36.0

package/dist/builder/feature/style/postcssTransformer.js

@@ -0,0 +1,95 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postcssTransformer_exports = {};
+__export(postcssTransformer_exports, {
+  isCssModule: () => isCssModule,
+  postcssTransformer: () => postcssTransformer
+});
+module.exports = __toCommonJS(postcssTransformer_exports);
+var import_postcss = __toESM(require("postcss"));
+var import_utils = require("../../../utils");
+var import_postcssUrlPlugin = require("./postcssUrlPlugin");
+const cssLangs = `\\.(css|less|sass|scss)($|\\?)`;
+const cssModuleRE = new RegExp(`\\.module${cssLangs}`);
+const isCssModule = (filePath, autoModules) => {
+  return typeof autoModules === "boolean" ? autoModules && cssModuleRE.test(filePath) : autoModules.test(filePath);
+};
+const postcssTransformer = async (css, entryPath, compilation) => {
+  const postcssConfig = compilation.config.style.postcss;
+  const { plugins = [], processOptions = {} } = postcssConfig;
+  const { modules: modulesOption = {}, autoModules = true } = compilation.config.style;
+  const { getJSON: userGetJSON } = modulesOption;
+  let modules = {};
+  const finalPlugins = [
+    (0, import_postcssUrlPlugin.postcssUrlPlugin)({
+      entryPath,
+      compilation
+    }),
+    ...plugins
+  ];
+  if (isCssModule(entryPath, autoModules)) {
+    finalPlugins.push((await Promise.resolve().then(() => __toESM(require("postcss-modules")))).default({
+      generateScopedName(name, filename, _css) {
+        const hash = (0, import_utils.getHash)(filename, "utf-8").substring(0, 5);
+        return `${name}_${hash}`;
+      },
+      async resolve(id) {
+        return id;
+      },
+      ...modulesOption,
+      getJSON(cssFileName, _modules, outputFileName) {
+        if (userGetJSON) {
+          userGetJSON(cssFileName, _modules, outputFileName);
+        }
+        modules = _modules;
+      }
+    }));
+  }
+  let loader = "css";
+  let { css: code } = await (0, import_postcss.default)(finalPlugins).process(css, {
+    from: entryPath,
+    ...processOptions
+  });
+  if (Object.values(modules).length) {
+    const normalizedPath = (0, import_utils.normalizeSlashes)(entryPath);
+    const key = (0, import_utils.getHash)(code, "utf-8").slice(0, 5);
+    compilation.virtualModule.set(key, code);
+    code = `import "${normalizedPath}?css_virtual&hash=${key}";export default ${JSON.stringify(modules)}`;
+    loader = "js";
+  }
+  return {
+    code,
+    loader
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCssModule,
+  postcssTransformer
+});

package/dist/builder/feature/style/postcssUrlPlugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'postcss';
+import { ICompiler } from '../../../types';
+export declare const postcssUrlPlugin: (options: {
+  entryPath: string;
+  compilation: ICompiler;
+}) => Plugin;

package/dist/builder/feature/style/postcssUrlPlugin.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var postcssUrlPlugin_exports = {};
+__export(postcssUrlPlugin_exports, {
+  postcssUrlPlugin: () => postcssUrlPlugin
+});
+module.exports = __toCommonJS(postcssUrlPlugin_exports);
+var import_path = require("path");
+var import_asset = require("../asset");
+var import_utils = require("./utils");
+const Processed = Symbol("processed");
+const HTTP_PATTERNS = /^(https?:)?\/\//;
+const DATAURL_PATTERNS = /^data:/;
+const HASH_PATTERNS = /#[^#]+$/;
+const postcssUrlPlugin = (options) => {
+  return {
+    postcssPlugin: "postcss-url",
+    async Declaration(decl) {
+      const isProcessed = decl[Processed];
+      decl.value = await (0, import_utils.rewriteCssUrls)(decl.value, false, async (URL) => {
+        if (URL && !HTTP_PATTERNS.test(URL) && !HASH_PATTERNS.test(URL) && !DATAURL_PATTERNS.test(URL) && !isProcessed) {
+          let filePath = URL;
+          const { outDir, sourceDir, buildType } = options.compilation.config;
+          const { css_resolve } = options.compilation;
+          filePath = css_resolve(URL, (0, import_path.dirname)(options.entryPath));
+          const rebaseFrom = buildType === "bundle" ? outDir : (0, import_path.join)(outDir, (0, import_path.relative)(sourceDir, (0, import_path.dirname)(options.entryPath)));
+          const { contents: fileUrl } = await import_asset.getAssetContents.apply(options.compilation, [
+            filePath,
+            rebaseFrom
+          ]);
+          decl[Processed] = true;
+          return fileUrl.toString();
+        }
+        return URL;
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  postcssUrlPlugin
+});

package/dist/builder/feature/style/sassRender.d.ts

@@ -0,0 +1,2 @@
+import { PreprocessRender } from './transformStyle';
+export declare const sassRender: PreprocessRender;

package/dist/builder/feature/style/sassRender.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sassRender_exports = {};
+__export(sassRender_exports, {
+  sassRender: () => sassRender
+});
+module.exports = __toCommonJS(sassRender_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"));
+var import_utils = require("./utils");
+const sassRender = async function(content, _, stdinDir, options, resolvePathMap, implementation) {
+  const sass = await (0, import_utils.loadProcessor)("sass", this.context.root, implementation);
+  return new Promise((resolve, reject) => {
+    sass.render({
+      data: content,
+      importer: [
+        (url, dir, done) => {
+          if (url.startsWith("data:")) {
+            done({
+              contents: url
+            });
+          }
+          let filePath = null;
+          const baseUrl = import_path.default.basename(url);
+          const dirUrl = import_path.default.dirname(url);
+          const removeUnderScoreBaseUrl = baseUrl.replace(/^_/, "");
+          const prependUnderScoreBaseUrl = `_${removeUnderScoreBaseUrl}`;
+          try {
+            const id = import_path.default.join(dirUrl, prependUnderScoreBaseUrl);
+            filePath = this.css_resolve(id, dir === "stdin" ? stdinDir : resolvePathMap.get(dir));
+          } catch (err) {
+            const id = import_path.default.join(dirUrl, removeUnderScoreBaseUrl);
+            filePath = this.css_resolve(id, dir === "stdin" ? stdinDir : resolvePathMap.get(dir));
+          }
+          resolvePathMap.set(url, import_path.default.dirname(filePath));
+          if (url.startsWith("./")) {
+            resolvePathMap.set(url.replace(/^\.\//, ""), import_path.default.dirname(filePath));
+          }
+          (0, import_utils.rebaseUrls)(filePath, stdinDir, this.css_resolve).then((value) => {
+            done({
+              contents: value.contents || (0, import_fs.readFileSync)(value.file, "utf-8")
+            });
+          });
+        }
+      ],
+      ...options
+    }, (err, res) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(res);
+      }
+    });
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sassRender
+});

package/dist/builder/feature/style/transformStyle.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { PartialMessage } from 'esbuild';
+import { ICompiler, Source } from '../../../types';
+export type PreprocessRender = (content: string, stdinPath: string, stdinDir: string, preprocessOptions: any, resolvePathMap: Map<string, string>, implementation?: object | string) => Promise<{
+  css: Buffer | string;
+  errors?: PartialMessage[];
+  warnings?: PartialMessage[];
+  map?: Buffer | string;
+}>;
+export declare function transformStyle(this: ICompiler, source: Source): Promise<{
+  code: string;
+  loader: "js" | "css";
+}>;

package/dist/builder/feature/style/transformStyle.js

@@ -0,0 +1,101 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformStyle_exports = {};
+__export(transformStyle_exports, {
+  transformStyle: () => transformStyle
+});
+module.exports = __toCommonJS(transformStyle_exports);
+var import_path = __toESM(require("path"));
+var import_postcssTransformer = require("./postcssTransformer");
+var import_lessRender = require("./lessRender");
+var import_sassRender = require("./sassRender");
+const cssLangs = `\\.(css|less|sass|scss)($|\\?)`;
+const cssLangRE = new RegExp(cssLangs);
+const cssRender = async function(content) {
+  return {
+    css: content
+  };
+};
+const renderMap = {
+  less: import_lessRender.lessRender,
+  sass: import_sassRender.sassRender,
+  scss: import_sassRender.sassRender,
+  css: cssRender
+};
+async function transformStyle(source) {
+  var _source_path_match;
+  const lang = (_source_path_match = source.path.match(cssLangRE)) === null || _source_path_match === void 0 ? void 0 : _source_path_match[1];
+  if (!lang) {
+    throw new Error(`UNSUPPORTED_CSS_LANG: not supported css lang${lang}`);
+  }
+  const { less, sass } = this.config.style;
+  let options;
+  let additionalData;
+  let implementation;
+  if (lang === "less") {
+    options = less === null || less === void 0 ? void 0 : less.lessOptions;
+    additionalData = less === null || less === void 0 ? void 0 : less.additionalData;
+    implementation = less === null || less === void 0 ? void 0 : less.implementation;
+  }
+  if (lang === "scss" || lang === "sass") {
+    options = sass === null || sass === void 0 ? void 0 : sass.sassOptions;
+    additionalData = sass === null || sass === void 0 ? void 0 : sass.additionalData;
+    implementation = sass === null || sass === void 0 ? void 0 : sass.implementation;
+  }
+  const preprocessRender = renderMap[lang];
+  const stdinDir = import_path.default.dirname(source.path);
+  const resolvePathMap = /* @__PURE__ */ new Map();
+  let content = "";
+  if (typeof additionalData === "string") {
+    content = `${additionalData}
+`;
+  } else if (typeof additionalData === "function") {
+    content = `${additionalData(source.path)}
+`;
+  }
+  content += source.code;
+  const renderResult = await preprocessRender.apply(this, [
+    content,
+    source.path,
+    stdinDir,
+    options,
+    resolvePathMap,
+    implementation
+  ]);
+  const css = renderResult.css.toString();
+  const { code, loader } = await (0, import_postcssTransformer.postcssTransformer)(css !== null && css !== void 0 ? css : "", source.path, this);
+  return {
+    code,
+    loader
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformStyle
+});

package/dist/builder/feature/style/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * make sure load processor in user project root other than root
+ * @param lang
+ * @param root
+ * @returns
+ */
+export declare function loadProcessor(lang: string, root: string, implementation?: object | string): any;
+type CssUrlReplacer = (url: string, importer?: string) => string | Promise<string>;
+/**
+ * relative url() inside \@imported sass and less files must be rebased to use
+ * root file as base.
+ */
+export declare function rebaseUrls(filepath: string, rootDir: string, resolver: (id: string, dir: string) => string): Promise<{
+  file: string;
+  contents?: string;
+}>;
+export declare function rewriteCssUrls(css: string, type: false | string, replacer: CssUrlReplacer): Promise<string>;
+export {};

package/dist/builder/feature/style/utils.js

@@ -0,0 +1,124 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  loadProcessor: () => loadProcessor,
+  rebaseUrls: () => rebaseUrls,
+  rewriteCssUrls: () => rewriteCssUrls
+});
+module.exports = __toCommonJS(utils_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("../../../utils");
+const cache = {};
+function loadProcessor(lang, root, implementation) {
+  if (cache[lang]) {
+    return cache[lang];
+  }
+  try {
+    if (typeof implementation === "string") {
+      return cache[lang] = require(implementation);
+    }
+    if (typeof implementation === "object") {
+      return cache[lang] = implementation;
+    }
+    const loadPath = require.resolve(lang, {
+      paths: [
+        root
+      ]
+    });
+    return cache[lang] = require(loadPath);
+  } catch (err) {
+    throw new Error(`${lang} require failed, please install it or use implemention`);
+  }
+}
+const dataUrlRE = /^\s*data:/i;
+const cssUrlRE = RegExp(`(?<=^|[^\\w\\-\\u0080-\\uffff])url\\(\\s*('[^']+'|"[^"]+"|[^'")]+)\\s*\\)`);
+const externalRE = /^(https?:)?\/\//;
+const isDataUrl = (url) => dataUrlRE.test(url);
+const isExternalUrl = (url) => externalRE.test(url);
+async function rebaseUrls(filepath, rootDir, resolver) {
+  const file = import_path.default.resolve(filepath);
+  const fileDir = import_path.default.dirname(file);
+  if (fileDir === rootDir) {
+    return {
+      file
+    };
+  }
+  const content = import_fs.default.readFileSync(file, "utf-8");
+  if (!cssUrlRE.test(content)) {
+    return {
+      file
+    };
+  }
+  const rebased = await rewriteCssUrls(content, import_path.default.extname(file).slice(1), (url) => {
+    if (url.startsWith("/")) {
+      return url;
+    }
+    return resolver(url, fileDir);
+  });
+  return {
+    file,
+    contents: rebased
+  };
+}
+function rewriteCssUrls(css, type, replacer) {
+  return asyncReplace(css, cssUrlRE, async (match) => {
+    const matched = match[0];
+    let rawUrl = match[1];
+    let wrap = "";
+    const first = rawUrl[0];
+    if (first === `"` || first === `'`) {
+      wrap = first;
+      rawUrl = rawUrl.slice(1, -1);
+    }
+    if (type === "less" && rawUrl.startsWith("@") || (type === "sass" || type === "scss") && rawUrl.startsWith("$") || isExternalUrl(rawUrl) || isDataUrl(rawUrl) || rawUrl.startsWith("#")) {
+      return matched;
+    }
+    return `url(${wrap}${(0, import_utils.normalizeSlashes)(await replacer(rawUrl))}${wrap})`;
+  });
+}
+async function asyncReplace(input, re, replacer) {
+  let match;
+  let remaining = input;
+  let rewritten = "";
+  while (match = re.exec(remaining)) {
+    rewritten += remaining.slice(0, match.index);
+    rewritten += await replacer(match);
+    remaining = remaining.slice(match.index + match[0].length);
+  }
+  rewritten += remaining;
+  return rewritten;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadProcessor,
+  rebaseUrls,
+  rewriteCssUrls
+});

package/dist/builder/feature/swc.d.ts

@@ -0,0 +1,9 @@
+import type { ICompiler, ITsconfig } from '../../types';
+export declare const swcTransform: (userTsconfig: ITsconfig) => {
+  name: string;
+  apply(compiler: ICompiler): void;
+};
+export declare const swcRenderChunk: {
+  name: string;
+  apply(compiler: ICompiler): void;
+};