pasika 0.10.44 → 0.10.46

package/dist/eslint/pasika/index.js

@@ -5184,19 +5184,82 @@ function isEnumLiteralType(node) {
 function isEnumLiteralUnion(node) {
   return node?.type === "TSUnionType" && (node.types?.length ?? 0) >= 2 && (node.types ?? []).every(isEnumLiteralType);
 }
+function isZodCall(node, method) {
+  const { callee } = node;
+  return callee?.type === "MemberExpression" && !callee.computed && callee.object.type === "Identifier" && callee.object.name === "z" && callee.property.type === "Identifier" && callee.property.name === method;
+}
+function propertyName2(property) {
+  if (property.computed) return void 0;
+  if (property.key.type === "Identifier") return property.key.name;
+  if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
+  return void 0;
+}
+function rawZodDiscriminantLiteral(schemaCall, discriminator) {
+  if (!isZodCall(schemaCall, "object")) return void 0;
+  const shape = schemaCall.arguments[0];
+  if (shape?.type !== "ObjectExpression") return void 0;
+  for (const property of shape.properties) {
+    if (property.type !== "Property" || propertyName2(property) !== discriminator) continue;
+    if (property.value.type !== "CallExpression" || !isZodCall(property.value, "literal")) return void 0;
+    const literal = property.value.arguments[0];
+    if (literal?.type === "Literal" && (typeof literal.value === "string" || typeof literal.value === "number")) {
+      return literal;
+    }
+    return void 0;
+  }
+  return void 0;
+}
 var preferEnumRule = {
   meta: {
     schema: [],
     type: "problem",
     docs: {
-      description: "Require fixed sets of named string/number values to be TypeScript enums instead of `as const` objects or literal-union type aliases."
+      description: "Require fixed sets of named string/number values to be TypeScript enums, including Zod discriminated-union discriminator values."
     }
   },
   create(context) {
     const filename = path40.resolve(context.filename);
     const sourceRoot = sourceRootOf(context);
     if (!filename.startsWith(sourceRoot + path40.sep)) return {};
+    const objectSchemas = /* @__PURE__ */ new Map();
+    const discriminatedUnions = [];
+    const reportedDiscriminants = /* @__PURE__ */ new Set();
     return {
+      VariableDeclarator(node) {
+        const { id, init } = node;
+        if (id?.type !== "Identifier" || init?.type !== "CallExpression" || !isZodCall(init, "object")) return;
+        objectSchemas.set(id.name, init);
+      },
+      CallExpression(node) {
+        if (isZodCall(node, "discriminatedUnion")) {
+          discriminatedUnions.push(node);
+        }
+      },
+      "Program:exit"() {
+        for (const unionCall of discriminatedUnions) {
+          const [discriminatorArg, optionsArg] = unionCall.arguments ?? [];
+          if (discriminatorArg?.type !== "Literal" || typeof discriminatorArg.value !== "string" || optionsArg?.type !== "ArrayExpression") {
+            continue;
+          }
+          for (const option of optionsArg.elements) {
+            if (!option || option.type === "SpreadElement") continue;
+            let schemaCall;
+            if (option.type === "Identifier") {
+              schemaCall = objectSchemas.get(option.name);
+            } else if (option.type === "CallExpression" && isZodCall(option, "object")) {
+              schemaCall = option;
+            }
+            if (!schemaCall) continue;
+            const literal = rawZodDiscriminantLiteral(schemaCall, discriminatorArg.value);
+            if (!literal || reportedDiscriminants.has(literal)) continue;
+            reportedDiscriminants.add(literal);
+            context.report({
+              node: literal,
+              message: "A Zod discriminated-union discriminator literal must use a TypeScript enum member. See docs/next-codebase-guide/rules/constants-rule.md"
+            });
+          }
+        }
+      },
       TSAsExpression(node) {
         if (!isConstAssertion(node)) return;
         const expression = node.expression;
@@ -5214,6 +5277,14 @@ var preferEnumRule = {
           node,
           message: "A named union made only of string or number literals must be a TypeScript enum. See docs/next-codebase-guide/rules/constants-rule.md"
         });
+      },
+      TSPropertySignature(node) {
+        const typeAnnotation = node.typeAnnotation?.typeAnnotation;
+        if (!isEnumLiteralUnion(typeAnnotation)) return;
+        context.report({
+          node,
+          message: "A property whose type is a union made only of string or number literals must use a TypeScript enum. See docs/next-codebase-guide/rules/constants-rule.md"
+        });
       }
     };
   }

package/package.json

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