@unocss/postcss 0.50.1 → 0.50.2

package/dist/index.cjs

@@ -16,7 +16,7 @@ const MagicString__default = /*#__PURE__*/_interopDefaultLegacy(MagicString);
 
 const defaultIncludeGlobs = ["**/*.{html,js,ts,jsx,tsx,vue,svelte,astro,elm,php,phtml,mdx,md}"];
 
-function parseApply(root, uno, directiveName) {
+async function parseApply(root, uno, directiveName) {
   root.walkAtRules(directiveName, async (rule) => {
     if (!rule.parent)
       return;
@@ -77,10 +77,10 @@ function parseApply(root, uno, directiveName) {
   });
 }
 
-function parseTheme(root, uno, directiveName) {
-  const themeFnRE = new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+const themeFnRE = (directiveName) => new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+async function parseTheme(root, uno, directiveName) {
   root.walkDecls((decl) => {
-    const matches = Array.from(decl.value.matchAll(themeFnRE));
+    const matches = Array.from(decl.value.matchAll(themeFnRE(directiveName)));
     if (!matches.length)
       return;
     for (const match of matches) {
@@ -111,7 +111,7 @@ function parseTheme(root, uno, directiveName) {
   });
 }
 
-function parseScreen(root, uno, directiveName) {
+async function parseScreen(root, uno, directiveName) {
   root.walkAtRules(directiveName, async (rule) => {
     let breakpointName = "";
     let prefix = "";
@@ -158,105 +158,151 @@ function calcMaxWidthBySize(size) {
   return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
 }
 
-function unocss({ content, directiveMap, cwd, configOrPath } = {
-  cwd: process.cwd()
-}) {
+function unocss(options = {}) {
+  core.warnOnce(
+    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
+  );
+  const {
+    cwd = process.cwd(),
+    directiveMap = {
+      apply: "apply",
+      theme: "theme",
+      screen: "screen",
+      unocss: "unocss"
+    },
+    content,
+    configOrPath
+  } = options;
   const fileMap = /* @__PURE__ */ new Map();
   const fileClassMap = /* @__PURE__ */ new Map();
   const classes = /* @__PURE__ */ new Set();
+  const targetCache = /* @__PURE__ */ new Set();
   const config$1 = config.loadConfig(cwd, configOrPath);
   let uno;
-  core.warnOnce(
-    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
-  );
+  let promises$1 = [];
+  let last_config_mtime = 0;
+  const targetRE = new RegExp(Object.values(directiveMap).join("|"));
   return {
-    postcssPlugin: "unocss",
+    postcssPlugin: directiveMap.unocss,
     plugins: [
       async function(root, result) {
-        const cfg = await config$1;
-        if (!Object.keys(!cfg.config))
-          throw new Error("UnoCSS config file not found.");
-        if (!uno)
-          uno = core.createGenerator(cfg.config);
-        await parseApply(root, uno, directiveMap?.apply || "apply");
-        parseTheme(root, uno, directiveMap?.theme || "theme");
-        await parseScreen(root, uno, directiveMap?.screen || "screen");
+        if (!result.opts.from?.split("?")[0].endsWith(".css"))
+          return;
+        let isTarget = false;
+        if (targetRE.test(root.toString())) {
+          if (!targetCache.has(result.opts.from)) {
+            root.walkAtRules((rule) => {
+              if (rule.name === directiveMap.unocss || rule.name === directiveMap.apply || rule.name === directiveMap.theme || rule.name === directiveMap.screen)
+                isTarget = true;
+            });
+            if (!isTarget) {
+              const themeFn = themeFnRE(directiveMap.theme);
+              root.walkDecls((decl) => {
+                if (themeFn.test(decl.value))
+                  isTarget = true;
+              });
+            }
+          } else {
+            isTarget = true;
+          }
+        } else if (targetCache.has(result.opts.from)) {
+          targetCache.delete(result.opts.from);
+        }
+        if (!isTarget)
+          return;
+        else
+          targetCache.add(result.opts.from);
+        try {
+          const cfg = await config$1;
+          if (!uno) {
+            uno = core.createGenerator(cfg.config);
+          } else if (cfg.sources.length) {
+            const config_mtime = (await promises.stat(cfg.sources[0])).mtimeMs;
+            if (config_mtime > last_config_mtime) {
+              uno = core.createGenerator((await config.loadConfig(cwd, configOrPath)).config);
+              last_config_mtime = config_mtime;
+            }
+          }
+        } catch (error) {
+          throw new Error(`UnoCSS config not found: ${error.message}`);
+        }
         const globs = content?.filter((v) => typeof v === "string") ?? defaultIncludeGlobs;
         const rawContent = content?.filter((v) => typeof v === "object") ?? [];
         const entries = await fg__default(globs, {
           cwd,
           dot: true,
           absolute: true,
-          ignore: ["**/{.git,node_modules}/**"]
+          ignore: ["**/{.git,node_modules}/**"],
+          stats: true
         });
-        if (result.opts.from?.split("?")[0].endsWith(".css")) {
-          result.messages.push({
-            type: "dependency",
-            plugin: "unocss",
-            file: result.opts.from,
-            parent: result.opts.from
-          });
-          await Promise.all(
-            [
-              ...rawContent.map(async (v) => {
-                const { matched } = await uno.generate(v.raw, {
-                  id: `unocss${v.extension}`
-                });
-                for (const candidate of matched)
-                  classes.add(candidate);
-              }),
-              ...entries.map(async (file) => {
-                result.messages.push({
-                  type: "dependency",
-                  plugin: "unocss",
-                  file,
-                  parent: result.opts.from
-                });
-                const { mtimeMs } = await promises.stat(file);
-                if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
-                  return;
-                else
-                  fileMap.set(file, mtimeMs);
-                const content2 = await promises.readFile(file, "utf8");
-                const { matched } = await uno.generate(content2, {
-                  id: file
-                });
-                fileClassMap.set(file, matched);
-              })
-            ]
-          );
-          for (const set of fileClassMap.values()) {
-            for (const candidate of set)
+        result.messages.push({
+          type: "dependency",
+          plugin: directiveMap.unocss,
+          file: result.opts.from,
+          parent: result.opts.from
+        });
+        await parseApply(root, uno, directiveMap.apply);
+        await parseTheme(root, uno, directiveMap.theme);
+        await parseScreen(root, uno, directiveMap.screen);
+        promises$1.push(
+          ...rawContent.map(async (v) => {
+            const { matched } = await uno.generate(v.raw, {
+              id: `unocss.${v.extension}`
+            });
+            for (const candidate of matched)
               classes.add(candidate);
-          }
-          const c = await uno.generate(classes);
-          classes.clear();
-          const excludes = [];
-          root.walkAtRules("unocss", (rule) => {
-            if (rule.params) {
-              const source = rule.source;
-              const layers = rule.params.split(",").map((v) => v.trim());
-              const css = postcss__default.parse(
-                layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
-              );
-              css.walkDecls((declaration) => {
-                declaration.source = source;
-              });
-              rule.replaceWith(css);
-              excludes.push(rule.params);
-            }
-          });
-          root.walkAtRules("unocss", (rule) => {
-            if (!rule.params) {
-              const source = rule.source;
-              const css = postcss__default.parse(c.getLayers(void 0, excludes) || "");
-              css.walkDecls((declaration) => {
-                declaration.source = source;
-              });
-              rule.replaceWith(css);
-            }
-          });
+          }),
+          ...entries.map(async ({ path: file, mtimeMs }) => {
+            result.messages.push({
+              type: "dependency",
+              plugin: directiveMap.unocss,
+              file,
+              parent: result.opts.from
+            });
+            if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
+              return;
+            else
+              fileMap.set(file, mtimeMs);
+            const content2 = await promises.readFile(file, "utf8");
+            const { matched } = await uno.generate(content2, {
+              id: file
+            });
+            fileClassMap.set(file, matched);
+          })
+        );
+        await Promise.all(promises$1);
+        promises$1 = [];
+        for (const set of fileClassMap.values()) {
+          for (const candidate of set)
+            classes.add(candidate);
         }
+        const c = await uno.generate(classes);
+        classes.clear();
+        const excludes = [];
+        root.walkAtRules(directiveMap.unocss, (rule) => {
+          if (rule.params) {
+            const source = rule.source;
+            const layers = rule.params.split(",").map((v) => v.trim());
+            const css = postcss__default.parse(
+              layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
+            );
+            css.walkDecls((declaration) => {
+              declaration.source = source;
+            });
+            rule.replaceWith(css);
+            excludes.push(rule.params);
+          }
+        });
+        root.walkAtRules(directiveMap.unocss, (rule) => {
+          if (!rule.params) {
+            const source = rule.source;
+            const css = postcss__default.parse(c.getLayers(void 0, excludes) || "");
+            css.walkDecls((declaration) => {
+              declaration.source = source;
+            });
+            rule.replaceWith(css);
+          }
+        });
       }
     ]
   };

package/dist/index.d.ts

@@ -10,12 +10,13 @@ interface UnoPostcssPluginOptions {
         apply: string;
         screen: string;
         theme: string;
+        unocss: string;
     };
     cwd?: string;
     configOrPath?: string | UserConfig;
 }
 
-declare function unocss({ content, directiveMap, cwd, configOrPath }?: UnoPostcssPluginOptions): {
+declare function unocss(options?: UnoPostcssPluginOptions): {
     postcssPlugin: string;
     plugins: ((root: Root, result: Result) => Promise<void>)[];
 };

package/dist/index.mjs

@@ -8,7 +8,7 @@ import MagicString from 'magic-string';
 
 const defaultIncludeGlobs = ["**/*.{html,js,ts,jsx,tsx,vue,svelte,astro,elm,php,phtml,mdx,md}"];
 
-function parseApply(root, uno, directiveName) {
+async function parseApply(root, uno, directiveName) {
   root.walkAtRules(directiveName, async (rule) => {
     if (!rule.parent)
       return;
@@ -69,10 +69,10 @@ function parseApply(root, uno, directiveName) {
   });
 }
 
-function parseTheme(root, uno, directiveName) {
-  const themeFnRE = new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+const themeFnRE = (directiveName) => new RegExp(`${directiveName}\\((.*?)\\)`, "g");
+async function parseTheme(root, uno, directiveName) {
   root.walkDecls((decl) => {
-    const matches = Array.from(decl.value.matchAll(themeFnRE));
+    const matches = Array.from(decl.value.matchAll(themeFnRE(directiveName)));
     if (!matches.length)
       return;
     for (const match of matches) {
@@ -103,7 +103,7 @@ function parseTheme(root, uno, directiveName) {
   });
 }
 
-function parseScreen(root, uno, directiveName) {
+async function parseScreen(root, uno, directiveName) {
   root.walkAtRules(directiveName, async (rule) => {
     let breakpointName = "";
     let prefix = "";
@@ -150,105 +150,151 @@ function calcMaxWidthBySize(size) {
   return Number.isNaN(maxWidth) ? size : `${maxWidth}${unit}`;
 }
 
-function unocss({ content, directiveMap, cwd, configOrPath } = {
-  cwd: process.cwd()
-}) {
+function unocss(options = {}) {
+  warnOnce(
+    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
+  );
+  const {
+    cwd = process.cwd(),
+    directiveMap = {
+      apply: "apply",
+      theme: "theme",
+      screen: "screen",
+      unocss: "unocss"
+    },
+    content,
+    configOrPath
+  } = options;
   const fileMap = /* @__PURE__ */ new Map();
   const fileClassMap = /* @__PURE__ */ new Map();
   const classes = /* @__PURE__ */ new Set();
+  const targetCache = /* @__PURE__ */ new Set();
   const config = loadConfig(cwd, configOrPath);
   let uno;
-  warnOnce(
-    "`@unocss/postcss` package is in an experimental state right now. It doesn't follow semver, and may introduce breaking changes in patch versions."
-  );
+  let promises = [];
+  let last_config_mtime = 0;
+  const targetRE = new RegExp(Object.values(directiveMap).join("|"));
   return {
-    postcssPlugin: "unocss",
+    postcssPlugin: directiveMap.unocss,
     plugins: [
       async function(root, result) {
-        const cfg = await config;
-        if (!Object.keys(!cfg.config))
-          throw new Error("UnoCSS config file not found.");
-        if (!uno)
-          uno = createGenerator(cfg.config);
-        await parseApply(root, uno, directiveMap?.apply || "apply");
-        parseTheme(root, uno, directiveMap?.theme || "theme");
-        await parseScreen(root, uno, directiveMap?.screen || "screen");
+        if (!result.opts.from?.split("?")[0].endsWith(".css"))
+          return;
+        let isTarget = false;
+        if (targetRE.test(root.toString())) {
+          if (!targetCache.has(result.opts.from)) {
+            root.walkAtRules((rule) => {
+              if (rule.name === directiveMap.unocss || rule.name === directiveMap.apply || rule.name === directiveMap.theme || rule.name === directiveMap.screen)
+                isTarget = true;
+            });
+            if (!isTarget) {
+              const themeFn = themeFnRE(directiveMap.theme);
+              root.walkDecls((decl) => {
+                if (themeFn.test(decl.value))
+                  isTarget = true;
+              });
+            }
+          } else {
+            isTarget = true;
+          }
+        } else if (targetCache.has(result.opts.from)) {
+          targetCache.delete(result.opts.from);
+        }
+        if (!isTarget)
+          return;
+        else
+          targetCache.add(result.opts.from);
+        try {
+          const cfg = await config;
+          if (!uno) {
+            uno = createGenerator(cfg.config);
+          } else if (cfg.sources.length) {
+            const config_mtime = (await stat(cfg.sources[0])).mtimeMs;
+            if (config_mtime > last_config_mtime) {
+              uno = createGenerator((await loadConfig(cwd, configOrPath)).config);
+              last_config_mtime = config_mtime;
+            }
+          }
+        } catch (error) {
+          throw new Error(`UnoCSS config not found: ${error.message}`);
+        }
         const globs = content?.filter((v) => typeof v === "string") ?? defaultIncludeGlobs;
         const rawContent = content?.filter((v) => typeof v === "object") ?? [];
         const entries = await fg(globs, {
           cwd,
           dot: true,
           absolute: true,
-          ignore: ["**/{.git,node_modules}/**"]
+          ignore: ["**/{.git,node_modules}/**"],
+          stats: true
         });
-        if (result.opts.from?.split("?")[0].endsWith(".css")) {
-          result.messages.push({
-            type: "dependency",
-            plugin: "unocss",
-            file: result.opts.from,
-            parent: result.opts.from
-          });
-          await Promise.all(
-            [
-              ...rawContent.map(async (v) => {
-                const { matched } = await uno.generate(v.raw, {
-                  id: `unocss${v.extension}`
-                });
-                for (const candidate of matched)
-                  classes.add(candidate);
-              }),
-              ...entries.map(async (file) => {
-                result.messages.push({
-                  type: "dependency",
-                  plugin: "unocss",
-                  file,
-                  parent: result.opts.from
-                });
-                const { mtimeMs } = await stat(file);
-                if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
-                  return;
-                else
-                  fileMap.set(file, mtimeMs);
-                const content2 = await readFile(file, "utf8");
-                const { matched } = await uno.generate(content2, {
-                  id: file
-                });
-                fileClassMap.set(file, matched);
-              })
-            ]
-          );
-          for (const set of fileClassMap.values()) {
-            for (const candidate of set)
+        result.messages.push({
+          type: "dependency",
+          plugin: directiveMap.unocss,
+          file: result.opts.from,
+          parent: result.opts.from
+        });
+        await parseApply(root, uno, directiveMap.apply);
+        await parseTheme(root, uno, directiveMap.theme);
+        await parseScreen(root, uno, directiveMap.screen);
+        promises.push(
+          ...rawContent.map(async (v) => {
+            const { matched } = await uno.generate(v.raw, {
+              id: `unocss.${v.extension}`
+            });
+            for (const candidate of matched)
               classes.add(candidate);
-          }
-          const c = await uno.generate(classes);
-          classes.clear();
-          const excludes = [];
-          root.walkAtRules("unocss", (rule) => {
-            if (rule.params) {
-              const source = rule.source;
-              const layers = rule.params.split(",").map((v) => v.trim());
-              const css = postcss.parse(
-                layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
-              );
-              css.walkDecls((declaration) => {
-                declaration.source = source;
-              });
-              rule.replaceWith(css);
-              excludes.push(rule.params);
-            }
-          });
-          root.walkAtRules("unocss", (rule) => {
-            if (!rule.params) {
-              const source = rule.source;
-              const css = postcss.parse(c.getLayers(void 0, excludes) || "");
-              css.walkDecls((declaration) => {
-                declaration.source = source;
-              });
-              rule.replaceWith(css);
-            }
-          });
+          }),
+          ...entries.map(async ({ path: file, mtimeMs }) => {
+            result.messages.push({
+              type: "dependency",
+              plugin: directiveMap.unocss,
+              file,
+              parent: result.opts.from
+            });
+            if (fileMap.has(file) && mtimeMs <= fileMap.get(file))
+              return;
+            else
+              fileMap.set(file, mtimeMs);
+            const content2 = await readFile(file, "utf8");
+            const { matched } = await uno.generate(content2, {
+              id: file
+            });
+            fileClassMap.set(file, matched);
+          })
+        );
+        await Promise.all(promises);
+        promises = [];
+        for (const set of fileClassMap.values()) {
+          for (const candidate of set)
+            classes.add(candidate);
         }
+        const c = await uno.generate(classes);
+        classes.clear();
+        const excludes = [];
+        root.walkAtRules(directiveMap.unocss, (rule) => {
+          if (rule.params) {
+            const source = rule.source;
+            const layers = rule.params.split(",").map((v) => v.trim());
+            const css = postcss.parse(
+              layers.map((i) => (i === "all" ? c.getLayers() : c.getLayer(i)) || "").filter(Boolean).join("\n")
+            );
+            css.walkDecls((declaration) => {
+              declaration.source = source;
+            });
+            rule.replaceWith(css);
+            excludes.push(rule.params);
+          }
+        });
+        root.walkAtRules(directiveMap.unocss, (rule) => {
+          if (!rule.params) {
+            const source = rule.source;
+            const css = postcss.parse(c.getLayers(void 0, excludes) || "");
+            css.walkDecls((declaration) => {
+              declaration.source = source;
+            });
+            rule.replaceWith(css);
+          }
+        });
       }
     ]
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unocss/postcss",
-  "version": "0.50.1",
+  "version": "0.50.2",
   "description": "PostCSS plugin for UnoCSS",
   "author": "sibbng <sibbngheid@gmail.com>",
   "license": "MIT",
@@ -36,8 +36,8 @@
     "postcss": "^8.4.21"
   },
   "dependencies": {
-    "@unocss/config": "0.50.1",
-    "@unocss/core": "0.50.1",
+    "@unocss/config": "0.50.2",
+    "@unocss/core": "0.50.2",
     "css-tree": "^2.3.1",
     "fast-glob": "^3.2.12",
     "magic-string": "^0.30.0",