@zealakit/css-doctor-next 1.0.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zealamic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -399,7 +399,10 @@ var CssDoctorWebpackPlugin = class {
       pageUsage[page.name] = classes;
       pageUsageCounts[page.name] = classes.length;
     }
-    const pageCoverageApplied = this.pageCoverage.enabled && pageNames.length > 0;
+    const hasPageClasses = pagesResult.pages.some(
+      (page) => page.classes.size > 0
+    );
+    const pageCoverageApplied = this.pageCoverage.enabled && hasPageClasses;
     const diagnostics = {
       plugin: "css-doctor-next",
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -488,7 +491,7 @@ var CssDoctorWebpackPlugin = class {
           cssContent: originalCss,
           pageUsage,
           pageCoverage: {
-            enabled: this.pageCoverage.enabled,
+            enabled: pageCoverageApplied,
             minPageRatio: this.pageCoverage.minPageRatio,
             forceCommon: this.pageCoverage.forceCommon
           },
@@ -748,6 +751,7 @@ async function collectPages(compilation, directPageUsage) {
   const pageEntries = [];
   const sharedEntries = [];
   const fallbackEntries = [];
+  const loaderFallbackEntries = [];
   for (const entry of entries) {
     const name = entryName(entry);
     if (!name) {
@@ -764,12 +768,19 @@ async function collectPages(compilation, directPageUsage) {
         name: routeNameForEntry(name) ?? name,
         sourceName: name
       });
+    } else {
+      loaderFallbackEntries.push({
+        entry,
+        name: routeNameForEntry(name) ?? name,
+        sourceName: name
+      });
     }
   }
   const selectedPages = pageEntries.length > 0 ? pageEntries : fallbackEntries;
   const direct = directPageUsage ? Object.keys(directPageUsage).length > 0 : false;
   const pages = /* @__PURE__ */ new Map();
   const pagesByCss = /* @__PURE__ */ new Map();
+  const projectRoot = compilation.compiler?.context ?? process.cwd();
   if (direct && directPageUsage) {
     for (const [rawName, classes] of Object.entries(directPageUsage)) {
       const name = rawName.trim();
@@ -783,10 +794,27 @@ async function collectPages(compilation, directPageUsage) {
         jsFiles: /* @__PURE__ */ new Set()
       });
     }
+    attachEntryAssetsToPages(pages, selectedPages);
+    const orphanPages = [...pages.values()].filter(
+      (page) => page.jsFiles.size === 0
+    );
+    if (orphanPages.length > 0) {
+      const loaderEntries = selectedPages.length > 0 ? selectedPages : loaderFallbackEntries;
+      const fallbackJs = /* @__PURE__ */ new Set();
+      for (const { entry } of loaderEntries) {
+        for (const jsFile of collectEntryJsFiles(entry)) {
+          fallbackJs.add(jsFile);
+        }
+      }
+      for (const page of orphanPages) {
+        for (const jsFile of fallbackJs) {
+          page.jsFiles.add(jsFile);
+        }
+      }
+    }
   } else {
     const sourceCache = /* @__PURE__ */ new Map();
     const sharedClasses = /* @__PURE__ */ new Set();
-    const projectRoot = process.cwd();
     for (const entry of sharedEntries) {
       for (const className of await collectEntryClasses(
         compilation,
@@ -839,19 +867,10 @@ async function collectPages(compilation, directPageUsage) {
   const targetPages = [...pages.keys()];
   for (const { entry, name } of selectedPages) {
     const cssFiles = collectEntryCssFiles(entry);
-    if (direct) {
-      const directPage = pages.get(name);
-      if (directPage) {
-        for (const cssFile of cssFiles) {
-          directPage.cssFiles.add(cssFile);
-        }
-      }
-    } else {
-      const page = pages.get(name);
-      if (page) {
-        for (const cssFile of cssFiles) {
-          page.cssFiles.add(cssFile);
-        }
+    const page = findPageForEntry(pages, name);
+    if (page) {
+      for (const cssFile of cssFiles) {
+        page.cssFiles.add(cssFile);
       }
     }
   }
@@ -876,18 +895,46 @@ async function collectPages(compilation, directPageUsage) {
     pagesByCss
   };
 }
+function attachEntryAssetsToPages(pages, selectedPages) {
+  for (const { entry, name } of selectedPages) {
+    const page = findPageForEntry(pages, name);
+    if (!page) {
+      continue;
+    }
+    for (const jsFile of collectEntryJsFiles(entry)) {
+      page.jsFiles.add(jsFile);
+    }
+    for (const cssFile of collectEntryCssFiles(entry)) {
+      page.cssFiles.add(cssFile);
+    }
+  }
+}
+function findPageForEntry(pages, entryNameValue) {
+  const direct = pages.get(entryNameValue);
+  if (direct) {
+    return direct;
+  }
+  const normalized = normalizeSlashes(entryNameValue).replace(/^\/+/, "");
+  const bare = normalized.replace(/^\//, "");
+  return pages.get(normalized) ?? pages.get(`/${bare}`) ?? pages.get(bare) ?? pages.get(bare.replace(/\//g, "-"));
+}
 async function collectPageSourceClasses(entryName2, projectRoot, sourceCache) {
   const classes = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
   const normalized = normalizeSlashes(entryName2);
+  const roots = projectSourceRoots(projectRoot);
   const candidates = [];
   if (normalized.startsWith("app/")) {
     const path = normalized.slice(4);
     if (path === "page" || path.endsWith("/page")) {
       const pagePath = path === "page" ? "app/page" : `app/${path}`;
-      candidates.push((0, import_node_path2.resolve)(projectRoot, pagePath));
+      for (const root of roots) {
+        candidates.push((0, import_node_path2.resolve)(root, pagePath));
+      }
       if (path === "_not-found/page") {
-        candidates.push((0, import_node_path2.resolve)(projectRoot, "app/not-found"));
+        for (const root of roots) {
+          candidates.push((0, import_node_path2.resolve)(root, "app/not-found"));
+        }
       }
       const directories = path.split("/").slice(0, -1).filter(Boolean);
       const layoutPaths = ["app"];
@@ -895,16 +942,24 @@ async function collectPageSourceClasses(entryName2, projectRoot, sourceCache) {
         layoutPaths.push(`app/${directories.slice(0, index + 1).join("/")}`);
       }
       for (const layoutPath of layoutPaths) {
-        candidates.push((0, import_node_path2.resolve)(projectRoot, `${layoutPath}/layout`));
+        for (const root of roots) {
+          candidates.push((0, import_node_path2.resolve)(root, `${layoutPath}/layout`));
+        }
       }
     } else {
-      candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
+      for (const root of roots) {
+        candidates.push((0, import_node_path2.resolve)(root, normalized));
+      }
     }
   } else if (normalized.startsWith("pages/")) {
-    candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
-    candidates.push((0, import_node_path2.resolve)(projectRoot, "pages/_app"));
+    for (const root of roots) {
+      candidates.push((0, import_node_path2.resolve)(root, normalized));
+      candidates.push((0, import_node_path2.resolve)(root, "pages/_app"));
+    }
   } else {
-    candidates.push((0, import_node_path2.resolve)(projectRoot, normalized));
+    for (const root of roots) {
+      candidates.push((0, import_node_path2.resolve)(root, normalized));
+    }
   }
   for (const candidate of candidates) {
     const file = findSourceFile(candidate);
@@ -917,13 +972,23 @@ async function collectPageSourceClasses(entryName2, projectRoot, sourceCache) {
 async function collectNameSourceClasses(entryName2, projectRoot, sourceCache) {
   const classes = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const candidate = (0, import_node_path2.resolve)(projectRoot, normalizeSlashes(entryName2));
-  const file = findSourceFile(candidate);
-  if (file) {
-    await scanSourceFile(file, classes, projectRoot, sourceCache, visited);
+  const relative = normalizeSlashes(entryName2);
+  for (const root of projectSourceRoots(projectRoot)) {
+    const file = findSourceFile((0, import_node_path2.resolve)(root, relative));
+    if (file) {
+      await scanSourceFile(file, classes, projectRoot, sourceCache, visited);
+    }
   }
   return classes;
 }
+function projectSourceRoots(projectRoot) {
+  const roots = [projectRoot];
+  const srcRoot = (0, import_node_path2.resolve)(projectRoot, "src");
+  if (srcRoot !== projectRoot && (0, import_node_fs2.existsSync)(srcRoot)) {
+    roots.push(srcRoot);
+  }
+  return roots;
+}
 async function scanSourceFile(filePath, classes, projectRoot, sourceCache, visited) {
   const absolutePath = (0, import_node_path2.resolve)(filePath);
   if (visited.has(absolutePath)) {
@@ -1007,18 +1072,28 @@ function extractImportSpecifiers(source) {
   return [...specifiers];
 }
 function resolveImportSpecifier(specifier, fromFile, projectRoot) {
-  let basePath;
   if (specifier.startsWith("@/")) {
-    basePath = (0, import_node_path2.resolve)(projectRoot, specifier.slice(2));
-  } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    basePath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(fromFile), specifier);
-  } else {
+    const relative = specifier.slice(2);
+    for (const root of projectSourceRoots(projectRoot)) {
+      const basePath = (0, import_node_path2.resolve)(root, relative);
+      if (isStyleFile(basePath)) {
+        return null;
+      }
+      const found = findSourceFile(basePath);
+      if (found) {
+        return found;
+      }
+    }
     return null;
   }
-  if (isStyleFile(basePath)) {
-    return null;
+  if (specifier.startsWith("./") || specifier.startsWith("../")) {
+    const basePath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(fromFile), specifier);
+    if (isStyleFile(basePath)) {
+      return null;
+    }
+    return findSourceFile(basePath);
   }
-  return findSourceFile(basePath);
+  return null;
 }
 async function collectEntryClasses(compilation, entry, sourceCache) {
   const classes = /* @__PURE__ */ new Set();
@@ -1187,13 +1262,22 @@ function scanClasses(source, classes) {
         continue;
       }
       for (const token of value.split(/\s+/)) {
-        if (/^-?[_a-zA-Z][\w-]*$/.test(token)) {
+        if (isClassToken(token)) {
           classes.add(token.toLowerCase());
         }
       }
     }
   }
 }
+function isClassToken(token) {
+  if (!token || token.length > 256) {
+    return false;
+  }
+  if (/[`${}]/.test(token)) {
+    return false;
+  }
+  return /[A-Za-z_]/.test(token);
+}
 function addCssOwner(pagesByCss, cssFile, page) {
   const owners = pagesByCss.get(cssFile) ?? /* @__PURE__ */ new Set();
   owners.add(page);