pasika 0.10.143 → 0.10.145

package/dist/eslint/pasika/index.js

@@ -11512,128 +11512,138 @@ var themeResetRule = {
 
 // eslint/rules/tailwind/theme-token-order.ts
 import path77 from "path";
-var THEME_GROUPS = [
-  "Color primitives",
-  "Semantic colors",
-  "Fixed and brand colors",
-  "Font families",
-  "Typography",
-  "Spacing and sizing",
-  "Breakpoints, containers, and aspect ratios",
-  "Border radii",
-  "Shadows and visual effects",
-  "Background images",
-  "Transitions and easing",
-  "Animations",
-  "Blur",
-  "Other tokens"
-];
-var primitiveColors = /* @__PURE__ */ new Set([
-  "--accent",
-  "--base-canvas",
-  "--base-edge",
-  "--base-ink",
-  "--card",
-  "--destructive",
-  "--magenta",
-  "--muted",
-  "--muted-ink",
-  "--primary",
-  "--rainbow-ink",
-  "--retro-edge",
-  "--retro-shadow",
-  "--secondary",
-  "--violet"
-]);
-function themeGroupName(name, value) {
-  if (primitiveColors.has(name)) return "Color primitives";
-  if (name.startsWith("--color-")) {
-    return value.includes("var(") ? "Semantic colors" : "Fixed and brand colors";
-  }
-  if (name.startsWith("--font-") && !name.startsWith("--font-weight-")) return "Font families";
-  if (/^--(?:font-weight|text-|tracking-|leading-)/u.test(name)) return "Typography";
-  if (name.startsWith("--spacing")) return "Spacing and sizing";
-  if (/^--(?:breakpoint|container|aspect)-/u.test(name)) return "Breakpoints, containers, and aspect ratios";
-  if (name.startsWith("--radius")) return "Border radii";
-  if (/^--(?:shadow|inset-shadow|drop-shadow|text-shadow)-/u.test(name)) return "Shadows and visual effects";
-  if (name.startsWith("--background-image-")) return "Background images";
-  if (/^--(?:default-transition|transition|ease)-/u.test(name)) return "Transitions and easing";
-  if (name.startsWith("--animate-")) return "Animations";
-  if (name.startsWith("--blur-")) return "Blur";
-  return "Other tokens";
+var GROUP_RE = /^\s*\/\*\s*(?:Group:\s*)?(?<paths>(?:global|src\/[\w./-]+\.(?:tsx?|jsx?))(?:\s*,\s*src\/[\w./-]+\.(?:tsx?|jsx?))*)\s*\*\/\s*$/u;
+var PATH_RE = /^src\/[\w./-]+\.(?:tsx?|jsx?)$/u;
+function normalizeGroup(label) {
+  if (label === "global") return "global";
+  return [...new Set(label.split(",").map((name) => name.trim()))].sort().join(", ");
+}
+function sectionOf(symbol) {
+  if (symbol.kind === "theme-token") return "theme";
+  if (symbol.kind === "utility") return "utility";
+  if (symbol.kind === "keyframes") return "keyframes";
+  return symbol.kind;
+}
+function ownerOf(symbol, graph, root) {
+  const references = graph.references.filter((ref) => {
+    if (ref.source !== "module" || !/\.(?:tsx|jsx)$/u.test(ref.file) || /\.(?:test|spec|stories)\.(?:tsx|jsx)$/u.test(ref.file)) {
+      return false;
+    }
+    if (symbol.kind === "theme-token") {
+      return ref.kind === "theme-class" && ref.token === symbol.name || ref.kind === "variable" && ref.name === symbol.name;
+    }
+    if (symbol.kind === "utility" || symbol.kind === "keyframes" || symbol.kind === "selector") {
+      return ref.name === symbol.name;
+    }
+    return ref.kind === "variable" && ref.name === symbol.name;
+  });
+  const indirect = graph.references.some(
+    (ref) => ref.source === "css" && ref.file !== symbol.file && (symbol.kind === "theme-token" && ref.kind === "variable" && ref.name === symbol.name || symbol.kind === "utility" && ref.kind === "utility" && ref.name === symbol.name || symbol.kind === "keyframes" && ref.kind === "keyframes" && ref.name === symbol.name)
+  );
+  if (indirect) return "global";
+  const owners = [
+    ...new Set(references.map((ref) => path77.relative(path77.dirname(root), ref.file).split(path77.sep).join("/")))
+  ].filter((name) => PATH_RE.test(name)).sort();
+  return owners.length > 0 ? owners.join(", ") : "global";
 }
 var themeTokenOrderRule = {
   meta: {
     schema: [],
     type: "problem",
+    fixable: "code",
     docs: {
-      description: "Require global Tailwind theme tokens to follow purpose groups and alphabetical order."
+      description: "Group CSS definitions by consuming component paths in alphabetical order."
     }
   },
   create(context) {
     const root = sourceRootOf(context);
-    const entry = path77.normalize(path77.join(root, "app", "styles", "globals.css"));
-    if (path77.normalize(path77.resolve(context.filename)) !== entry) return {};
+    const current = path77.normalize(path77.resolve(context.filename));
+    const textOf = cachedTextReader();
+    const cssFiles = /* @__PURE__ */ new Set([...findFiles(root, CSS_EXTENSIONS).map((file) => path77.normalize(file)), current]);
+    const graph = buildCssDependencyGraph({
+      sourceRoot: root,
+      css: [...cssFiles].map((file) => ({
+        path: file,
+        content: path77.normalize(file) === current ? context.sourceCode.text : textOf(file)
+      })),
+      modules: findFiles(root, MODULE_EXTENSIONS4).map((file) => ({ path: file, content: textOf(file) }))
+    });
+    const lines = context.sourceCode.text.split(/\r?\n/u);
+    const groups = [];
+    for (const [index, line] of lines.entries()) {
+      const match = GROUP_RE.exec(line);
+      if (match?.groups?.paths) groups.push({ label: normalizeGroup(match.groups.paths), line: index + 1 });
+    }
+    const items = graph.definitions.filter((symbol) => symbol.file === current && symbol.name !== "--*").filter(
+      (symbol) => ["theme-token", "utility", "keyframes", "root-variable", "selector", "font-face"].includes(symbol.kind)
+    ).map((symbol) => ({
+      symbol,
+      owner: ownerOf(symbol, graph, root),
+      section: sectionOf(symbol)
+    })).sort((a, b) => a.symbol.line - b.symbol.line);
+    let activeGroup;
+    let previousItem;
+    for (const item of items) {
+      const previousLine = previousItem?.symbol.line ?? 0;
+      const intervening = groups.filter((group) => group.line > previousLine && group.line < item.symbol.line).at(-1);
+      if (item.section !== previousItem?.section) activeGroup = intervening;
+      else if (intervening) activeGroup = intervening;
+      item.group = activeGroup;
+      previousItem = item;
+    }
     return {
-      "StyleSheet:exit"(sheet) {
-        const theme = [...sheet.children].find(
-          (child) => child.type === "Atrule" && child.name === "theme" && child.loc
-        );
-        if (!theme?.loc) return;
-        const raw = context.sourceCode.text.slice(theme.loc.start.offset, theme.loc.end.offset);
-        const opening = raw.indexOf("{");
-        const closing = raw.lastIndexOf("}");
-        if (opening === -1 || closing <= opening) return;
-        const lines = raw.slice(opening + 1, closing).split(/\r?\n/u);
-        const firstLine = theme.loc.start.line + (raw.slice(0, opening + 1).match(/\n/gu)?.length ?? 0);
-        const tokens = [];
-        let activeHeading;
-        let hasGroupHeadings = false;
-        for (const [index, line] of lines.entries()) {
-          const heading = /^\s*\/\*\s*(?<heading>.*?)\s*\*\/\s*$/u.exec(line)?.groups?.heading;
-          if (heading && THEME_GROUPS.includes(heading)) {
-            activeHeading = heading;
-            hasGroupHeadings = true;
-          }
-          const declaration = /^ {2}(?<name>--[a-z][a-z0-9-]*)\s*:\s*(?<value>.*)$/u.exec(line);
-          const { name, value } = declaration?.groups ?? {};
-          if (!name || value === void 0) continue;
-          tokens.push({
-            name,
-            group: themeGroupName(name, value),
-            activeHeading,
-            line: firstLine + index
-          });
-        }
-        if (tokens.length > 1 && !hasGroupHeadings) {
+      "StyleSheet:exit"(node) {
+        for (const group of groups.filter((entry) => entry.label === "global")) {
           context.report({
-            node: sheet,
-            message: "Global theme tokens must use named purpose-group section comments."
+            node,
+            loc: { start: { line: group.line, column: 1 }, end: { line: group.line, column: 2 } },
+            message: "Global CSS definitions must not have a group comment.",
+            fix(fixer) {
+              const start = context.sourceCode.getIndexFromLoc({ line: group.line, column: 1 });
+              const end = start + (lines[group.line - 1] ?? "").length;
+              const remaining = context.sourceCode.text.slice(end);
+              let newline = 0;
+              if (remaining.startsWith("\r\n")) newline = 2;
+              else if (remaining.startsWith("\n")) newline = 1;
+              return fixer.removeRange([start, end + newline]);
+            }
           });
         }
         let previous;
-        for (const token of tokens) {
+        for (const item of items) {
+          const currentGroup = item.group;
+          const actual = currentGroup?.label;
+          const reportedGroup = actual ?? "none";
           let message;
-          const groupIndex = THEME_GROUPS.indexOf(token.group);
-          const previousIndex = previous ? THEME_GROUPS.indexOf(previous.group) : -1;
-          if (previous && groupIndex < previousIndex) {
-            message = `Theme token "${token.name}" belongs to "${token.group}", which must appear before "${previous.group}".`;
-          } else if (previous && groupIndex === previousIndex && token.name.toLowerCase() < previous.name.toLowerCase()) {
-            message = `Theme tokens in "${token.group}" must be alphabetical: "${token.name}" goes before "${previous.name}".`;
-          } else if (hasGroupHeadings && token.activeHeading !== token.group) {
-            message = `Theme token "${token.name}" belongs under the "${token.group}" section comment.`;
+          if (item.owner === "global" && currentGroup && currentGroup.label !== "global") {
+            message = "Global definitions must be ungrouped.";
+          } else if (item.owner !== "global" && !currentGroup) {
+            message = `CSS definition "${item.symbol.name}" requires a component-path group comment.`;
+          } else if (item.owner !== "global" && actual !== item.owner) {
+            message = `CSS definition "${item.symbol.name}" belongs to group "${item.owner}", not "${reportedGroup}".`;
+          } else if (previous?.section === item.section) {
+            if (previous.owner !== item.owner && previous.owner.localeCompare(item.owner) > 0) {
+              message = `CSS consumer groups in ${item.section} must be ordered alphabetically by path.`;
+            } else if (previous.owner === item.owner && previous.symbol.name.localeCompare(item.symbol.name) > 0) {
+              message = `CSS definitions in group "${item.owner}" must be alphabetical: "${item.symbol.name}" comes before "${previous.symbol.name}".`;
+            }
           }
           if (message) {
+            const line = item.symbol.line;
             context.report({
-              node: sheet,
-              loc: {
-                start: { line: token.line, column: 1 },
-                end: { line: token.line, column: 2 }
-              },
-              message
+              node,
+              loc: { start: { line, column: 1 }, end: { line, column: 2 } },
+              message,
+              ...item.owner !== "global" && currentGroup && actual !== item.owner && items.filter((candidate) => candidate.group === currentGroup).length === 1 ? {
+                fix(fixer) {
+                  const start = context.sourceCode.getIndexFromLoc({ line: currentGroup.line, column: 1 });
+                  const end = start + (lines[currentGroup.line - 1] ?? "").length;
+                  return fixer.replaceTextRange([start, end], `/* Group: ${item.owner} */`);
+                }
+              } : {}
             });
           }
-          previous = token;
+          previous = item;
         }
       }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.143",
+  "version": "0.10.145",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",