@sarj/eslint-plugin 1.0.1 → 2.0.1

package/dist/index.js

@@ -1,98 +1,1052 @@
-import { zodNamingConvention } from "./rules/zod-naming-convention.js";
-import { requireAssertNever } from "./rules/require-assert-never.js";
-import { requireZodFormValidation } from "./rules/require-zod-form-validation.js";
-import { enforceFileStructure } from "./rules/enforce-file-structure.js";
-import { noRawEnv } from "./rules/no-raw-env.js";
-import { preferShadcn } from "./rules/prefer-shadcn.js";
-import { noEnum } from "./rules/no-enum.js";
-/**
- * @sarj/eslint-plugin
- *
- * Custom ESLint rules collection for Sarj projects.
- * Supports ESLint 9+ flat config format.
- */
-const rules = {
-    "zod-naming-convention": zodNamingConvention,
-    "require-assert-never": requireAssertNever,
-    "require-zod-form-validation": requireZodFormValidation,
-    "enforce-file-structure": enforceFileStructure,
-    "no-raw-env": noRawEnv,
-    "prefer-shadcn": preferShadcn,
-    "no-enum": noEnum,
-};
-const plugin = {
-    meta: {
-        name: "@sarj/eslint-plugin",
-        version: "1.0.0",
+// src/rules/enforce-file-structure.ts
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+var SECTION = {
+  imports: 0,
+  types: 1,
+  constants: 2,
+  functions: 3,
+  exports: 4
+};
+var SECTION_NAMES = [
+  "imports",
+  "types",
+  "constants",
+  "functions",
+  "exports"
+];
+var sectionName = (ordinal) => {
+  const name = SECTION_NAMES[ordinal];
+  return name ?? "unknown";
+};
+var isConstantNamed = (declarator) => {
+  if (declarator.id.type !== AST_NODE_TYPES.Identifier) return false;
+  const name = declarator.id.name;
+  return name.length > 0 && name === name.toUpperCase();
+};
+var getStatementSection = (statement) => {
+  switch (statement.type) {
+    case AST_NODE_TYPES.ImportDeclaration:
+      return SECTION.imports;
+    case AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case AST_NODE_TYPES.TSInterfaceDeclaration:
+    case AST_NODE_TYPES.TSEnumDeclaration:
+      return SECTION.types;
+    case AST_NODE_TYPES.VariableDeclaration: {
+      if (statement.kind === "const") {
+        const firstDeclarator = statement.declarations[0];
+        if (firstDeclarator !== void 0 && isConstantNamed(firstDeclarator)) {
+          return SECTION.constants;
+        }
+      }
+      return SECTION.functions;
+    }
+    case AST_NODE_TYPES.FunctionDeclaration:
+      return SECTION.functions;
+    case AST_NODE_TYPES.ExportNamedDeclaration:
+    case AST_NODE_TYPES.ExportDefaultDeclaration:
+    case AST_NODE_TYPES.ExportAllDeclaration:
+      return SECTION.exports;
+    default:
+      return SECTION.functions;
+  }
+};
+var isUseServerDirective = (statement) => {
+  if (statement === void 0) return false;
+  if (statement.type !== AST_NODE_TYPES.ExpressionStatement) return false;
+  const expr = statement.expression;
+  if (expr.type !== AST_NODE_TYPES.Literal) return false;
+  return expr.value === "use server";
+};
+var enforce_file_structure_default = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "enforce-file-structure",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce a canonical top-of-file ordering: imports -> types -> constants -> functions -> exports. Server-action files (under `/actions/` or with `action` in the path) must also begin with a `use server` directive."
     },
-    rules,
-};
-// ESLint 9 flat configs
-const configs = {
-    // Basic sarj rules only
-    recommended: [
-        {
-            plugins: {
-                "@sarj": plugin,
-            },
-            rules: {
-                "@sarj/zod-naming-convention": "warn",
-                "@sarj/require-assert-never": "error",
-                "@sarj/require-zod-form-validation": "error",
-                "@sarj/enforce-file-structure": "warn",
-            },
-        },
-    ],
-    // All sarj rules at error level
-    strict: [
-        {
-            plugins: {
-                "@sarj": plugin,
-            },
-            rules: {
-                "@sarj/zod-naming-convention": "error",
-                "@sarj/require-assert-never": "error",
-                "@sarj/require-zod-form-validation": "error",
-                "@sarj/enforce-file-structure": "error",
-                "@sarj/no-raw-env": "error",
-                "@sarj/prefer-shadcn": "error",
-                "@sarj/no-enum": "error",
-            },
-        },
-    ],
-    // Comprehensive style guide rules (sarj + external)
-    "style-guide": [
-        {
-            plugins: {
-                "@sarj": plugin,
-            },
-            rules: {
-                // === Sarj custom rules ===
-                "@sarj/zod-naming-convention": "error",
-                "@sarj/require-assert-never": "error",
-                "@sarj/require-zod-form-validation": "error",
-                "@sarj/enforce-file-structure": "error",
-                "@sarj/no-raw-env": "error",
-                "@sarj/prefer-shadcn": "error",
-                "@sarj/no-enum": "error",
-                // === Core ESLint rules ===
-                "no-var": "error",
-                "prefer-const": "error",
-                "object-shorthand": ["error", "always"],
-                "no-nested-ternary": "error",
-                "no-console": ["warn", { allow: ["warn", "error"] }],
-                eqeqeq: ["error", "always"],
-                "no-param-reassign": "error",
-                "no-return-await": "error",
-                "prefer-template": "error",
-                "array-callback-return": "error",
-                // === Complexity limits ===
-                complexity: ["warn", { max: 15 }],
-                "max-depth": ["warn", { max: 4 }],
-                "max-nested-callbacks": ["warn", { max: 3 }],
-                "max-params": ["error", { max: 5 }],
-            },
-        },
+    schema: [],
+    messages: {
+      incorrectOrder: "File structure violation: {{current}} should come before {{expected}}",
+      useServerDirective: "Server action files must start with 'use server' directive"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename;
+    const isServerAction = filename.includes("/actions/") || filename.includes("action");
+    return {
+      Program(node) {
+        const body = node.body;
+        if (isServerAction) {
+          const firstNode = body[0];
+          if (!isUseServerDirective(firstNode)) {
+            context.report({
+              node,
+              messageId: "useServerDirective"
+            });
+          }
+        }
+        let currentSection = SECTION.imports;
+        for (const statement of body) {
+          if (isUseServerDirective(statement)) continue;
+          if (statement.type === AST_NODE_TYPES.ExpressionStatement && statement.expression.type === AST_NODE_TYPES.Literal && typeof statement.expression.value === "string" && statement.expression.value.startsWith("use ")) {
+            continue;
+          }
+          const statementSection = getStatementSection(statement);
+          if (statementSection < currentSection) {
+            context.report({
+              node: statement,
+              messageId: "incorrectOrder",
+              data: {
+                current: sectionName(statementSection),
+                expected: sectionName(currentSection)
+              }
+            });
+          } else if (statementSection > currentSection) {
+            currentSection = statementSection;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-client-side-data-fetching.ts
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES2,
+  ESLintUtils as ESLintUtils2
+} from "@typescript-eslint/utils";
+var FETCH_LIBS = /* @__PURE__ */ new Set(["axios", "ky", "superagent"]);
+var HTTP_METHOD_NAMES = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "request",
+  "head",
+  "options"
+]);
+var ANALYTICS_KEYWORDS = [
+  "analytics",
+  "telemetry",
+  "track",
+  "log",
+  "ping",
+  "beacon",
+  "metrics",
+  "event"
+];
+function isEffectHookCall(node) {
+  const callee = node.callee;
+  if (callee.type === AST_NODE_TYPES2.Identifier) {
+    return callee.name === "useEffect" || callee.name === "useLayoutEffect";
+  }
+  if (callee.type === AST_NODE_TYPES2.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES2.Identifier && callee.object.name === "React" && callee.property.type === AST_NODE_TYPES2.Identifier) {
+    return callee.property.name === "useEffect" || callee.property.name === "useLayoutEffect";
+  }
+  return false;
+}
+function readMethodProperty(optionsArg) {
+  if (!optionsArg || optionsArg.type !== AST_NODE_TYPES2.ObjectExpression) {
+    return null;
+  }
+  for (const prop of optionsArg.properties) {
+    if (prop.type !== AST_NODE_TYPES2.Property) continue;
+    if (prop.computed) continue;
+    const key = prop.key;
+    const matchesMethodKey = key.type === AST_NODE_TYPES2.Identifier && key.name === "method" || key.type === AST_NODE_TYPES2.Literal && key.value === "method";
+    if (!matchesMethodKey) continue;
+    if (prop.value.type === AST_NODE_TYPES2.Literal && typeof prop.value.value === "string") {
+      return prop.value.value.toUpperCase();
+    }
+    return null;
+  }
+  return null;
+}
+function isFetchCall(node) {
+  const callee = node.callee;
+  if (callee.type === AST_NODE_TYPES2.Identifier && callee.name === "fetch") {
+    const method = readMethodProperty(node.arguments[1]);
+    if (method !== null && method !== "GET") {
+      return false;
+    }
+    return true;
+  }
+  if (callee.type === AST_NODE_TYPES2.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES2.Identifier && FETCH_LIBS.has(callee.object.name) && callee.property.type === AST_NODE_TYPES2.Identifier) {
+    return HTTP_METHOD_NAMES.has(callee.property.name);
+  }
+  if (callee.type === AST_NODE_TYPES2.Identifier && (callee.name === "axios" || callee.name === "ky")) {
+    const firstArg = node.arguments[0];
+    const secondArg = node.arguments[1];
+    let configArg;
+    if (firstArg?.type === AST_NODE_TYPES2.ObjectExpression) {
+      configArg = firstArg;
+    } else if (secondArg?.type === AST_NODE_TYPES2.ObjectExpression) {
+      configArg = secondArg;
+    }
+    const method = readMethodProperty(configArg);
+    if (method !== null && method !== "GET") {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function extractUrlString(node) {
+  const firstArg = node.arguments[0];
+  if (!firstArg) return "";
+  if (firstArg.type === AST_NODE_TYPES2.Literal && typeof firstArg.value === "string") {
+    return firstArg.value;
+  }
+  if (firstArg.type === AST_NODE_TYPES2.TemplateLiteral) {
+    return firstArg.quasis.map((q) => q.value.cooked).join("");
+  }
+  if (firstArg.type === AST_NODE_TYPES2.Identifier) {
+    return firstArg.name;
+  }
+  return "";
+}
+function isAnalyticsCall(node) {
+  const url = extractUrlString(node).toLowerCase();
+  if (url === "") return false;
+  return ANALYTICS_KEYWORDS.some((keyword) => url.includes(keyword));
+}
+var no_client_side_data_fetching_default = ESLintUtils2.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-client-side-data-fetching",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow data fetching inside `useEffect` / `useLayoutEffect`; prefer React Server Components, Server Actions, or a client-side cache (SWR / React Query)."
+    },
+    schema: [],
+    messages: {
+      noClientFetch: "Avoid direct data fetching inside useEffect / useLayoutEffect. This causes waterfalls and layout shifts. Prefer React Server Components, Server Actions, or client-side caching libraries like SWR or React Query."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    let effectDepth = 0;
+    return {
+      CallExpression(node) {
+        if (isEffectHookCall(node)) {
+          effectDepth += 1;
+          return;
+        }
+        if (effectDepth === 0) return;
+        if (!isFetchCall(node)) return;
+        if (isAnalyticsCall(node)) return;
+        context.report({ node, messageId: "noClientFetch" });
+      },
+      "CallExpression:exit"(node) {
+        if (isEffectHookCall(node)) {
+          effectDepth -= 1;
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-enum.ts
+import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+var DEFAULT_IGNORE_PATTERNS = [
+  /[\\/]generated[\\/]/,
+  /\.gen\.tsx?$/,
+  /\.generated\.tsx?$/
+];
+function matchesAnyPattern(filename, patterns) {
+  for (const pattern of patterns) {
+    const regexSource = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "::DOUBLESTAR::").replace(/\*/g, "[^/\\\\]*").replace(/::DOUBLESTAR::/g, ".*");
+    if (new RegExp(`^${regexSource}$`).test(filename)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasGeneratedMarker(sourceText) {
+  const head = sourceText.slice(0, 1024);
+  return /@generated\b/.test(head);
+}
+var no_enum_default = ESLintUtils3.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-enum",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow TypeScript `enum`; use string-literal unions or `as const` objects instead."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          ignoreFiles: {
+            type: "array",
+            items: { type: "string" }
+          }
+        }
+      }
     ],
+    messages: {
+      noEnum: 'Enums are discouraged. Use a string-literal union (e.g. `type Status = "active" | "inactive"`) or an `as const` object instead.'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [optionsArg]) {
+    const options = optionsArg ?? {};
+    const ignoreFiles = options.ignoreFiles ?? [];
+    const filename = context.filename;
+    const sourceText = context.sourceCode.getText();
+    const isIgnoredByDefault = DEFAULT_IGNORE_PATTERNS.some(
+      (re) => re.test(filename)
+    );
+    const isIgnoredByOption = ignoreFiles.length > 0 && matchesAnyPattern(filename, ignoreFiles);
+    const isGenerated = hasGeneratedMarker(sourceText);
+    if (isIgnoredByDefault || isIgnoredByOption || isGenerated) {
+      return {};
+    }
+    return {
+      TSEnumDeclaration(node) {
+        context.report({
+          node,
+          messageId: "noEnum"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/no-raw-env.ts
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+var no_raw_env_default = ESLintUtils4.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-raw-env",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow direct `process.env` access; use a Zod-validated env module instead."
+    },
+    schema: [],
+    messages: {
+      noRawEnv: "Do not read from `process.env` directly. Import the Zod-validated env module instead so values are typed and validated at startup."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (node.computed) {
+          return;
+        }
+        if (node.object.type === "Identifier" && node.object.name === "process" && node.property.type === "Identifier" && node.property.name === "env") {
+          context.report({
+            node,
+            messageId: "noRawEnv"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-unnecessary-use-client.ts
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES3,
+  ESLintUtils as ESLintUtils5
+} from "@typescript-eslint/utils";
+var HOOK_REGEX = /^use([A-Z]|$)/;
+var EVENT_PROP_REGEX = /^on[A-Z]/;
+var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
+var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "navigator",
+  "localStorage",
+  "sessionStorage",
+  "location",
+  "history",
+  "screen",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "CustomEvent",
+  "Event",
+  "MouseEvent",
+  "KeyboardEvent",
+  "TouchEvent"
+]);
+var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-day-picker|@floating-ui\/|react-select|react-toastify|react-hook-form|recharts|react-dropzone|react-slick|react-swipeable|react-resizable|react-draggable|react-beautiful-dnd|@hello-pangea\/dnd|react-virtualized|react-window|@tanstack\/react-table|@tanstack\/react-query|react-redux|recoil|jotai|zustand|@tippyjs\/react|react-color|react-datepicker|next-themes|react-helmet|react-helmet-async|styled-components|@emotion\/)/;
+var isUseClientDirective = (node) => {
+  return node.type === AST_NODE_TYPES3.ExpressionStatement && node.expression.type === AST_NODE_TYPES3.Literal && node.expression.value === "use client";
+};
+var isGlobalReference = (node, context) => {
+  if (!BROWSER_GLOBALS.has(node.name)) return false;
+  const parent = node.parent;
+  if (parent !== void 0) {
+    if (parent.type === AST_NODE_TYPES3.MemberExpression && parent.property === node && !parent.computed) {
+      return false;
+    }
+    if (parent.type === AST_NODE_TYPES3.Property && parent.key === node && !parent.computed) {
+      return false;
+    }
+    if (parent.type.startsWith("TS")) {
+      return false;
+    }
+  }
+  let scope = context.sourceCode.getScope(node);
+  while (scope !== null) {
+    const variable = scope.set.get(node.name);
+    if (variable !== void 0 && variable.defs.length > 0) {
+      return false;
+    }
+    scope = scope.upper;
+  }
+  return true;
+};
+var no_unnecessary_use_client_default = ESLintUtils5.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "no-unnecessary-use-client",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag `'use client'` files with no hooks or event handlers \u2014 they could be RSC."
+    },
+    schema: [],
+    messages: {
+      unnecessaryUseClient: "'use client' directive but no hooks (use*), JSX event handlers (on*), browser globals, or client-only imports found. Consider removing the directive and serving as a React Server Component."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename;
+    if (ERROR_FILE_REGEX.test(filename)) {
+      return {};
+    }
+    let directiveNode = null;
+    let hasClientIndicator = false;
+    const markIfHookOrContext = (callee) => {
+      if (callee.type === AST_NODE_TYPES3.Identifier) {
+        if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
+          hasClientIndicator = true;
+        }
+        return;
+      }
+      if (callee.type === AST_NODE_TYPES3.MemberExpression && callee.property.type === AST_NODE_TYPES3.Identifier) {
+        const name = callee.property.name;
+        if (HOOK_REGEX.test(name) || name === "createContext") {
+          hasClientIndicator = true;
+        }
+      }
+    };
+    return {
+      Program(node) {
+        for (const stmt of node.body) {
+          if (stmt.type !== AST_NODE_TYPES3.ExpressionStatement) break;
+          if (isUseClientDirective(stmt)) {
+            directiveNode = stmt;
+            break;
+          }
+        }
+      },
+      CallExpression(node) {
+        markIfHookOrContext(node.callee);
+      },
+      JSXAttribute(node) {
+        if (node.name.type === AST_NODE_TYPES3.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+          hasClientIndicator = true;
+        }
+      },
+      ImportDeclaration(node) {
+        if (typeof node.source.value === "string" && CLIENT_ONLY_PACKAGES_REGEX.test(node.source.value)) {
+          hasClientIndicator = true;
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (node.source !== null) {
+          hasClientIndicator = true;
+        }
+      },
+      ExportAllDeclaration(node) {
+        if (node.source !== null) {
+          hasClientIndicator = true;
+        }
+      },
+      ClassDeclaration() {
+        hasClientIndicator = true;
+      },
+      ClassExpression() {
+        hasClientIndicator = true;
+      },
+      Identifier(node) {
+        if (isGlobalReference(node, context)) {
+          hasClientIndicator = true;
+        }
+      },
+      "Program:exit"() {
+        if (directiveNode !== null && !hasClientIndicator) {
+          context.report({
+            node: directiveNode,
+            messageId: "unnecessaryUseClient"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-schema-for-api-payload.ts
+import {
+  AST_NODE_TYPES as AST_NODE_TYPES4,
+  ESLintUtils as ESLintUtils6
+} from "@typescript-eslint/utils";
+var unwrap = (node) => {
+  let current = node;
+  while (current !== null && current !== void 0) {
+    if (current.type === AST_NODE_TYPES4.TSAsExpression || current.type === AST_NODE_TYPES4.TSTypeAssertion || current.type === AST_NODE_TYPES4.TSNonNullExpression || current.type === AST_NODE_TYPES4.TSSatisfiesExpression) {
+      current = current.expression;
+    } else if (current.type === AST_NODE_TYPES4.ChainExpression) {
+      current = current.expression;
+    } else {
+      break;
+    }
+  }
+  return current ?? null;
+};
+var isJsonCall = (node) => {
+  let current = unwrap(node);
+  if (current === null) return false;
+  if (current.type === AST_NODE_TYPES4.AwaitExpression) {
+    current = unwrap(current.argument);
+  }
+  if (current === null || current.type !== AST_NODE_TYPES4.CallExpression) {
+    return false;
+  }
+  const callee = unwrap(current.callee);
+  if (callee === null || callee.type !== AST_NODE_TYPES4.MemberExpression) {
+    return false;
+  }
+  const property = unwrap(callee.property);
+  return property !== null && property.type === AST_NODE_TYPES4.Identifier && property.name === "json";
+};
+var findVariable = (scope, name) => {
+  let current = scope;
+  while (current !== null) {
+    const variable = current.set.get(name);
+    if (variable !== void 0) return variable;
+    current = current.upper;
+  }
+  return null;
+};
+var isUnvalidatedVariableRef = (node, scope, tracked) => {
+  const unwrapped = unwrap(node);
+  if (unwrapped === null || unwrapped.type !== AST_NODE_TYPES4.Identifier) {
+    return false;
+  }
+  const variable = findVariable(scope, unwrapped.name);
+  return variable !== null && tracked.has(variable);
+};
+var prefer_schema_for_api_payload_default = ESLintUtils6.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "prefer-schema-for-api-payload",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Zod (or similar) schema validation on `response.json()` before property access."
+    },
+    schema: [],
+    messages: {
+      unparsedJsonAccess: "Property access on the result of `response.json()` without a schema parse. Pipe through `XSchema.parse(...)` (Zod) before reading fields."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const unvalidatedVariables = /* @__PURE__ */ new Set();
+    const trackInitializer = (declarator) => {
+      if (!isJsonCall(declarator.init)) return;
+      const declaredVars = context.sourceCode.getDeclaredVariables(declarator);
+      const variable = declaredVars[0];
+      if (variable !== void 0) {
+        unvalidatedVariables.add(variable);
+      }
+    };
+    return {
+      VariableDeclarator(node) {
+        const scope = context.sourceCode.getScope(node);
+        if (node.id.type === AST_NODE_TYPES4.Identifier) {
+          trackInitializer(node);
+          return;
+        }
+        if (node.id.type === AST_NODE_TYPES4.ObjectPattern || node.id.type === AST_NODE_TYPES4.ArrayPattern) {
+          if (isJsonCall(node.init)) {
+            context.report({ node: node.id, messageId: "unparsedJsonAccess" });
+            return;
+          }
+          if (isUnvalidatedVariableRef(node.init, scope, unvalidatedVariables)) {
+            context.report({ node: node.id, messageId: "unparsedJsonAccess" });
+          }
+        }
+      },
+      AssignmentExpression(node) {
+        const scope = context.sourceCode.getScope(node);
+        if (node.left.type === AST_NODE_TYPES4.Identifier) {
+          const variable = findVariable(scope, node.left.name);
+          if (variable === null) return;
+          if (isJsonCall(node.right)) {
+            unvalidatedVariables.add(variable);
+          } else {
+            unvalidatedVariables.delete(variable);
+          }
+          return;
+        }
+        if (node.left.type === AST_NODE_TYPES4.ObjectPattern || node.left.type === AST_NODE_TYPES4.ArrayPattern) {
+          if (isJsonCall(node.right)) {
+            context.report({
+              node: node.left,
+              messageId: "unparsedJsonAccess"
+            });
+            return;
+          }
+          if (isUnvalidatedVariableRef(node.right, scope, unvalidatedVariables)) {
+            context.report({
+              node: node.left,
+              messageId: "unparsedJsonAccess"
+            });
+          }
+        }
+      },
+      MemberExpression(node) {
+        const scope = context.sourceCode.getScope(node);
+        const obj = unwrap(node.object);
+        if (isJsonCall(obj)) {
+          const parent = node.parent;
+          if (parent.type === AST_NODE_TYPES4.CallExpression && parent.callee === node && node.property.type === AST_NODE_TYPES4.Identifier && (node.property.name === "parse" || node.property.name === "safeParse")) {
+            return;
+          }
+          context.report({ node, messageId: "unparsedJsonAccess" });
+          return;
+        }
+        if (obj !== null && obj.type === AST_NODE_TYPES4.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+          context.report({ node, messageId: "unparsedJsonAccess" });
+          const variable = findVariable(scope, obj.name);
+          if (variable !== null) {
+            unvalidatedVariables.delete(variable);
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-server-actions.ts
+import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
+var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
+var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
+function getScope(context, node) {
+  return context.sourceCode.getScope(node);
+}
+function resolveNode(node, context) {
+  if (!node) return null;
+  if (node.type !== "Identifier") return node;
+  let scope = getScope(context, node);
+  while (scope) {
+    const variable = scope.set.get(node.name);
+    if (variable && variable.defs.length === 1) {
+      const def = variable.defs[0];
+      if (def && def.type === "Variable") {
+        const declarator = def.node;
+        if (declarator.type === "VariableDeclarator" && declarator.init) {
+          return declarator.init;
+        }
+      }
+    }
+    scope = scope.upper;
+  }
+  return node;
+}
+function isApiUrl(node, context) {
+  const resolved = resolveNode(node, context);
+  if (!resolved) return false;
+  if (resolved.type === "Literal" && typeof resolved.value === "string") {
+    return resolved.value.startsWith("/api/");
+  }
+  if (resolved.type === "TemplateLiteral") {
+    const firstQuasi = resolved.quasis[0];
+    const cooked = firstQuasi?.value.cooked;
+    return typeof cooked === "string" && cooked.startsWith("/api/");
+  }
+  if (resolved.type === "BinaryExpression" && resolved.operator === "+") {
+    return isApiUrl(resolved.left, context);
+  }
+  return false;
+}
+function isMutationMethod(node, context) {
+  const resolved = resolveNode(node, context);
+  if (!resolved) return false;
+  if (resolved.type === "Literal" && typeof resolved.value === "string") {
+    return MUTATION_METHODS.has(resolved.value.toUpperCase());
+  }
+  if (resolved.type === "TemplateLiteral" && resolved.expressions.length === 0) {
+    const val = resolved.quasis.map((q) => q.value.cooked).join("");
+    return MUTATION_METHODS.has(val.toUpperCase());
+  }
+  if (resolved.type === "ConditionalExpression") {
+    return isMutationMethod(resolved.consequent, context) || isMutationMethod(resolved.alternate, context);
+  }
+  if (resolved.type === "LogicalExpression" && resolved.operator === "||") {
+    return isMutationMethod(resolved.left, context) || isMutationMethod(resolved.right, context);
+  }
+  return false;
+}
+function getPropertyNode(objNode, propName) {
+  if (!objNode || objNode.type !== "ObjectExpression") return null;
+  for (const prop of objNode.properties) {
+    if (prop.type !== "Property") continue;
+    let keyName = null;
+    if (prop.key.type === "Identifier" && !prop.computed) {
+      keyName = prop.key.name;
+    } else if (prop.key.type === "Literal" && typeof prop.key.value === "string") {
+      keyName = prop.key.value;
+    }
+    if (keyName === propName) {
+      if (prop.value.type === "AssignmentPattern" || prop.value.type === "ArrayPattern" || prop.value.type === "ObjectPattern") {
+        return null;
+      }
+      return prop.value;
+    }
+  }
+  return null;
+}
+var prefer_server_actions_default = ESLintUtils7.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "prefer-server-actions",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer Next.js Server Actions over /api/* mutations."
+    },
+    schema: [],
+    messages: {
+      preferServerAction: "Mutation against /api/* \u2014 prefer a Next.js Server Action for type-safety and to avoid the JSON round-trip."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename;
+    if (SKIP_FILE_REGEX.test(filename)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        let isMutation = false;
+        if (node.callee.type === "Identifier" && node.callee.name === "fetch") {
+          const urlArg = node.arguments[0];
+          if (urlArg && urlArg.type !== "SpreadElement" && isApiUrl(urlArg, context)) {
+            const initArg = node.arguments[1];
+            if (initArg && initArg.type !== "SpreadElement") {
+              const resolvedInit = resolveNode(initArg, context);
+              const methodNode = getPropertyNode(resolvedInit, "method");
+              if (methodNode && isMutationMethod(methodNode, context)) {
+                isMutation = true;
+              }
+            }
+          }
+        } else if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && !node.callee.computed) {
+          const methodName = node.callee.property.name.toLowerCase();
+          if (AXIOS_MUTATION_METHODS.has(methodName)) {
+            const urlArg = node.arguments[0];
+            if (urlArg && urlArg.type !== "SpreadElement" && isApiUrl(urlArg, context)) {
+              isMutation = true;
+            }
+          }
+        } else if (node.callee.type === "Identifier" && (node.callee.name === "axios" || node.callee.name === "request")) {
+          const firstArg = node.arguments[0];
+          if (firstArg && firstArg.type !== "SpreadElement") {
+            const configArg = resolveNode(firstArg, context);
+            if (configArg && configArg.type === "ObjectExpression") {
+              const urlNode = getPropertyNode(configArg, "url");
+              const methodNode = getPropertyNode(configArg, "method");
+              if (urlNode && isApiUrl(urlNode, context) && methodNode && isMutationMethod(methodNode, context)) {
+                isMutation = true;
+              }
+            }
+          }
+        }
+        if (isMutation) {
+          context.report({ node, messageId: "preferServerAction" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/prefer-shadcn.ts
+import { ESLintUtils as ESLintUtils8 } from "@typescript-eslint/utils";
+var REPLACEMENTS = {
+  input: "Input",
+  select: "Select",
+  textarea: "Textarea",
+  dialog: "Dialog"
+};
+var prefer_shadcn_default = ESLintUtils8.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "prefer-shadcn",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer shadcn/ui form primitives over native `<input>`, `<select>`, `<textarea>`, and `<dialog>` elements."
+    },
+    schema: [],
+    messages: {
+      preferShadcn: "Use the shadcn <{{replacement}}> component from @/components/ui/{{lowercase}} instead of native <{{element}}>."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.type !== "JSXIdentifier") {
+          return;
+        }
+        const elementName = node.name.name;
+        const replacement = REPLACEMENTS[elementName];
+        if (replacement === void 0) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: "preferShadcn",
+          data: {
+            element: elementName,
+            replacement,
+            lowercase: elementName
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/rules/require-assert-never.ts
+import { ESLintUtils as ESLintUtils9, AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+var isAssertNeverCall = (expression) => {
+  if (expression.type !== AST_NODE_TYPES5.CallExpression) return false;
+  const callee = expression.callee;
+  return callee.type === AST_NODE_TYPES5.Identifier && callee.name === "assertNever";
+};
+var statementContainsAssertNever = (statement) => {
+  if (statement.type === AST_NODE_TYPES5.ExpressionStatement) {
+    return isAssertNeverCall(statement.expression);
+  }
+  if (statement.type === AST_NODE_TYPES5.ThrowStatement) {
+    return isAssertNeverCall(statement.argument);
+  }
+  if (statement.type === AST_NODE_TYPES5.BlockStatement) {
+    return statement.body.some(statementContainsAssertNever);
+  }
+  return false;
+};
+var require_assert_never_default = ESLintUtils9.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "require-assert-never",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require switch statements to end with `assertNever(_)` in their default case so that discriminated unions are exhaustively checked at compile time."
+    },
+    schema: [],
+    messages: {
+      missingAssertNever: "Switch statement default case must call assertNever() for exhaustive type checking"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      SwitchStatement(node) {
+        const defaultCase = node.cases.find(
+          (caseNode) => caseNode.test === null
+        );
+        if (!defaultCase) return;
+        const hasAssertNever = defaultCase.consequent.some(
+          statementContainsAssertNever
+        );
+        if (hasAssertNever) return;
+        context.report({
+          node: defaultCase,
+          messageId: "missingAssertNever"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/require-zod-form-validation.ts
+import { ESLintUtils as ESLintUtils10, AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var isFormDataGetCall = (node) => {
+  const callee = node.callee;
+  if (callee.type !== AST_NODE_TYPES6.MemberExpression) return false;
+  if (callee.property.type !== AST_NODE_TYPES6.Identifier || callee.property.name !== "get") {
+    return false;
+  }
+  return callee.object.type === AST_NODE_TYPES6.Identifier && callee.object.name === "formData";
+};
+var isParseCallExpression = (node) => {
+  if (node.type !== AST_NODE_TYPES6.CallExpression) return false;
+  const callee = node.callee;
+  if (callee.type !== AST_NODE_TYPES6.MemberExpression) return false;
+  return callee.property.type === AST_NODE_TYPES6.Identifier && callee.property.name === "parse";
+};
+var require_zod_form_validation_default = ESLintUtils10.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "require-zod-form-validation",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Zod validation (`Schema.parse(...)`) when reading values out of a `FormData` object."
+    },
+    schema: [],
+    messages: {
+      missingZodValidation: "FormData parsing must use Zod schema validation (e.g., Schema.parse())"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isFormDataGetCall(node)) return;
+        let parent = node.parent;
+        while (parent !== null && parent !== void 0) {
+          if (isParseCallExpression(parent)) return;
+          parent = parent.parent;
+        }
+        context.report({
+          node,
+          messageId: "missingZodValidation"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/zod-naming-convention.ts
+import { ESLintUtils as ESLintUtils11, AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var calleeChainStartsWithZ = (node) => {
+  let current = node;
+  while (current.type === AST_NODE_TYPES7.MemberExpression) {
+    const receiver = current.object;
+    if (receiver.type === AST_NODE_TYPES7.Identifier && receiver.name === "z") {
+      return true;
+    }
+    if (receiver.type === AST_NODE_TYPES7.CallExpression) {
+      current = receiver.callee;
+      continue;
+    }
+    return false;
+  }
+  return false;
+};
+var zod_naming_convention_default = ESLintUtils11.RuleCreator(
+  (name) => `https://github.com/sarj-ai/linting/blob/main/packages/typescript/src/rules/${name}.ts`
+)({
+  name: "zod-naming-convention",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce Zod schemas to be named with a Z prefix (e.g. `ZUser = z.object({...})`)."
+    },
+    schema: [],
+    messages: {
+      zPrefix: "Zod schema names should start with Z"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      VariableDeclarator(node) {
+        const init = node.init;
+        if (init === null || init === void 0) return;
+        if (init.type !== AST_NODE_TYPES7.CallExpression) return;
+        const callee = init.callee;
+        if (callee.type !== AST_NODE_TYPES7.MemberExpression) return;
+        if (!calleeChainStartsWithZ(callee)) return;
+        if (node.id.type !== AST_NODE_TYPES7.Identifier) return;
+        const variableName = node.id.name;
+        if (variableName.startsWith("Z")) return;
+        context.report({
+          node: node.id,
+          messageId: "zPrefix"
+        });
+      }
+    };
+  }
+});
+
+// src/index.ts
+var rules = {
+  "enforce-file-structure": enforce_file_structure_default,
+  "no-client-side-data-fetching": no_client_side_data_fetching_default,
+  "no-enum": no_enum_default,
+  "no-raw-env": no_raw_env_default,
+  "no-unnecessary-use-client": no_unnecessary_use_client_default,
+  "prefer-schema-for-api-payload": prefer_schema_for_api_payload_default,
+  "prefer-server-actions": prefer_server_actions_default,
+  "prefer-shadcn": prefer_shadcn_default,
+  "require-assert-never": require_assert_never_default,
+  "require-zod-form-validation": require_zod_form_validation_default,
+  "zod-naming-convention": zod_naming_convention_default
+};
+var plugin = {
+  meta: {
+    name: "@sarj/eslint-plugin",
+    version: "2.0.0"
+  },
+  rules,
+  configs: {
+    recommended: {
+      plugins: ["@sarj"],
+      rules: {
+        "@sarj/zod-naming-convention": "warn",
+        "@sarj/require-assert-never": "error",
+        "@sarj/require-zod-form-validation": "error",
+        "@sarj/enforce-file-structure": "warn",
+        "@sarj/no-client-side-data-fetching": "warn",
+        "@sarj/prefer-server-actions": "warn",
+        "@sarj/no-unnecessary-use-client": "warn",
+        "@sarj/prefer-schema-for-api-payload": "warn"
+      }
+    },
+    strict: {
+      plugins: ["@sarj"],
+      rules: {
+        "@sarj/zod-naming-convention": "error",
+        "@sarj/require-assert-never": "error",
+        "@sarj/require-zod-form-validation": "error",
+        "@sarj/enforce-file-structure": "error",
+        "@sarj/no-raw-env": "error",
+        "@sarj/prefer-shadcn": "error",
+        "@sarj/no-enum": "error",
+        "@sarj/no-client-side-data-fetching": "error",
+        "@sarj/prefer-server-actions": "error",
+        "@sarj/no-unnecessary-use-client": "error",
+        "@sarj/prefer-schema-for-api-payload": "error"
+      }
+    }
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default,
+  rules
 };
-export { plugin as default, configs, rules };
+//# sourceMappingURL=index.js.map