pasika 0.10.90 → 0.10.91

package/dist/eslint/pasika/index.js

@@ -6200,6 +6200,7 @@ var nextjsPackageJsonRules = {
 
 // eslint/rules/prefer-enum.ts
 import path44 from "path";
+import ts8 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -6242,12 +6243,33 @@ function rawZodDiscriminantLiteral(schemaCall, discriminator) {
   }
   return void 0;
 }
+function isLiteralTupleAssertion(node) {
+  if (!isConstAssertion(node)) return false;
+  const expression = node.expression;
+  if (expression?.type !== "ArrayExpression" || expression.elements.length < 2) return false;
+  const values = expression.elements.map((element) => {
+    if (element?.type !== "Literal") return void 0;
+    return typeof element.value === "string" || typeof element.value === "number" ? element.value : void 0;
+  });
+  return values.every((value) => value !== void 0) && new Set(values).size >= 2;
+}
+function isTsLiteralTupleDeclaration(declaration) {
+  if (!ts8.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  const init = declaration.initializer;
+  if (!ts8.isAsExpression(init) || !ts8.isTypeReferenceNode(init.type) || !ts8.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts8.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
+    return false;
+  }
+  const values = init.expression.elements.map(
+    (element) => ts8.isStringLiteral(element) || ts8.isNumericLiteral(element) ? element.text : void 0
+  );
+  return values.every((value) => value !== void 0) && new Set(values).size >= 2;
+}
 var preferEnumRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require fixed sets of named string/number values to be TypeScript enums, including Zod discriminated-union discriminator values."
+      description: "Require fixed sets of named string/number values to be TypeScript enums, including named Zod enum tuples and discriminated-union discriminator values."
     }
   },
   create(context) {
@@ -6255,20 +6277,54 @@ var preferEnumRule = {
     const sourceRoot = sourceRootOf(context);
     if (!filename.startsWith(sourceRoot + path44.sep)) return {};
     const objectSchemas = /* @__PURE__ */ new Map();
+    const literalTuples = /* @__PURE__ */ new Set();
+    const enumTupleUses = [];
     const discriminatedUnions = [];
     const reportedDiscriminants = /* @__PURE__ */ new Set();
+    const services = typedParserServices(context.sourceCode.parserServices);
+    function isTupleDomain(name) {
+      if (!services) return literalTuples.has(name.name);
+      const tsNode = services.esTreeNodeToTSNodeMap.get(name);
+      if (!tsNode) return false;
+      const checker = services.program.getTypeChecker();
+      const symbol = checker.getSymbolAtLocation(tsNode);
+      if (!symbol) return false;
+      const original = symbol.flags === ts8.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
+    }
     return {
       VariableDeclarator(node) {
         const { id, init } = node;
-        if (id?.type !== "Identifier" || init?.type !== "CallExpression" || !isZodCall(init, "object")) return;
-        objectSchemas.set(id.name, init);
+        if (id?.type !== "Identifier" || !init) return;
+        if (init.type === "CallExpression" && isZodCall(init, "object")) {
+          objectSchemas.set(id.name, init);
+        }
       },
       CallExpression(node) {
         if (isZodCall(node, "discriminatedUnion")) {
           discriminatedUnions.push(node);
         }
+        const argument = node.arguments?.[0];
+        if (isZodCall(node, "enum") && argument?.type === "Identifier") {
+          enumTupleUses.push({ name: argument, node });
+        }
+      },
+      TSIndexedAccessType(node) {
+        const { objectType, indexType } = node;
+        if (objectType?.type === "TSTypeQuery" && objectType.exprName?.type === "Identifier" && indexType?.type === "TSNumberKeyword") {
+          enumTupleUses.push({ name: objectType.exprName, node });
+        }
       },
       "Program:exit"() {
+        const reportedTuples = /* @__PURE__ */ new Set();
+        for (const use of enumTupleUses) {
+          if (reportedTuples.has(use.name.name) || !isTupleDomain(use.name)) continue;
+          reportedTuples.add(use.name.name);
+          context.report({
+            node: use.node,
+            message: "A const tuple used as a named enum domain must be replaced with a TypeScript enum. See docs/next-codebase-guide/rules/constants-rule.md"
+          });
+        }
         for (const unionCall of discriminatedUnions) {
           const [discriminatorArg, optionsArg] = unionCall.arguments ?? [];
           if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression") {
@@ -6295,6 +6351,10 @@ var preferEnumRule = {
       },
       TSAsExpression(node) {
         if (!isConstAssertion(node)) return;
+        if (isLiteralTupleAssertion(node) && node.parent?.type === "VariableDeclarator") {
+          const { id } = node.parent;
+          if (id.type === "Identifier") literalTuples.add(id.name);
+        }
         const expression = node.expression;
         if (!expression || expression.type !== "ObjectExpression") return;
         if (expression.properties.length === 0) return;
@@ -6324,7 +6384,7 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
-import ts8 from "typescript";
+import ts9 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;
@@ -6413,8 +6473,8 @@ function enumValueResolver(context) {
   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));
+    const resolved = symbol.flags === ts9.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts9.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -7329,7 +7389,7 @@ var rootSupportPlacementRule = {
 
 // eslint/rules/route-handler-shape.ts
 import path49 from "path";
-import ts9 from "typescript";
+import ts10 from "typescript";
 var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 var REQUIRED_BOUNDARY = "withResponse";
 function isFunctionLike(node) {
@@ -7347,33 +7407,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts9.isForStatement(node) || ts9.isForOfStatement(node) || ts9.isForInStatement(node) || ts9.isWhileStatement(node) || ts9.isDoStatement(node);
+  return ts10.isForStatement(node) || ts10.isForOfStatement(node) || ts10.isForInStatement(node) || ts10.isWhileStatement(node) || ts10.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts9.isFunctionExpression(node) || ts9.isArrowFunction(node) || ts9.isFunctionDeclaration(node);
+  return ts10.isFunctionExpression(node) || ts10.isArrowFunction(node) || ts10.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts9.createSourceFile(
+  const sourceFile = ts10.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts9.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    ts9.ScriptKind.TS
+    ts10.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts9.isTryStatement(node)) kinds.add("try");
+    if (ts10.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts9.isIfStatement(node)) kinds.add("if");
-    if (ts9.isCallExpression(node) && ts9.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts10.isIfStatement(node)) kinds.add("if");
+    if (ts10.isCallExpression(node) && ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts9.isCallExpression(node) && ts9.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -7535,38 +7595,38 @@ var schemaCasingRule = {
 
 // eslint/rules/sole-state-owner.ts
 import path51 from "path";
-import ts10 from "typescript";
+import ts11 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts10.isCallExpression(child) && ts10.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts10.isVariableDeclaration(child.parent)) {
+    if (ts11.isCallExpression(child) && ts11.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts11.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts10.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts11.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts10.isBindingElement(value) && ts10.isBindingElement(updater)) {
+          if (value && updater && ts11.isBindingElement(value) && ts11.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts10.isIdentifier(valueName) && ts10.isIdentifier(updaterName)) {
+            if (ts11.isIdentifier(valueName) && ts11.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts10.forEachChild(child, visit);
+    ts11.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts10.isCallExpression(node) && ts10.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts10.isIdentifier(node) && node.text === hook.value) {
+  if (ts11.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts10.isBindingElement(parent) || ts10.isPropertyAccessExpression(parent) || ts10.isShorthandPropertyAssignment(parent)) {
+    if (ts11.isBindingElement(parent) || ts11.isPropertyAccessExpression(parent) || ts11.isShorthandPropertyAssignment(parent)) {
       return void 0;
     }
     return "value";
@@ -7576,16 +7636,16 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts10.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts10.isJsxFragment(expression)) {
+  while (ts11.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts11.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
+      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts10.isJsxElement(expression)) {
+  if (ts11.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts10.isJsxText(c) && !ts10.isJsxSpreadAttribute(c)
+      (c) => !ts11.isJsxText(c) && !ts11.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
@@ -7599,8 +7659,8 @@ function collectUsesIn(child, hook) {
       positions.push(node);
       count += 1;
     }
-    if (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node)) return;
-    ts10.forEachChild(node, visit);
+    if (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node)) return;
+    ts11.forEachChild(node, visit);
   };
   visit(child);
   return { positions, count };
@@ -7639,18 +7699,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts10.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts10.isBlock(body)) return void 0;
+  const body = ts11.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts11.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts10.isFunctionLike(node) || ts10.isClassLike(node))) return;
-    if (ts10.isReturnStatement(node)) returns.push(node);
-    ts10.forEachChild(node, visit);
+    if (node !== body && (ts11.isFunctionLike(node) || ts11.isClassLike(node))) return;
+    if (ts11.isReturnStatement(node)) returns.push(node);
+    ts11.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const single = returns[0];
-  if (!single?.expression || !ts10.isExpression(single.expression)) return void 0;
+  if (!single?.expression || !ts11.isExpression(single.expression)) return void 0;
   const returnExpression = single.expression;
   const root = topLevelJsxChildren(returnExpression);
   if (!root || root.children.length === 0) return void 0;
@@ -7673,11 +7733,11 @@ function usesOutsideJsx(declaration, hook, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts10.isFunctionDeclaration(node) || ts10.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts11.isFunctionDeclaration(node) || ts11.isClassDeclaration(node))) return;
     if (isHookUsage(node, hook)) {
       let current = node;
       let isInJsxChild = false;
-      while (!ts10.isSourceFile(current)) {
+      while (!ts11.isSourceFile(current)) {
         if (children.includes(current)) {
           isInJsxChild = true;
           break;
@@ -7686,7 +7746,7 @@ function usesOutsideJsx(declaration, hook, children) {
       }
       if (!isInJsxChild) outside = true;
     }
-    ts10.forEachChild(node, visit);
+    ts11.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;

package/package.json

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