pasika 0.10.116 → 0.10.118

package/dist/eslint/pasika/index.js

@@ -10095,6 +10095,53 @@ function themeClasses(name) {
     }
     return ["bg", "text", "border", "fill", "stroke", "ring"].map((prefix) => `${prefix}-${stem}`);
   }
+  if (name.startsWith("--background-image-")) return [`bg-${name.slice("--background-image-".length)}`];
+  if (name.startsWith("--spacing-")) {
+    const stem = name.slice("--spacing-".length);
+    return [
+      "p",
+      "px",
+      "py",
+      "pt",
+      "pr",
+      "pb",
+      "pl",
+      "ps",
+      "pe",
+      "m",
+      "mx",
+      "my",
+      "mt",
+      "mr",
+      "mb",
+      "ml",
+      "ms",
+      "me",
+      "w",
+      "h",
+      "size",
+      "min-w",
+      "min-h",
+      "max-w",
+      "max-h",
+      "gap",
+      "gap-x",
+      "gap-y",
+      "inset",
+      "inset-x",
+      "inset-y",
+      "top",
+      "right",
+      "bottom",
+      "left",
+      "start",
+      "end",
+      "space-x",
+      "space-y"
+    ].map((prefix) => `${prefix}-${stem}`);
+  }
+  if (name.startsWith("--aspect-")) return [`aspect-${name.slice("--aspect-".length)}`];
+  if (name.startsWith("--leading-")) return [`leading-${name.slice("--leading-".length)}`];
   if (name.startsWith("--animate-")) return [`animate-${name.slice("--animate-".length)}`];
   if (name.startsWith("--radius-")) return [`rounded-${name.slice("--radius-".length)}`];
   if (name.startsWith("--text-") || name.startsWith("--tracking-") || name.startsWith("--font-")) {
@@ -11114,6 +11161,7 @@ var themeOperations = [
   { property: "tab-size", prefix: "tab", namespace: "tab-size" },
   { property: "border-radius", prefix: "rounded", namespace: "radius" },
   { property: "background-color", prefix: "bg", namespace: "color" },
+  { property: "background-image", prefix: "bg", namespace: "background-image" },
   { property: "color", prefix: "text", namespace: "color" },
   { property: "border-color", prefix: "border", namespace: "color" },
   { property: "outline-color", prefix: "outline", namespace: "color" },
@@ -11148,10 +11196,11 @@ function themeCandidate(name, utilityText) {
   const typed = /^@utility\s+[\w-]+\s*\{\s*@apply\s+(?<kind>[a-z]+)-\((?<hint>[a-z-]+:)?(?<variable>--[a-z][a-z0-9-]*)\);?\s*\}$/u.exec(
     source
   );
-  const property = arbitrary?.groups?.property;
+  const direct = /^@utility\s+[\w-]+\s*\{\s*(?<property>[a-z-]+)\s*:\s*(?<value>[^;{}\r\n]+);?\s*\}$/u.exec(source);
+  const property = arbitrary?.groups?.property ?? direct?.groups?.property;
   const matched = themeOperations.find((operation) => {
-    if (!name.startsWith(`${operation.prefix}-`) || name.length <= operation.prefix.length + 1) return false;
     if (property) return property === operation.property;
+    if (!name.startsWith(`${operation.prefix}-`) || name.length <= operation.prefix.length + 1) return false;
     if (typed?.groups?.kind !== operation.prefix) return false;
     const hint = typed.groups.hint;
     if (operation.prefix === "text") return hint === (operation.property === "font-size" ? "length:" : "color:");
@@ -11161,7 +11210,7 @@ function themeCandidate(name, utilityText) {
     return hint === void 0;
   });
   if (!matched) return void 0;
-  const value = arbitrary?.groups?.value?.trim() ?? (typed?.groups?.variable ? `var(${typed.groups.variable})` : void 0);
+  const value = arbitrary?.groups?.value?.trim() ?? direct?.groups?.value?.trim() ?? (typed?.groups?.variable ? `var(${typed.groups.variable})` : void 0);
   if (!value) return void 0;
   const simple = /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem|em|%|vh|vw|ch|deg)?$/u.test(value);
   const variable = /^var\(--[a-z][a-z0-9-]*\)$/u.test(value);
@@ -11170,9 +11219,9 @@ function themeCandidate(name, utilityText) {
   const ratio = /^\d+\/\d+$/u.test(value);
   if (!simple && !variable && !color && !keyword && !ratio) return void 0;
   if (matched.property === "font-size" && value.startsWith("-")) return void 0;
-  const stem = name.slice(matched.prefix.length + 1);
+  const stem = name.startsWith(`${matched.prefix}-`) ? name.slice(matched.prefix.length + 1) : void 0;
   return {
-    token: `--${matched.namespace}-${stem}`,
+    token: stem ? `--${matched.namespace}-${stem}` : "",
     property: matched.property,
     value,
     prefix: matched.prefix,
@@ -11236,6 +11285,37 @@ var utilityMappingRule = {
       includeReferences: false
     });
     const projectTokens = graph.definitions.filter((symbol) => symbol.kind === "theme-token");
+    const rootDefinitions = /* @__PURE__ */ new Map();
+    for (const symbol of graph.definitions) {
+      if (symbol.kind !== "root-variable" || !symbol.value) continue;
+      const values = rootDefinitions.get(symbol.name) ?? [];
+      values.push({ value: symbol.value, scope: symbol.scope ?? "default" });
+      rootDefinitions.set(symbol.name, values);
+    }
+    function comparableValue(value, visited = /* @__PURE__ */ new Set()) {
+      const text = value.trim();
+      const match = /^var\((?<name>--[a-z][a-z0-9-]*)\)$/u.exec(text);
+      const name = match?.groups?.name;
+      if (!name) {
+        const hex = /^#(?<digits>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(text)?.groups?.digits;
+        if (!hex) return text;
+        const lower = hex.toLowerCase();
+        return lower.length <= 4 ? Array.from(lower, (digit) => digit + digit).join("") : lower;
+      }
+      if (visited.has(name)) return void 0;
+      const values = rootDefinitions.get(name);
+      if (!values) return text;
+      if (values.length !== 1 || values[0]?.scope !== "default") return void 0;
+      const next = values[0].value;
+      if (!next) return void 0;
+      visited.add(name);
+      return comparableValue(next, visited);
+    }
+    function equivalentValue(a, b) {
+      const left = comparableValue(a);
+      const right = comparableValue(b);
+      return left !== void 0 && right !== void 0 && left === right;
+    }
     return {
       "StyleSheet:exit"(node) {
         const utilities = atrulesNamed(node, "utility");
@@ -11261,6 +11341,16 @@ var utilityMappingRule = {
             themeDefinitions.set(child.property, definitions);
           }
         }
+        for (const cssRule of node.children) {
+          if (cssRule.type !== "Rule") continue;
+          if (context.sourceCode.getText(cssRule.prelude).trim() !== ":root") continue;
+          for (const child of blockChildren2(cssRule)) {
+            if (child.type !== "Declaration" || !child.property.startsWith("--")) continue;
+            if (rootDefinitions.has(child.property)) continue;
+            const value = declarationValue(context.sourceCode.getText(child));
+            if (value) rootDefinitions.set(child.property, [{ value, scope: "default" }]);
+          }
+        }
         const rootValues = /* @__PURE__ */ new Map();
         const overriddenVariables = /* @__PURE__ */ new Set();
         for (const cssRule of rules(node)) {
@@ -11312,56 +11402,104 @@ var utilityMappingRule = {
             break;
           }
         }
+        function matchingThemeToken(candidate) {
+          const namespacePrefix = `--${candidate.namespace}-`;
+          const available = [
+            ...projectTokens,
+            ...[...themeDefinitions].flatMap(
+              ([name, definitions]) => definitions.length === 1 && definitions[0] ? [{ name, value: definitions[0].value }] : []
+            )
+          ];
+          for (const token of available) {
+            if (!token.value || !token.name.startsWith(namespacePrefix) || token.name.includes("--", 2)) continue;
+            if (!equivalentValue(candidate.value, token.value)) continue;
+            if (candidate.namespace === "text" && ["--line-height", "--letter-spacing", "--font-weight"].some(
+              (suffix) => themeDefinitions.has(`${token.name}${suffix}`) || projectTokens.some((entry) => entry.name === `${token.name}${suffix}`)
+            )) {
+              continue;
+            }
+            const generatedClass = `${candidate.prefix}-${token.name.slice(namespacePrefix.length)}`;
+            if (candidate.namespace === "color" && !themeClasses(token.name).includes(generatedClass)) continue;
+            return generatedClass;
+          }
+          return void 0;
+        }
         for (const utility of utilities) {
           const name = preludeIdentifiers(utility)[0] ?? "unknown";
-          const operationCount = applyOperationCount(utility);
-          if (operationCount !== 1) {
+          const candidate = themeCandidate(name, context.sourceCode.getText(utility));
+          const equivalent = candidate ? matchingThemeToken(candidate) : void 0;
+          if (candidate && equivalent && nameCounts.get(name) === 1) {
             context.report({
               node: utility,
-              message: `Custom utility "${name}" maps ${String(operationCount)} Tailwind operations; custom utilities must map exactly one operation. Reusable presentation belongs in a component.`
+              message: `Custom utility "${name}" duplicates theme-generated "${equivalent}" (${candidate.property}: ${candidate.value}); reuse "${equivalent}" instead.`
             });
             continue;
           }
-          if (nameCounts.get(name) !== 1) continue;
-          const candidate = themeCandidate(name, context.sourceCode.getText(utility));
-          if (!candidate) continue;
-          const tokenAlreadyDefined = themeTokens.has(candidate.token) || projectTokens.some((token) => token.name === candidate.token);
-          const namespacePrefix = `--${candidate.namespace}-`;
-          const staticValue = !/\b(?:var|env|attr|calc|min|max|clamp|color-mix|light-dark)\s*\(/iu.test(
-            candidate.value
-          );
-          const valueKey = (value) => {
-            const input = value.trim();
-            const digits = /^#(?<hex>[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/iu.exec(input)?.groups?.hex;
-            if (digits) {
-              const lower = digits.toLowerCase();
-              return lower.length <= 4 ? Array.from(lower, (digit) => digit + digit).join("") : lower;
-            }
-            return input;
-          };
-          const sameOperation = (token, value) => token.startsWith(namespacePrefix) && !token.includes("--", 2) && valueKey(value) === valueKey(candidate.value) && (candidate.namespace !== "text" || !["--line-height", "--letter-spacing", "--font-weight"].some(
-            (suffix) => themeDefinitions.has(`${token}${suffix}`) || projectTokens.some((definition) => definition.name === `${token}${suffix}`)
-          ));
-          const equivalent = staticValue ? projectTokens.find((token) => token.value !== void 0 && sameOperation(token.name, token.value)) : void 0;
-          const localEquivalent = staticValue ? [...themeDefinitions].find(
-            ([token, definitions]) => definitions.length === 1 && definitions[0]?.value !== void 0 && sameOperation(token, definitions[0].value)
-          )?.[0] : void 0;
-          const existingToken = equivalent?.name ?? localEquivalent;
-          if (tokenAlreadyDefined && !existingToken) continue;
-          if (existingToken) {
-            const className = `${candidate.prefix}-${existingToken.slice(namespacePrefix.length)}`;
+          const operationCount = applyOperationCount(utility);
+          if (operationCount !== 1) {
             context.report({
               node: utility,
-              message: `Custom utility "${name}" duplicates theme-generated "${className}" (${candidate.property}: ${candidate.value}); reuse "${className}" instead.`
+              message: `Custom utility "${name}" maps ${String(operationCount)} Tailwind operations; custom utilities must map exactly one operation. Reusable presentation belongs in a component.`
             });
             continue;
           }
+          if (nameCounts.get(name) !== 1 || !candidate?.token) continue;
+          const tokenAlreadyDefined = themeTokens.has(candidate.token) || projectTokens.some((token) => token.name === candidate.token);
+          if (tokenAlreadyDefined) continue;
           if (candidate.property === "font-size" && themeTokens.has(`--color-${name.slice(5)}`)) continue;
           context.report({
             node: utility,
             message: `Custom utility "${name}" only maps ${candidate.property} (${candidate.value}); prefer @theme inline token "${candidate.token}" backed by a :root variable. Preserve the class name and compare compiled CSS before removing the utility.`
           });
         }
+        function checkClass(cssNode) {
+          if (cssNode.type === "Atrule") {
+            if (cssNode.name !== "layer" || !("prelude" in cssNode) || !cssNode.prelude) return;
+            if (context.sourceCode.getText(cssNode.prelude).trim() === "base") return;
+            for (const child of blockChildren2(cssNode)) checkClass(child);
+            return;
+          }
+          if (cssNode.type !== "Rule") return;
+          const selector = context.sourceCode.getText(cssNode.prelude).trim();
+          if (!/^\.[a-zA-Z_][\w-]*$/u.test(selector)) return;
+          const children = blockChildren2(cssNode);
+          if (children.length !== 1) return;
+          const only = children[0];
+          if (!only) return;
+          const declarationText = context.sourceCode.getText(only).trim();
+          if (only.type === "Atrule" && only.name === "apply") {
+            const alias = /^@apply\s+(?<name>[a-z][a-z0-9-]*)\s*;?$/u.exec(declarationText)?.groups?.name;
+            if (alias && [...projectTokens.map((token) => token.name), ...themeDefinitions.keys()].some(
+              (name) => themeClasses(name).includes(alias)
+            )) {
+              context.report({
+                node: cssNode,
+                message: `CSS class "${selector}" only aliases theme-generated "${alias}"; use "${alias}" instead.`
+              });
+              return;
+            }
+          }
+          const found = only.type === "Declaration" ? /^(?<property>[a-z-]+)\s*:\s*(?<value>[^;{}]+);?$/u.exec(declarationText) : /^@apply\s+\[(?<property>[a-z-]+):(?<value>[^\]\r\n;{}]+)\]\s*;?$/u.exec(declarationText);
+          const property = found?.groups?.property;
+          const value = found?.groups?.value?.trim();
+          if (!property || !value || value.endsWith("!important")) return;
+          const operation = themeOperations.find((item) => item.property === property);
+          if (!operation) return;
+          const candidate = {
+            token: "",
+            property,
+            value,
+            prefix: operation.prefix,
+            namespace: operation.namespace
+          };
+          const equivalent = matchingThemeToken(candidate);
+          if (!equivalent) return;
+          context.report({
+            node: cssNode,
+            message: `CSS class "${selector}" duplicates theme-generated "${equivalent}" (${property}: ${value}); use "${equivalent}" instead.`
+          });
+        }
+        for (const cssRule of node.children) checkClass(cssRule);
       }
     };
   }
@@ -11542,7 +11680,7 @@ import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync a
 import { createRequire } from "module";
 import path79 from "path";
 var PREFIX_NAMESPACES = {
-  bg: ["color"],
+  bg: ["color", "background-image"],
   text: ["color", "text"],
   border: ["color"],
   ring: ["color"],
@@ -11567,6 +11705,47 @@ var PREFIX_NAMESPACES = {
   "backdrop-blur": ["blur"],
   "ring-offset": ["color"]
 };
+var SPACING_UTILITY_PREFIXES = /* @__PURE__ */ new Set([
+  "p",
+  "px",
+  "py",
+  "pt",
+  "pr",
+  "pb",
+  "pl",
+  "ps",
+  "pe",
+  "m",
+  "mx",
+  "my",
+  "mt",
+  "mr",
+  "mb",
+  "ml",
+  "ms",
+  "me",
+  "w",
+  "h",
+  "size",
+  "min-w",
+  "min-h",
+  "max-w",
+  "max-h",
+  "gap",
+  "gap-x",
+  "gap-y",
+  "inset",
+  "inset-x",
+  "inset-y",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "start",
+  "end",
+  "space-x",
+  "space-y"
+]);
 var PREFIX_BUILTINS = {
   bg: [
     "none",
@@ -11907,8 +12086,12 @@ function readInventory(files) {
     for (const block of themeBlocks(css2)) {
       if (/--\*\s*:\s*initial\b/.test(block)) defaultsReset = true;
       for (const decl of block.matchAll(/--(?<namespace>[a-z][a-z0-9]*)-(?<token>[a-z0-9][a-z0-9_-]*)\s*:/g)) {
-        const namespace = decl.groups?.namespace;
-        const token = decl.groups?.token;
+        let namespace = decl.groups?.namespace;
+        let token = decl.groups?.token;
+        if (namespace === "background" && token?.startsWith("image-")) {
+          namespace = "background-image";
+          token = token.slice("image-".length);
+        }
         if (!namespace || !token) continue;
         let set = themeTokensByNamespace.get(namespace);
         if (!set) {
@@ -11944,7 +12127,7 @@ function isKnown(className, inventory) {
   if (!utility.includes("-")) return true;
   const dash = utility.indexOf("-");
   const firstTwo = utility.split("-").slice(0, 2).join("-");
-  const compound = PREFIX_NAMESPACES[firstTwo] ? firstTwo : void 0;
+  const compound = PREFIX_NAMESPACES[firstTwo] || SPACING_UTILITY_PREFIXES.has(firstTwo) ? firstTwo : void 0;
   const prefix = compound ?? utility.slice(0, dash);
   const token = compound ? utility.slice(compound.length + 1) : utility.slice(dash + 1);
   if (!token) return true;
@@ -11953,6 +12136,7 @@ function isKnown(className, inventory) {
   const namespaces = PREFIX_NAMESPACES[prefix];
   if (!namespaces) {
     if (STATIC_VALUE_TOKENS[prefix]?.includes(token)) return true;
+    if (SPACING_UTILITY_PREFIXES.has(prefix) && inventory.themeTokens.get("spacing")?.has(token)) return true;
     const projectTokens = inventory.themeTokens.get(prefix);
     if (projectTokens) {
       if (projectTokens.has(token)) return true;

package/package.json

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