pasika 0.10.83 → 0.10.85

package/dist/eslint/pasika/index.d.ts

@@ -237,6 +237,7 @@ declare const pasikaPlugin: {
                 };
             };
             create(context: eslint.Rule.RuleContext): {
+                CallExpression(node: ESTree.CallExpression): void;
                 JSXAttribute(node: JsxAttributeNode): void;
             };
         };

package/dist/eslint/pasika/index.js

@@ -3029,6 +3029,31 @@ function stringArguments(node) {
   }
   return [];
 }
+function staticClassLiterals(node) {
+  if (!node) return [];
+  if (node.type === "Literal" && typeof node.value === "string") return [node];
+  if (node.type === "CallExpression") {
+    if (node.callee.type === "Identifier" && node.callee.name === "cn") return [];
+    return node.arguments.flatMap(
+      (argument) => argument.type === "SpreadElement" ? [] : staticClassLiterals(argument)
+    );
+  }
+  if (node.type === "ObjectExpression") {
+    return node.properties.flatMap(
+      (property) => property.type === "Property" ? staticClassLiterals(property.value) : []
+    );
+  }
+  if (node.type === "ArrayExpression") {
+    return node.elements.flatMap((element) => element?.type === "SpreadElement" ? [] : staticClassLiterals(element));
+  }
+  if (node.type === "ConditionalExpression") {
+    return [...staticClassLiterals(node.consequent), ...staticClassLiterals(node.alternate)];
+  }
+  if (node.type === "LogicalExpression") {
+    return [...staticClassLiterals(node.left), ...staticClassLiterals(node.right)];
+  }
+  return [];
+}
 var enforceCnMergeRule = {
   meta: { schema: [], type: "problem", docs: { description: "Enforce cn() for conditional class merging." } },
   create(context) {
@@ -3042,6 +3067,32 @@ var enforceCnMergeRule = {
       }
     }
     return {
+      CallExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+        if (node.callee.name === "cn") {
+          for (const argument of node.arguments) {
+            if (argument.type !== "Literal" || typeof argument.value !== "string" || classCount(argument.value) <= 5) {
+              continue;
+            }
+            context.report({
+              node: argument,
+              message: "Each cn() string argument must contain at most 5 class names. Group by styling concern. See docs/next-tailwind-guide/rules/class-composition-rule.md"
+            });
+          }
+          return;
+        }
+        if (node.callee.name !== "cva") return;
+        for (const argument of node.arguments) {
+          if (argument.type === "SpreadElement") continue;
+          for (const literal of staticClassLiterals(argument)) {
+            if (typeof literal.value !== "string" || classCount(literal.value) <= 5) continue;
+            context.report({
+              node: literal,
+              message: "Static cva class list with more than 5 classes must use cn() with grouped string literals. See docs/next-tailwind-guide/rules/class-composition-rule.md"
+            });
+          }
+        }
+      },
       JSXAttribute(node) {
         const attributeName = node.name?.name ?? "";
         const element = node.parent.parent;
@@ -3107,17 +3158,6 @@ var enforceCnMergeRule = {
             node,
             message: "Static className with more than 5 classes must use cn() with grouped string literals. See docs/next-tailwind-guide/rules/class-composition-rule.md"
           });
-          return;
-        }
-        if (expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "cn") {
-          for (const arg of expr.arguments) {
-            if (arg.type === "Literal" && typeof arg.value === "string" && classCount(arg.value) > 5) {
-              context.report({
-                node: arg,
-                message: "Each cn() string argument must contain at most 5 class names. Group by styling concern. See docs/next-tailwind-guide/rules/class-composition-rule.md"
-              });
-            }
-          }
         }
       }
     };
@@ -6181,14 +6221,16 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
+import ts8 from "typescript";
 var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 function hasTypeAnnotation(identifier) {
   return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
 }
