@unocss/webpack 0.62.3 → 0.63.0

package/dist/shared/webpack.DDjG3x9e.cjs

@@ -0,0 +1,466 @@
+'use strict';
+
+const node_path = require('node:path');
+const process$1 = require('node:process');
+const unplugin$1 = require('unplugin');
+const WebpackSources = require('webpack-sources');
+const fs = require('node:fs/promises');
+const tinyglobby = require('tinyglobby');
+const remapping = require('@ampproject/remapping');
+const MagicString = require('magic-string');
+const core = require('@unocss/core');
+const pluginutils = require('@rollup/pluginutils');
+const config = require('@unocss/config');
+const node_crypto = require('node:crypto');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process$1);
+const WebpackSources__default = /*#__PURE__*/_interopDefaultCompat(WebpackSources);
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+const remapping__default = /*#__PURE__*/_interopDefaultCompat(remapping);
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
+
+const INCLUDE_COMMENT = "@unocss-include";
+const IGNORE_COMMENT = "@unocss-ignore";
+const CSS_PLACEHOLDER = "@unocss-placeholder";
+const SKIP_START_COMMENT = "@unocss-skip-start";
+const SKIP_END_COMMENT = "@unocss-skip-end";
+const SKIP_COMMENT_RE = new RegExp(`(//\\s*?${SKIP_START_COMMENT}\\s*?|\\/\\*\\s*?${SKIP_START_COMMENT}\\s*?\\*\\/|<!--\\s*?${SKIP_START_COMMENT}\\s*?-->)[\\s\\S]*?(//\\s*?${SKIP_END_COMMENT}\\s*?|\\/\\*\\s*?${SKIP_END_COMMENT}\\s*?\\*\\/|<!--\\s*?${SKIP_END_COMMENT}\\s*?-->)`, "g");
+
+function getPath(id) {
+  return id.replace(/\?.*$/, "");
+}
+function isCssId(id) {
+  return core.cssIdRE.test(id);
+}
+function hash(str) {
+  let i;
+  let l;
+  let hval = 2166136261;
+  for (i = 0, l = str.length; i < l; i++) {
+    hval ^= str.charCodeAt(i);
+    hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24);
+  }
+  return `00000${(hval >>> 0).toString(36)}`.slice(-6);
+}
+function transformSkipCode(code, map, SKIP_RULES_RE, keyFlag) {
+  for (const item of Array.from(code.matchAll(SKIP_RULES_RE))) {
+    if (item != null) {
+      const matched = item[0];
+      const withHashKey = `${keyFlag}${hash(matched)}`;
+      map.set(withHashKey, matched);
+      code = code.replace(matched, withHashKey);
+    }
+  }
+  return code;
+}
+function restoreSkipCode(code, map) {
+  for (const [withHashKey, matched] of map.entries())
+    code = code.replaceAll(withHashKey, matched);
+  return code;
+}
+
+async function applyTransformers(ctx, original, id, enforce = "default") {
+  if (original.includes(IGNORE_COMMENT))
+    return;
+  const transformers = (ctx.uno.config.transformers || []).filter((i) => (i.enforce || "default") === enforce);
+  if (!transformers.length)
+    return;
+  const skipMap = /* @__PURE__ */ new Map();
+  let code = original;
+  let s = new MagicString__default(transformSkipCode(code, skipMap, SKIP_COMMENT_RE, "@unocss-skip-placeholder-"));
+  const maps = [];
+  for (const t of transformers) {
+    if (t.idFilter) {
+      if (!t.idFilter(id))
+        continue;
+    } else if (!ctx.filter(code, id)) {
+      continue;
+    }
+    await t.transform(s, id, ctx);
+    if (s.hasChanged()) {
+      code = restoreSkipCode(s.toString(), skipMap);
+      maps.push(s.generateMap({ hires: true, source: id }));
+      s = new MagicString__default(code);
+    }
+  }
+  if (code !== original) {
+    return {
+      code,
+      map: remapping__default(maps, (_, ctx2) => {
+        ctx2.content = code;
+        return null;
+      })
+    };
+  }
+}
+
+async function setupContentExtractor(ctx, shouldWatch = false) {
+  const { content } = await ctx.getConfig();
+  const { extract, tasks, root, filter } = ctx;
+  if (content?.inline) {
+    await Promise.all(
+      content.inline.map(async (c, idx) => {
+        if (typeof c === "function")
+          c = await c();
+        if (typeof c === "string")
+          c = { code: c };
+        return extract(c.code, c.id ?? `__plain_content_${idx}__`);
+      })
+    );
+  }
+  if (content?.filesystem) {
+    const files = await tinyglobby.glob(content.filesystem, { cwd: root, expandDirectories: false });
+    async function extractFile(file) {
+      file = node_path.isAbsolute(file) ? file : node_path.resolve(root, file);
+      const code = await fs__default.readFile(file, "utf-8");
+      if (!filter(code, file))
+        return;
+      const preTransform = await applyTransformers(ctx, code, file, "pre");
+      const defaultTransform = await applyTransformers(ctx, preTransform?.code || code, file);
+      await applyTransformers(ctx, defaultTransform?.code || preTransform?.code || code, file, "post");
+      return await extract(preTransform?.code || code, file);
+    }
+    if (shouldWatch) {
+      const { watch } = await import('chokidar');
+      const ignored = ["**/{.git,node_modules}/**"];
+      const watcher = watch(files, {
+        ignorePermissionErrors: true,
+        ignored,
+        cwd: root,
+        ignoreInitial: true
+      });
+      watcher.on("all", (type, file) => {
+        if (type === "add" || type === "change") {
+          const absolutePath = node_path.resolve(root, file);
+          tasks.push(extractFile(absolutePath));
+        }
+      });
+    }
+    await Promise.all(files.map(extractFile));
+  }
+}
+
+const defaultPipelineExclude = [core.cssIdRE];
+const defaultPipelineInclude = [/\.(vue|svelte|[jt]sx|mdx?|astro|elm|php|phtml|html)($|\?)/];
+
+function deprecationCheck(config) {
+  let warned = false;
+  function warn(msg) {
+    warned = true;
+    console.warn(`[unocss] ${msg}`);
+  }
+  if (config.include)
+    warn("`include` option is deprecated, use `content.pipeline.include` instead.");
+  if (config.exclude)
+    warn("`exclude` option is deprecated, use `content.pipeline.exclude` instead.");
+  if (config.extraContent)
+    warn("`extraContent` option is deprecated, use `content` instead.");
+  if (config.content?.plain)
+    warn("`content.plain` option is renamed to `content.inline`.");
+  if (warned && typeof process !== "undefined" && process.env.CI)
+    throw new Error("deprecation warning");
+}
+
+function createContext(configOrPath, defaults = {}, extraConfigSources = [], resolveConfigResult = () => {
+}) {
+  let root = process__default.cwd();
+  let rawConfig = {};
+  let configFileList = [];
+  const uno = core.createGenerator(rawConfig, defaults);
+  let rollupFilter = pluginutils.createFilter(
+    defaultPipelineInclude,
+    defaultPipelineExclude,
+    { resolve: typeof configOrPath === "string" ? configOrPath : root }
+  );
+  const invalidations = [];
+  const reloadListeners = [];
+  const modules = new core.BetterMap();
+  const tokens = /* @__PURE__ */ new Set();
+  const tasks = [];
+  const affectedModules = /* @__PURE__ */ new Set();
+  const loadConfig = config.createRecoveryConfigLoader();
+  let ready = reloadConfig();
+  async function reloadConfig() {
+    const result = await loadConfig(root, configOrPath, extraConfigSources, defaults);
+    resolveConfigResult(result);
+    deprecationCheck(result.config);
+    rawConfig = result.config;
+    configFileList = result.sources;
+    uno.setConfig(rawConfig);
+    uno.config.envMode = "dev";
+    rollupFilter = rawConfig.content?.pipeline === false ? () => false : pluginutils.createFilter(
+      rawConfig.content?.pipeline?.include || rawConfig.include || defaultPipelineInclude,
+      rawConfig.content?.pipeline?.exclude || rawConfig.exclude || defaultPipelineExclude,
+      { resolve: typeof configOrPath === "string" ? configOrPath : root }
+    );
+    tokens.clear();
+    await Promise.all(modules.map((code, id) => uno.applyExtractors(code.replace(SKIP_COMMENT_RE, ""), id, tokens)));
+    invalidate();
+    dispatchReload();
+    const presets = /* @__PURE__ */ new Set();
+    uno.config.presets.forEach((i) => {
+      if (!i.name)
+        return;
+      if (presets.has(i.name))
+        console.warn(`[unocss] duplication of preset ${i.name} found, there might be something wrong with your config.`);
+      else
+        presets.add(i.name);
+    });
+    return result;
+  }
+  async function updateRoot(newRoot) {
+    if (newRoot !== root) {
+      root = newRoot;
+      ready = reloadConfig();
+    }
+    return await ready;
+  }
+  function invalidate() {
+    invalidations.forEach((cb) => cb());
+  }
+  function dispatchReload() {
+    reloadListeners.forEach((cb) => cb());
+  }
+  async function extract(code, id) {
+    if (id)
+      modules.set(id, code);
+    const len = tokens.size;
+    await uno.applyExtractors(code.replace(SKIP_COMMENT_RE, ""), id, tokens);
+    if (tokens.size > len)
+      invalidate();
+  }
+  function filter(code, id) {
+    if (code.includes(IGNORE_COMMENT))
+      return false;
+    return code.includes(INCLUDE_COMMENT) || code.includes(CSS_PLACEHOLDER) || rollupFilter(id.replace(/\?v=\w+$/, ""));
+  }
+  async function getConfig() {
+    await ready;
+    return rawConfig;
+  }
+  async function flushTasks() {
+    const _tasks = [...tasks];
+    await Promise.all(_tasks);
+    if (tasks[0] === _tasks[0])
+      tasks.splice(0, _tasks.length);
+  }
+  return {
+    get ready() {
+      return ready;
+    },
+    tokens,
+    modules,
+    affectedModules,
+    tasks,
+    flushTasks,
+    invalidate,
+    onInvalidate(fn) {
+      invalidations.push(fn);
+    },
+    filter,
+    reloadConfig,
+    onReload(fn) {
+      reloadListeners.push(fn);
+    },
+    uno,
+    extract,
+    getConfig,
+    get root() {
+      return root;
+    },
+    updateRoot,
+    getConfigFileList: () => configFileList
+  };
+}
+
+function getHash(input, length = 8) {
+  return node_crypto.createHash("sha256").update(input).digest("hex").slice(0, length);
+}
+
+const VIRTUAL_ENTRY_ALIAS = [
+  /^(?:virtual:)?uno(?::(.+))?\.css(\?.*)?$/
+];
+const LAYER_MARK_ALL = "__ALL__";
+const RESOLVED_ID_WITH_QUERY_RE = /[/\\]__uno(_.*?)?\.css(\?.*)?$/;
+const RESOLVED_ID_RE = /[/\\]__uno(?:_(.*?))?\.css$/;
+function resolveId(id) {
+  if (id.match(RESOLVED_ID_WITH_QUERY_RE))
+    return id;
+  for (const alias of VIRTUAL_ENTRY_ALIAS) {
+    const match = id.match(alias);
+    if (match) {
+      return match[1] ? `/__uno_${match[1]}.css` : "/__uno.css";
+    }
+  }
+}
+function resolveLayer(id) {
+  const match = id.match(RESOLVED_ID_RE);
+  if (match)
+    return match[1] || LAYER_MARK_ALL;
+}
+const LAYER_PLACEHOLDER_RE = /#--unocss--\s*\{\s*layer\s*:\s*(.+?)\s*(?:;\s*escape-view\s*:\s*(.+?)\s*)?;?\s*\}/g;
+function getLayerPlaceholder(layer) {
+  return `#--unocss--{layer:${layer};escape-view:\\"\\'\\\`\\\\}`;
+}
+function getCssEscaperForJsContent(view) {
+  if (!view)
+    return (css) => css;
+  const prefix = {};
+  const escapeViewRe = /(\\*)\\(["'`\\])/g;
+  view.trim().replace(escapeViewRe, (_, bs, char) => {
+    prefix[char] = bs.replace(/\\\\/g, "\\");
+    return "";
+  });
+  return (css) => css.replace(/["'`\\]/g, (v) => {
+    return (prefix[v] || "") + v;
+  });
+}
+const HASH_PLACEHOLDER_RE = /#--unocss-hash--\s*\{\s*content\s*:\s*\\*"([^\\"]+)\\*";?\s*\}/g;
+function getHashPlaceholder(hash) {
+  return `#--unocss-hash--{content:"${hash}"}`;
+}
+
+const PLUGIN_NAME = "unocss:webpack";
+const UPDATE_DEBOUNCE = 10;
+function unplugin(configOrPath, defaults) {
+  return unplugin$1.createUnplugin(() => {
+    const ctx = createContext(configOrPath, {
+      envMode: process__default.env.NODE_ENV === "development" ? "dev" : "build",
+      ...defaults
+    });
+    const { uno, tokens, filter, extract, onInvalidate, tasks, flushTasks } = ctx;
+    let timer;
+    onInvalidate(() => {
+      clearTimeout(timer);
+      timer = setTimeout(updateModules, UPDATE_DEBOUNCE);
+    });
+    const nonPreTransformers = ctx.uno.config.transformers?.filter((i) => i.enforce !== "pre");
+    if (nonPreTransformers?.length) {
+      console.warn(
+        // eslint-disable-next-line prefer-template
+        '[unocss] webpack integration only supports "pre" enforce transformers currently.the following transformers will be ignored\n' + nonPreTransformers.map((i) => ` - ${i.name}`).join("\n")
+      );
+    }
+    tasks.push(setupContentExtractor(ctx, typeof configOrPath === "object" && configOrPath?.watch));
+    const entries = /* @__PURE__ */ new Set();
+    const hashes = /* @__PURE__ */ new Map();
+    const plugin = {
+      name: "unocss:webpack",
+      enforce: "pre",
+      transformInclude(id) {
+        return filter("", id) && !id.endsWith(".html") && !RESOLVED_ID_RE.test(id);
+      },
+      async transform(code, id) {
+        const result = await applyTransformers(ctx, code, id, "pre");
+        if (isCssId(id))
+          return result;
+        if (result == null)
+          tasks.push(extract(code, id));
+        else
+          tasks.push(extract(result.code, id));
+        return result;
+      },
+      resolveId(id) {
+        const entry = resolveId(id);
+        if (entry === id)
+          return;
+        if (entry) {
+          let query = "";
+          const queryIndex = id.indexOf("?");
+          if (queryIndex >= 0)
+            query = id.slice(queryIndex);
+          entries.add(entry);
+          return entry + query;
+        }
+      },
+      loadInclude(id) {
+        const layer = getLayer(id);
+        return !!layer;
+      },
+      // serve the placeholders in virtual module
+      load(id) {
+        const layer = getLayer(id);
+        const hash = hashes.get(id);
+        if (layer)
+          return (hash ? getHashPlaceholder(hash) : "") + getLayerPlaceholder(layer);
+      },
+      webpack(compiler) {
+        compiler.hooks.beforeCompile.tapPromise(PLUGIN_NAME, async () => {
+          await ctx.ready;
+        });
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+          const optimizeAssetsHook = (
+            /* webpack 5 & 6 */
+            compilation.hooks.processAssets || /* webpack 4 */
+            compilation.hooks.optimizeAssets
+          );
+          optimizeAssetsHook.tapPromise(PLUGIN_NAME, async () => {
+            const files = Object.keys(compilation.assets);
+            await flushTasks();
+            const result = await uno.generate(tokens, { minify: true });
+            for (const file of files) {
+              if (file === "*")
+                return;
+              let code = compilation.assets[file].source().toString();
+              let escapeCss;
+              let replaced = false;
+              code = code.replace(HASH_PLACEHOLDER_RE, "");
+              code = code.replace(LAYER_PLACEHOLDER_RE, (_, layer, escapeView) => {
+                replaced = true;
+                const css = layer.trim() === LAYER_MARK_ALL ? result.getLayers(void 0, Array.from(entries).map((i) => resolveLayer(i)).filter((i) => !!i)) : result.getLayer(layer) || "";
+                escapeCss = escapeCss ?? getCssEscaperForJsContent(escapeView.trim());
+                return escapeCss(css);
+              });
+              if (replaced)
+                compilation.assets[file] = new WebpackSources__default.SourceMapSource(code, file, compilation.assets[file].map());
+            }
+          });
+        });
+      },
+      get rspack() {
+        return this.webpack;
+      }
+    };
+    let lastTokenSize = tokens.size;
+    async function updateModules() {
+      if (!plugin.__vfsModules)
+        return;
+      await flushTasks();
+      const result = await uno.generate(tokens);
+      if (lastTokenSize === tokens.size)
+        return;
+      lastTokenSize = tokens.size;
+      Array.from(plugin.__vfsModules).forEach((id) => {
+        let path = decodeURIComponent(id.slice(plugin.__virtualModulePrefix.length));
+        path = normalizeAbsolutePath(path);
+        const layer = resolveLayer(path);
+        if (!layer)
+          return;
+        const code = layer === LAYER_MARK_ALL ? result.getLayers(void 0, Array.from(entries).map((i) => resolveLayer(i)).filter((i) => !!i)) : result.getLayer(layer) || "";
+        const hash = getHash(code);
+        hashes.set(path, hash);
+        plugin.__vfs.writeModule(id, code);
+      });
+    }
+    return plugin;
+  });
+}
+function getLayer(id) {
+  let layer = resolveLayer(getPath(id));
+  if (!layer) {
+    const entry = resolveId(id);
+    if (entry)
+      layer = resolveLayer(entry);
+  }
+  return layer;
+}
+function normalizeAbsolutePath(path) {
+  if (node_path.isAbsolute(path))
+    return node_path.normalize(path);
+  else
+    return path;
+}
+
+exports.unplugin = unplugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unocss/webpack",
   "type": "module",