-function directPropertyBinding(context, declarator) {
+function directPropertyBinding(context, declarator, isEnumValue) {
   if (declarator.id.type !== "Identifier" || hasTypeAnnotation(declarator.id)) return void 0;
   if (declarator.init?.type !== "MemberExpression") return void 0;
   const member = declarator.init;
+  if (isEnumValue(member.object)) return void 0;
   if (member.computed || member.optional || member.property.type !== "Identifier") return void 0;
   if (!memberCanBecomeLocal(member)) return void 0;
   if (context.sourceCode.getCommentsInside(declarator).length > 0) return void 0;
@@ -6249,6 +6291,37 @@ function memberCanBecomeLocal(member) {
   if (rootIdentifierName(member) === "locales") return false;
   return member.property.type === "Identifier" && isCompliantLocalName(member.property.name);
 }
+function isEnumDefinition(definition) {
+  return typeof definition === "object" && definition !== null && "type" in definition && definition.type === "TSEnumName";
+}
+function localEnumBinding(context, node) {
+  if (node.type !== "Identifier") return false;
+  let scope = context.sourceCode.getScope(node);
+  for (; ; ) {
+    const variable = scope.variables.find(({ name }) => name === node.name);
+    if (variable) return variable.defs.some(isEnumDefinition);
+    if (scope.upper === null) return false;
+    scope = scope.upper;
+  }
+}
+function enumValueResolver(context) {
+  const services = typedParserServices(context.sourceCode.parserServices);
+  if (!services) return (node) => localEnumBinding(context, node);
+  const checker = services.program.getTypeChecker();
+  const { esTreeNodeToTSNodeMap: nodeMap } = services;
+  const isEnumSymbol = (symbol) => {
+    const resolved = symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts8.isEnumDeclaration(declaration));
+  };
+  return (node) => {
+    const tsNode = nodeMap.get(node);
+    if (!tsNode) return localEnumBinding(context, node);
+    const symbol = checker.getSymbolAtLocation(tsNode);
+    if (symbol && isEnumSymbol(symbol)) return true;
+    const typeSymbol = checker.getTypeAtLocation(tsNode).getSymbol();
+    return typeSymbol ? isEnumSymbol(typeSymbol) : localEnumBinding(context, node);
+  };
+}
 function directMappingRequiresQualifiedAccess(context, ownershipResolver, member) {
   const mapping = renamedDirectMapping(context, member);
   if (!mapping || !ownershipResolver) return false;
@@ -6256,8 +6329,8 @@ function directMappingRequiresQualifiedAccess(context, ownershipResolver, member
   const targetResolution = ownershipResolver.targetProperty(mapping.property, mapping.targetName);
   return sourceResolution.kind === "data-contract" || targetResolution.kind === "data-contract";
 }
-function memberCanBeDestructured(context, ownershipResolver, member) {
-  return memberCanBecomeLocal(member) && !directMappingRequiresQualifiedAccess(context, ownershipResolver, member);
+function memberCanBeDestructured(context, ownershipResolver, member, isEnumValue) {
+  return !isEnumValue(member.object) && memberCanBecomeLocal(member) && !directMappingRequiresQualifiedAccess(context, ownershipResolver, member);
 }
 function objectUsage(scope, sourceText) {
   let usage = scope.objects.get(sourceText);
@@ -6282,9 +6355,9 @@ function memberIsDirectVariableInitializer(context, member) {
   const parent = context.sourceCode.getAncestors(member).at(-1);
   return parent?.type === "VariableDeclarator" && parent.init === member;
 }
-function recordMemberUsage(context, scope, ownershipResolver, member) {
+function recordMemberUsage(context, scope, ownershipResolver, member, isEnumValue) {
   if (!scope || member.computed || member.optional || member.property.type !== "Identifier") return;
-  if (!memberCanBeDestructured(context, ownershipResolver, member)) return;
+  if (!memberCanBeDestructured(context, ownershipResolver, member, isEnumValue)) return;
   if (!isGroupedUsageSource(member.object) || !memberIsRead(context, member)) return;
   const sourceText = context.sourceCode.getText(member.object);
   const usage = objectUsage(scope, sourceText);
@@ -6294,11 +6367,11 @@ function recordMemberUsage(context, scope, ownershipResolver, member) {
     usage.directMembers.push({ member, propertyName: propertyName5 });
   }
 }
-function recordDestructuringUsage(context, scope, declaration) {
+function recordDestructuringUsage(context, scope, declaration, isEnumValue) {
   if (!scope) return;
   for (const declarator of declaration.declarations) {
     if (declarator.id.type !== "ObjectPattern" || !declarator.init || !isGroupedUsageSource(declarator.init)) continue;
-    if (rootIdentifierName(declarator.init) === "locales") continue;
+    if (rootIdentifierName(declarator.init) === "locales" || isEnumValue(declarator.init)) continue;
     const sourceText = context.sourceCode.getText(declarator.init);
     const usage = objectUsage(scope, sourceText);
     if (usage.directMembers.length > 0) continue;
@@ -6345,7 +6418,7 @@ function whitespaceKeepsStatementsAdjacent(text) {
   if (text.trim() !== "") return false;
   return (text.match(/\n/gu) ?? []).length <= 1;
 }
-function groupedDeclarations(context, declaration, firstBinding) {
+function groupedDeclarations(context, declaration, firstBinding, isEnumValue) {
   if (declaration.declarations.length !== 1) {
     return [{ declaration, binding: firstBinding }];
   }
@@ -6365,7 +6438,7 @@ function groupedDeclarations(context, declaration, firstBinding) {
     if (nextNode.declarations.length !== 1) break;
     const nextDeclarator = nextNode.declarations[0];
     if (!nextDeclarator) break;
-    const nextBinding = directPropertyBinding(context, nextDeclarator);
+    const nextBinding = directPropertyBinding(context, nextDeclarator, isEnumValue);
     if (nextBinding?.sourceText !== firstBinding.sourceText) break;
     if (seenProperties.has(nextBinding.propertyName)) break;
     const [, previousEnd] = context.sourceCode.getRange(previous);
@@ -6377,11 +6450,11 @@ function groupedDeclarations(context, declaration, firstBinding) {
   }
   return group;
 }
-function destructuringSelection(context, declaration) {
+function destructuringSelection(context, declaration, isEnumValue) {
   if (declaration.declarations.length !== 1) return void 0;
   const declarator = declaration.declarations[0];
   if (declarator?.id.type !== "ObjectPattern" || !declarator.init) return void 0;
-  if (rootIdentifierName(declarator.init) === "locales") return void 0;
+  if (rootIdentifierName(declarator.init) === "locales" || isEnumValue(declarator.init)) return void 0;
   if (context.sourceCode.getCommentsInside(declarator).length > 0) return void 0;
   const bindingTexts = [];
   const localNames = [];
@@ -6404,7 +6477,7 @@ function destructuringSelection(context, declaration) {
     propertyNames
   };
 }
-function groupedDestructuringSelections(context, first) {
+function groupedDestructuringSelections(context, first, isEnumValue) {
   const parent = context.sourceCode.getAncestors(first.declaration).at(-1);
   if (parent?.type !== "Program" && parent?.type !== "BlockStatement") return [first];
   const body = parent.body;
@@ -6416,7 +6489,7 @@ function groupedDestructuringSelections(context, first) {
     const nextNode = body[index];
     const previous = group.at(-1)?.declaration;
     if (!previous || nextNode?.type !== "VariableDeclaration" || nextNode.kind !== first.declaration.kind) break;
-    const next = destructuringSelection(context, nextNode);
+    const next = destructuringSelection(context, nextNode, isEnumValue);
     if (next?.sourceText !== first.sourceText) break;
     if (next.propertyNames.some((propertyName5) => seenProperties.has(propertyName5))) break;
     const [, previousEnd] = context.sourceCode.getRange(previous);
@@ -6457,6 +6530,7 @@ var preferObjectDestructuringRule = {
   },
   create(context) {
     const ownershipResolver = contractOwnershipResolver(context);
+    const isEnumValue = enumValueResolver(context);
     const grouped = /* @__PURE__ */ new Set();
     const usageScopes = [];
     const currentUsageScope = () => usageScopes.at(-1);
@@ -6521,14 +6595,22 @@ ${indentation}`;
       ArrowFunctionExpression: enterUsageBarrier,
       "ArrowFunctionExpression:exit": exitUsageScope,
       MemberExpression(node) {
-        recordMemberUsage(context, currentUsageScope(), ownershipResolver, node);
+        recordMemberUsage(context, currentUsageScope(), ownershipResolver, node, isEnumValue);
       },
       VariableDeclaration(node) {
-        recordDestructuringUsage(context, currentUsageScope(), node);
+        for (const declarator of node.declarations) {
+          if (declarator.id.type !== "ObjectPattern" || !declarator.init || !isEnumValue(declarator.init)) continue;
+          const sourceText = context.sourceCode.getText(declarator.init);
+          context.report({
+            node: declarator.id,
+            message: `"${sourceText}" is an enum. Keep enum member accesses qualified instead of destructuring it. ${DOC5}`
+          });
+        }
+        recordDestructuringUsage(context, currentUsageScope(), node, isEnumValue);
         if (grouped.has(node)) return;
-        const selection = destructuringSelection(context, node);
+        const selection = destructuringSelection(context, node, isEnumValue);
         if (selection) {
-          const group = groupedDestructuringSelections(context, selection);
+          const group = groupedDestructuringSelections(context, selection, isEnumValue);
           if (group.length <= 1) return;
           for (const item of group.slice(1)) grouped.add(item.declaration);
           const lastDeclaration = group.at(-1)?.declaration;
@@ -6550,7 +6632,7 @@ ${indentation}`;
           });
           return;
         }
-        const bindings = node.declarations.map((declarator) => directPropertyBinding(context, declarator)).filter((binding) => binding !== void 0);
+        const bindings = node.declarations.map((declarator) => directPropertyBinding(context, declarator, isEnumValue)).filter((binding) => binding !== void 0);
         if (bindings.length === 0) return;
         const firstBinding = bindings[0];
         if (!firstBinding) return;
@@ -6571,7 +6653,7 @@ ${indentation}`;
           return;
         }
         if (node.declarations.length === 1 && bindings.length === 1) {
-          const group = groupedDeclarations(context, node, firstBinding);
+          const group = groupedDeclarations(context, node, firstBinding, isEnumValue);
           if (group.length > 1) {
             for (const item of group.slice(1)) grouped.add(item.declaration);
             const groupBindings = group.map(({ binding }) => binding);
@@ -7144,7 +7226,7 @@ var rootSupportPlacementRule = {
 
 // eslint/rules/route-handler-shape.ts
 import path48 from "path";
-import ts8 from "typescript";
+import ts9 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -7162,33 +7244,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts8.isForStatement(node) || ts8.isForOfStatement(node) || ts8.isForInStatement(node) || ts8.isWhileStatement(node) || ts8.isDoStatement(node);
+  return ts9.isForStatement(node) || ts9.isForOfStatement(node) || ts9.isForInStatement(node) || ts9.isWhileStatement(node) || ts9.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts8.isFunctionExpression(node) || ts8.isArrowFunction(node) || ts8.isFunctionDeclaration(node);
+  return ts9.isFunctionExpression(node) || ts9.isArrowFunction(node) || ts9.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts8.createSourceFile(
+  const sourceFile = ts9.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts8.ScriptTarget.Latest,
+    ts9.ScriptTarget.Latest,
     true,
-    ts8.ScriptKind.TS
+    ts9.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts8.isTryStatement(node)) kinds.add("try");
+    if (ts9.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts8.isIfStatement(node)) kinds.add("if");
-    if (ts8.isCallExpression(node) && ts8.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts9.isIfStatement(node)) kinds.add("if");
+    if (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts8.isCallExpression(node) && ts8.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -7350,38 +7432,38 @@ var schemaCasingRule = {
 
 // eslint/rules/sole-state-owner.ts
 import path50 from "path";
-import ts9 from "typescript";
+import ts10 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts9.isCallExpression(child) && ts9.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts9.isVariableDeclaration(child.parent)) {
+    if (ts10.isCallExpression(child) && ts10.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts10.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts9.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts10.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts9.isBindingElement(value) && ts9.isBindingElement(updater)) {
+          if (value && updater && ts10.isBindingElement(value) && ts10.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts9.isIdentifier(valueName) && ts9.isIdentifier(updaterName)) {
+            if (ts10.isIdentifier(valueName) && ts10.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts9.forEachChild(child, visit);
+    ts10.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts9.isIdentifier(node) && node.text === hook.value) {
+  if (ts10.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts9.isBindingElement(parent) || ts9.isPropertyAccessExpression(parent) || ts9.isShorthandPropertyAssignment(parent)) {
+    if (ts10.isBindingElement(parent) || ts10.isPropertyAccessExpression(parent) || ts10.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -7391,16 +7473,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts9.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts9.isJsxFragment(expression)) {
+  while (ts10.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts10.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
+      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts9.isJsxElement(expression)) {
+  if (ts10.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts9.isJsxText(c) && !ts9.isJsxSpreadAttribute(c)
+      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -7414,8 +7496,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node)) return;
-    ts9.forEachChild(node, visit);
+    if (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node)) return;
+    ts10.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -7454,18 +7536,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts9.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts9.isBlock(body)) return void 0;
+  const body = ts10.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts10.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts9.isFunctionLike(node) || ts9.isClassLike(node))) return;
-    if (ts9.isReturnStatement(node)) returns.push(node);
-    ts9.forEachChild(node, visit);
+    if (node !== body && (ts10.isFunctionLike(node) || ts10.isClassLike(node))) return;
+    if (ts10.isReturnStatement(node)) returns.push(node);
+    ts10.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts9.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts10.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -7488,11 +7570,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts9.isFunctionDeclaration(node) || ts9.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts9.isSourceFile(current)) {
+      while (!ts10.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -7501,7 +7583,7 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;

package/package.json

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