-  "version": "0.62.3",
+  "version": "0.63.0",
   "description": "The Webpack plugin for UnoCSS",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -30,6 +30,16 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./rspack": {
+      "import": {
+        "types": "./dist/rspack.d.mts",
+        "default": "./dist/rspack.mjs"
+      },
+      "require": {
+        "types": "./dist/rspack.d.cts",
+        "default": "./dist/rspack.cjs"
+      }
     }
   },
   "main": "./dist/index.cjs",
@@ -43,19 +53,19 @@
   },
   "dependencies": {
     "@ampproject/remapping": "^2.3.0",
-    "@rollup/pluginutils": "^5.1.0",
+    "@rollup/pluginutils": "^5.1.2",
     "chokidar": "^3.6.0",
     "magic-string": "^0.30.11",
-    "tinyglobby": "^0.2.5",
-    "unplugin": "^1.12.2",
+    "tinyglobby": "^0.2.6",
+    "unplugin": "^1.14.1",
     "webpack-sources": "^3.2.3",
-    "@unocss/core": "0.62.3",
-    "@unocss/config": "0.62.3"
+    "@unocss/config": "0.63.0",
+    "@unocss/core": "0.63.0"
   },
   "devDependencies": {
     "@types/webpack": "^5.28.5",
     "@types/webpack-sources": "^3.2.3",
-    "webpack": "^5.94.0"
+    "webpack": "^5.95.0"
   },
   "scripts": {
     "build": "unbuild",