@skapxd/eslint-opinionated 0.1.0

package/dist/index.js

@@ -0,0 +1,1781 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  configs: () => configs,
+  default: () => index_default,
+  rules: () => rules
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/shared/configs/base-rules.ts
+var baseRules = {
+  "skapxd/no-ad-hoc-ok-result": "warn",
+  "skapxd/no-deep-relative-imports": "warn",
+  "skapxd/no-promise-chain": "error",
+  "skapxd/no-try-catch": "error",
+  "skapxd/one-root-function-per-file": "error",
+  "skapxd/prefer-ts-pattern": "error",
+  "skapxd/result-error-requires-cause": "error"
+};
+
+// src/shared/configs/create-typed-language-options.ts
+function createTypedLanguageOptions() {
+  return {
+    parserOptions: {
+      projectService: true
+    }
+  };
+}
+
+// src/shared/configs/create-shared-configs.ts
+function createSharedConfigs(pluginReference) {
+  const typedLanguageOptions = createTypedLanguageOptions();
+  return {
+    backend: {
+      languageOptions: typedLanguageOptions,
+      name: "skapxd/shared/backend",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        ...baseRules,
+        "skapxd/async-functions-return-result": [
+          "error",
+          {
+            checkMissingReturnType: true,
+            resultTypeNames: ["Result", "ResultValue", "SafeResult"]
+          }
+        ]
+      }
+    },
+    base: {
+      name: "skapxd/shared/base",
+      plugins: { skapxd: pluginReference },
+      rules: baseRules
+    },
+    frontend: {
+      languageOptions: typedLanguageOptions,
+      name: "skapxd/shared/frontend",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        ...baseRules,
+        "skapxd/jsx-return-name-pascal-case": "error",
+        "skapxd/no-functions-inside-components": "error",
+        "skapxd/no-jsx-ternary-null": "error",
+        "skapxd/max-hook-size": [
+          "warn",
+          {
+            maxLines: 120,
+            maxUseState: 1
+          }
+        ]
+      }
+    },
+    // Capa de servicios del front (peticiones, clientes de API): todo await
+    // debe ir envuelto en trySafe de @skapxd/result. El consumidor puede
+    // sobreescribir `files` si sus servicios viven en otra carpeta.
+    frontendServices: {
+      files: ["**/services/**/*.{ts,tsx}", "**/api/**/*.{ts,tsx}"],
+      languageOptions: typedLanguageOptions,
+      name: "skapxd/shared/frontend-services",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        "skapxd/await-requires-try-safe": "error"
+      }
+    },
+    package: {
+      name: "skapxd/shared/package",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        "skapxd/one-root-function-per-file": "error"
+      }
+    }
+  };
+}
+
+// src/shared/configs/strict-config.ts
+var strictConfig = {
+  linterOptions: {
+    noInlineConfig: true
+  },
+  name: "skapxd/strict"
+};
+
+// src/astro/configs.ts
+function createAstroConfigs(pluginReference) {
+  const typedLanguageOptions = createTypedLanguageOptions();
+  return [
+    {
+      files: ["src/**/*.{ts,tsx,astro}"],
+      name: "skapxd/astro/base",
+      plugins: { skapxd: pluginReference },
+      rules: baseRules
+    },
+    {
+      files: ["src/**/*.{ts,tsx}"],
+      languageOptions: typedLanguageOptions,
+      name: "skapxd/astro/typescript",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        "skapxd/result-error-requires-cause": "error"
+      }
+    }
+  ];
+}
+
+// src/next/configs.ts
+function createNextConfigs(pluginReference) {
+  const typedLanguageOptions = createTypedLanguageOptions();
+  return [
+    {
+      name: "skapxd/next/base",
+      plugins: { skapxd: pluginReference },
+      rules: baseRules
+    },
+    {
+      files: ["src/app/api/**/*.{ts,tsx}", "src/server/**/*.{ts,tsx}"],
+      languageOptions: typedLanguageOptions,
+      name: "skapxd/next/server",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        ...baseRules,
+        "skapxd/async-functions-return-result": [
+          "error",
+          {
+            allowFilePatterns: [
+              "/(route|page|layout|template|loading|error|not-found)\\.tsx?$"
+            ],
+            allowNamePatterns: [
+              "^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)$",
+              "^handle(Get|Post|Put|Patch|Delete|Head|Options)$",
+              "^start$"
+            ],
+            checkMissingReturnType: true,
+            resultTypeNames: ["Result", "ResultValue", "SafeResult"]
+          }
+        ]
+      }
+    },
+    {
+      files: ["**/*.tsx"],
+      name: "skapxd/next/react",
+      plugins: { skapxd: pluginReference },
+      rules: {
+        "skapxd/jsx-return-name-pascal-case": "error",
+        "skapxd/no-functions-inside-components": "error",
+        "skapxd/no-jsx-ternary-null": "error",
+        "skapxd/max-hook-size": [
+          "warn",
+          {
+            maxLines: 120,
+            maxUseState: 1
+          }
+        ]
+      }
+    }
+  ];
+}
+
+// src/utils/get-file-name.ts
+function getFileName(filename) {
+  return filename.split(/[\\/]/).at(-1) ?? filename;
+}
+
+// src/utils/get-source-extension.ts
+function getSourceExtension(fileName) {
+  return fileName.endsWith(".tsx") ? ".tsx" : ".ts";
+}
+
+// src/utils/get-directory-name.ts
+function getDirectoryName(filename) {
+  return filename.split(/[\\/]/).slice(0, -1).join("/");
+}
+
+// src/utils/is-http-route-method.ts
+function isHttpRouteMethod(functionName) {
+  return ["DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"].includes(
+    functionName
+  );
+}
+
+// src/utils/to-kebab-case.ts
+function toKebabCase(value) {
+  return value.replace(/OEmbed/g, "Oembed").replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-|-$/g, "").toLocaleLowerCase();
+}
+
+// src/utils/get-suggested-helper-file-name.ts
+function getSuggestedHelperFileName({ extension, fileStem, functionName }) {
+  const helperFunctionName = fileStem === "route" && isHttpRouteMethod(functionName) ? `handle${functionName}` : functionName;
+  return `${toKebabCase(helperFunctionName)}${extension}`;
+}
+
+// src/utils/get-path-parts.ts
+function getPathParts(filename) {
+  return filename.split(/[\\/]/).filter(Boolean);
+}
+
+// src/utils/is-in-source-root.ts
+function isInSourceRoot(filename) {
+  const pathParts = getPathParts(filename);
+  return pathParts.at(-2) === "src";
+}
+
+// src/utils/is-inside-app-directory.ts
+function isInsideAppDirectory(filename) {
+  return getPathParts(filename).includes("app");
+}
+
+// src/constants/next-app-metadata-file-stems.ts
+var nextAppMetadataFileStems = [
+  "apple-icon",
+  "icon",
+  "manifest",
+  "opengraph-image",
+  "robots",
+  "sitemap",
+  "twitter-image"
+];
+
+// src/constants/next-app-route-segment-file-stems.ts
+var nextAppRouteSegmentFileStems = [
+  "default",
+  "error",
+  "forbidden",
+  "global-error",
+  "global-not-found",
+  "layout",
+  "loading",
+  "not-found",
+  "page",
+  "route",
+  "template",
+  "unauthorized"
+];
+
+// src/constants/next-project-root-file-stems.ts
+var nextProjectRootFileStems = [
+  "instrumentation",
+  "instrumentation-client",
+  "mdx-components",
+  "proxy"
+];
+
+// src/utils/is-next-convention-file.ts
+function isNextConventionFile({ fileStem, filename }) {
+  if ([
+    ...nextAppRouteSegmentFileStems,
+    ...nextAppMetadataFileStems
+  ].includes(fileStem)) {
+    return isInsideAppDirectory(filename);
+  }
+  if (nextProjectRootFileStems.includes(fileStem)) {
+    return isInSourceRoot(filename);
+  }
+  return false;
+}
+
+// src/utils/get-suggested-helper-path.ts
+function getSuggestedHelperPath({ extension, fileStem, filename, functionName }) {
+  const helperFileName = getSuggestedHelperFileName({
+    extension,
+    fileStem,
+    functionName
+  });
+  if (isNextConventionFile({ fileStem, filename })) {
+    return `${getDirectoryName(filename)}/${helperFileName}`;
+  }
+  return `${getDirectoryName(filename)}/${toKebabCase(fileStem)}/${helperFileName}`;
+}
+
+// src/utils/get-move-suggestion.ts
+function getMoveSuggestion({ filename, functionName }) {
+  const fileName = getFileName(filename);
+  const extension = getSourceExtension(fileName);
+  const fileStem = fileName.slice(0, -extension.length);
+  const suggestedPath = getSuggestedHelperPath({
+    extension,
+    fileStem,
+    filename,
+    functionName
+  });
+  if (fileStem === "route" && isHttpRouteMethod(functionName)) {
+    return `Mueve la implementacion de \`${functionName}\` a \`${suggestedPath}\` si solo se usa aqui y deja \`${functionName}\` en route.ts delegando a ese helper. No conviertas route.ts en route/index.ts porque Next no lo reconoce.`;
+  }
+  if (isNextConventionFile({ fileStem, filename })) {
+    return `Mueve \`${functionName}\` a \`${suggestedPath}\` si solo se usa aqui y deja \`${fileName}\` como entrypoint de Next. No conviertas \`${fileName}\` en \`${fileStem}/index${extension}\` porque Next exige el nombre exacto del archivo.`;
+  }
+  return `Mueve \`${functionName}\` a \`${suggestedPath}\` si solo se usa aqui.`;
+}
+
+// src/utils/get-function-node-name.ts
+function getFunctionNodeName(node) {
+  return node.id?.name ?? "helper";
+}
+
+// src/utils/get-variable-declarator-name.ts
+function getVariableDeclaratorName(variableDeclarator) {
+  return variableDeclarator.id.type === "Identifier" ? variableDeclarator.id.name : getFunctionNodeName(variableDeclarator.init);
+}
+
+// src/utils/is-function-node.ts
+function isFunctionNode(node) {
+  return node?.type === "FunctionDeclaration" || node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression";
+}
+
+// src/utils/get-root-function-entries.ts
+function getRootFunctionEntries(statement) {
+  const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+  if (!declaration) {
+    return [];
+  }
+  if (isFunctionNode(declaration)) {
+    return [
+      {
+        name: getFunctionNodeName(declaration),
+        node: declaration
+      }
+    ];
+  }
+  if (declaration.type !== "VariableDeclaration") {
+    return [];
+  }
+  return declaration.declarations.filter((variableDeclarator) => isFunctionNode(variableDeclarator.init)).map((variableDeclarator) => ({
+    name: getVariableDeclaratorName(variableDeclarator),
+    node: variableDeclarator.init
+  }));
+}
+
+// src/utils/get-suggested-helper-file-names.ts
+function getSuggestedHelperFileNames({ extension, fileStem, functionNames }) {
+  return [
+    ...new Set(
+      functionNames.map(
+        (functionName) => getSuggestedHelperFileName({
+          extension,
+          fileStem,
+          functionName
+        })
+      )
+    )
+  ];
+}
+
+// src/utils/get-tree-child-lines.ts
+function getTreeChildLines({ indent = "", names }) {
+  return names.map((name, index) => {
+    const branch = index === names.length - 1 ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    return `${indent}${branch} ${name}`;
+  });
+}
+
+// src/utils/get-structure-suggestion.ts
+function getStructureSuggestion({ filename, functionNames }) {
+  const fileName = getFileName(filename);
+  const extension = getSourceExtension(fileName);
+  const fileStem = fileName.slice(0, -extension.length);
+  const directoryName = getDirectoryName(filename);
+  const helperFileNames = getSuggestedHelperFileNames({
+    extension,
+    fileStem,
+    functionNames
+  });
+  if (isNextConventionFile({ fileStem, filename })) {
+    return [
+      `${directoryName}/`,
+      ...getTreeChildLines({
+        names: [fileName, ...helperFileNames]
+      })
+    ].join("\n");
+  }
+  return [
+    `${directoryName}/${toKebabCase(fileStem)}/`,
+    ...getTreeChildLines({
+      names: [`index${extension}`, ...helperFileNames]
+    })
+  ].join("\n");
+}
+
+// src/rules/one-root-function-per-file.ts
+var oneRootFunctionPerFile = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limita cada archivo a una sola funcion declarada en la raiz."
+    },
+    messages: {
+      tooManyRootFunctions: "Este archivo tiene {{count}} funciones en la raiz. Deja solo una funcion top-level por archivo. {{moveSuggestion}}\n\nEstructura sugerida:\n{{structureSuggestion}}\n\nSi se reutiliza, muevela a un modulo compartido con nombre de dominio."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Program(node) {
+        const rootFunctions = node.body.flatMap(
+          (statement) => getRootFunctionEntries(statement)
+        );
+        if (rootFunctions.length <= 1) {
+          return;
+        }
+        const firstHelper = rootFunctions[1];
+        const helperFunctionNames = rootFunctions.slice(1).map((rootFunction) => rootFunction.name);
+        context.report({
+          data: {
+            count: String(rootFunctions.length),
+            moveSuggestion: getMoveSuggestion({
+              filename: context.filename ?? context.getFilename(),
+              functionName: firstHelper.name
+            }),
+            structureSuggestion: getStructureSuggestion({
+              filename: context.filename ?? context.getFilename(),
+              functionNames: helperFunctionNames
+            })
+          },
+          messageId: "tooManyRootFunctions",
+          node: firstHelper.node
+        });
+      }
+    };
+  }
+};
+
+// src/utils/is-ast-node.ts
+function isAstNode(value) {
+  return Boolean(value && typeof value === "object" && "type" in value);
+}
+
+// src/utils/get-node-children.ts
+function getNodeChildren(node) {
+  return Object.entries(node).flatMap(([key, value]) => {
+    if (["parent", "loc", "range", "tokens", "comments"].includes(key)) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value.filter(isAstNode);
+    }
+    return isAstNode(value) ? [value] : [];
+  });
+}
+
+// src/utils/contains-jsx.ts
+function containsJsx(node) {
+  if (!isAstNode(node)) {
+    return false;
+  }
+  if (node.type === "JSXElement" || node.type === "JSXFragment") {
+    return true;
+  }
+  return getNodeChildren(node).some((child) => containsJsx(child));
+}
+
+// src/utils/contains-own-jsx.ts
+function containsOwnJsx(node) {
+  if (!isAstNode(node)) {
+    return false;
+  }
+  if (node.type === "JSXElement" || node.type === "JSXFragment") {
+    return true;
+  }
+  if (isFunctionNode(node)) {
+    return false;
+  }
+  return getNodeChildren(node).some((child) => containsOwnJsx(child));
+}
+
+// src/utils/function-returns-jsx.ts
+function functionReturnsJsx(functionNode) {
+  if (functionNode.body?.type !== "BlockStatement") {
+    return containsJsx(functionNode.body);
+  }
+  return containsOwnJsx(functionNode.body);
+}
+
+// src/utils/is-pascal-case-name.ts
+function isPascalCaseName(value) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(value);
+}
+
+// src/utils/to-pascal-case.ts
+function toPascalCase(value) {
+  return value.replace(/^[a-z]/, (letter) => letter.toLocaleUpperCase());
+}
+
+// src/rules/jsx-return-name-pascal-case.ts
+var jsxReturnNamePascalCase = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exige nombres PascalCase para funciones que devuelven JSX."
+    },
+    messages: {
+      invalidName: "La funcion `{{name}}` devuelve JSX. Nombrala como componente, por ejemplo `{{suggestedName}}`, y usala con sintaxis JSX si aplica."
+    },
+    schema: []
+  },
+  create(context) {
+    function reportIfJsxReturningFunction(node, name, reportNode = node) {
+      if (!name || isPascalCaseName(name) || !functionReturnsJsx(node)) {
+        return;
+      }
+      context.report({
+        data: {
+          name,
+          suggestedName: toPascalCase(name)
+        },
+        messageId: "invalidName",
+        node: reportNode
+      });
+    }
+    return {
+      FunctionDeclaration(node) {
+        reportIfJsxReturningFunction(node, node.id?.name, node.id ?? node);
+      },
+      VariableDeclarator(node) {
+        if (!isFunctionNode(node.init) || node.id.type !== "Identifier") {
+          return;
+        }
+        reportIfJsxReturningFunction(node.init, node.id.name, node.id);
+      }
+    };
+  }
+};
+
+// src/utils/is-member-property-named.ts
+function isMemberPropertyNamed(node, propertyName) {
+  if (node.computed) {
+    return node.property.type === "Literal" && node.property.value === propertyName;
+  }
+  return node.property.type === "Identifier" && node.property.name === propertyName;
+}
+
+// src/utils/is-callee-named.ts
+function isCalleeNamed(node, names) {
+  if (node?.type === "Identifier") {
+    return names.includes(node.name);
+  }
+  if (node?.type === "MemberExpression") {
+    return names.some((name) => isMemberPropertyNamed(node, name));
+  }
+  return false;
+}
+
+// src/utils/contains-call-named.ts
+function containsCallNamed(node, names) {
+  if (!isAstNode(node)) {
+    return false;
+  }
+  if (node.type === "CallExpression" && isCalleeNamed(node.callee, names)) {
+    return true;
+  }
+  return getNodeChildren(node).some((child) => containsCallNamed(child, names));
+}
+
+// src/utils/get-async-result-rule-options.ts
+function getAsyncResultRuleOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    allowNamePatterns: options.allowNamePatterns ?? [],
+    checkMissingReturnType: options.checkMissingReturnType ?? true,
+    checkMissingReturnTypeWhenCallNames: options.checkMissingReturnTypeWhenCallNames ?? [],
+    promiseTypeNames: options.promiseTypeNames ?? ["Promise"],
+    requireCallNames: options.requireCallNames ?? [],
+    resultTypeNames: options.resultTypeNames ?? ["Result"]
+  };
+}
+
+// src/utils/get-property-name.ts
+function getPropertyName(node) {
+  if (!node) {
+    return "anonymous";
+  }
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type === "Literal") {
+    return String(node.value);
+  }
+  return "anonymous";
+}
+
+// src/utils/get-parent-function-name.ts
+function getParentFunctionName(node) {
+  const parent = node.parent;
+  if (parent?.type === "VariableDeclarator") {
+    return getVariableDeclaratorName(parent);
+  }
+  if (parent?.type === "Property" || parent?.type === "MethodDefinition" || parent?.type === "PropertyDefinition") {
+    return getPropertyName(parent.key);
+  }
+  return getFunctionNodeName(node);
+}
+
+// src/utils/get-function-expression-name.ts
+function getFunctionExpressionName(node) {
+  return node.id?.name ?? getParentFunctionName(node);
+}
+
+// src/utils/get-parent-function-report-node.ts
+function getParentFunctionReportNode(node) {
+  const parent = node.parent;
+  if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id;
+  }
+  if (parent?.type === "Property" || parent?.type === "MethodDefinition" || parent?.type === "PropertyDefinition") {
+    return parent.key;
+  }
+  return node.id ?? node;
+}
+
+// src/utils/get-type-context.ts
+function getTypeContext(context) {
+  const sourceCode = context.sourceCode ?? context.getSourceCode();
+  const parserServices = sourceCode.parserServices;
+  if (!parserServices?.program) {
+    return null;
+  }
+  return {
+    checker: parserServices.program.getTypeChecker(),
+    services: parserServices
+  };
+}
+
+// src/utils/is-anonymous-generated-function-name.ts
+function isAnonymousGeneratedFunctionName(name) {
+  return name === "anonymous" || name === "helper";
+}
+
+// src/utils/get-type-reference-parameters.ts
+function getTypeReferenceParameters(node) {
+  return node.typeArguments?.params ?? node.typeParameters?.params ?? [];
+}
+
+// src/utils/is-type-reference-named.ts
+function isTypeReferenceNamed(node, names) {
+  const typeName = node.typeName;
+  return typeName.type === "Identifier" && names.includes(typeName.name);
+}
+
+// src/utils/is-promise-of-result-type.ts
+function isPromiseOfResultType(node, options) {
+  if (node.type !== "TSTypeReference") {
+    return false;
+  }
+  if (!isTypeReferenceNamed(node, options.promiseTypeNames)) {
+    return false;
+  }
+  const promiseValueType = getTypeReferenceParameters(node)[0];
+  return Boolean(
+    promiseValueType && promiseValueType.type === "TSTypeReference" && isTypeReferenceNamed(promiseValueType, options.resultTypeNames)
+  );
+}
+
+// src/utils/get-package-name.ts
+var import_result = require("@skapxd/result");
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var packageNameByDir = /* @__PURE__ */ new Map();
+function getPackageName(fileName) {
+  const visited = [];
+  let dir = import_node_path.default.dirname(fileName);
+  while (true) {
+    if (packageNameByDir.has(dir)) {
+      const cached = packageNameByDir.get(dir);
+      for (const visitedDir of visited) packageNameByDir.set(visitedDir, cached);
+      return cached;
+    }
+    visited.push(dir);
+    const packageJsonPath = import_node_path.default.join(dir, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath)) {
+      const parsed = (0, import_result.trySafe)(
+        () => JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf8"))
+      );
+      const name = parsed.ok ? parsed.value.name ?? null : null;
+      for (const visitedDir of visited) packageNameByDir.set(visitedDir, name);
+      return name;
+    }
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) {
+      for (const visitedDir of visited) packageNameByDir.set(visitedDir, null);
+      return null;
+    }
+    dir = parent;
+  }
+}
+
+// src/utils/is-skapxd-result-source-file.ts
+function isSkapxdResultSourceFile(fileName) {
+  return getPackageName(fileName) === "@skapxd/result";
+}
+
+// src/utils/resolve-alias-symbol.ts
+var import_typescript = __toESM(require("typescript"));
+function resolveAliasSymbol(symbol, typeContext) {
+  return symbol.flags & import_typescript.default.SymbolFlags.Alias ? typeContext.checker.getAliasedSymbol(symbol) : symbol;
+}
+
+// src/utils/is-symbol-from-skapxd-result.ts
+function isSymbolFromSkapxdResult(symbol, typeContext) {
+  const resolvedSymbol = resolveAliasSymbol(symbol, typeContext);
+  return (resolvedSymbol.getDeclarations() ?? []).some(
+    (declaration) => isSkapxdResultSourceFile(declaration.getSourceFile().fileName)
+  );
+}
+
+// src/utils/is-skapxd-named-type.ts
+function isSkapxdNamedType(type, names, typeContext) {
+  return [
+    type.aliasSymbol,
+    type.symbol
+  ].some(
+    (symbol) => Boolean(
+      symbol && names.includes(symbol.getName()) && isSymbolFromSkapxdResult(symbol, typeContext)
+    )
+  );
+}
+
+// src/utils/is-skapxd-result-type.ts
+function isSkapxdResultType(type, typeContext) {
+  if (isSkapxdNamedType(type, ["Result", "SafeResult"], typeContext)) {
+    return true;
+  }
+  if (!type.isUnion()) {
+    return false;
+  }
+  const hasOk = type.types.some(
+    (part) => isSkapxdNamedType(part, ["Ok"], typeContext)
+  );
+  const hasErr = type.types.some(
+    (part) => isSkapxdNamedType(part, ["Err"], typeContext)
+  );
+  return hasOk && hasErr;
+}
+
+// src/utils/is-skapxd-result-or-promise-result-type.ts
+function isSkapxdResultOrPromiseResultType(type, typeContext) {
+  if (isSkapxdResultType(type, typeContext)) {
+    return true;
+  }
+  const promisedType = typeContext.checker.getPromisedTypeOfPromise(type);
+  return Boolean(promisedType && isSkapxdResultType(promisedType, typeContext));
+}
+
+// src/utils/matches-any-pattern.ts
+function matchesAnyPattern(value, patterns) {
+  return patterns.some((pattern) => new RegExp(pattern).test(value));
+}
+
+// src/rules/async-functions-return-result.ts
+var asyncFunctionsReturnResult = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exige Promise<Result<...>> en funciones async de dominio."
+    },
+    messages: {
+      missingReturnType: "La funcion async `{{name}}` debe declarar Promise<Result<...>> como tipo de retorno.",
+      invalidReturnType: "La funcion async `{{name}}` debe retornar Promise<Result<...>> para modelar errores de forma explicita."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          allowNamePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          checkMissingReturnType: { type: "boolean" },
+          checkMissingReturnTypeWhenCallNames: {
+            items: { type: "string" },
+            type: "array"
+          },
+          requireCallNames: {
+            items: { type: "string" },
+            type: "array"
+          },
+          promiseTypeNames: {
+            items: { type: "string" },
+            type: "array"
+          },
+          resultTypeNames: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getAsyncResultRuleOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    const typeContext = getTypeContext(context);
+    function isSkapxdResultReturnType(annotation) {
+      if (typeContext) {
+        const type = typeContext.services.getTypeFromTypeNode(annotation);
+        return isSkapxdResultOrPromiseResultType(type, typeContext);
+      }
+      return isPromiseOfResultType(annotation, options);
+    }
+    function reportIfInvalidAsyncReturn(node, name, reportNode = node) {
+      if (!node.async || matchesAnyPattern(filename, options.allowFilePatterns)) {
+        return;
+      }
+      const functionName = name ?? "anonymous";
+      if (isAnonymousGeneratedFunctionName(functionName)) {
+        return;
+      }
+      if (matchesAnyPattern(functionName, options.allowNamePatterns)) {
+        return;
+      }
+      if (options.requireCallNames.length && !containsCallNamed(node.body, options.requireCallNames)) {
+        return;
+      }
+      const returnType = node.returnType?.typeAnnotation;
+      if (!returnType) {
+        if (options.checkMissingReturnType || containsCallNamed(node.body, options.checkMissingReturnTypeWhenCallNames)) {
+          context.report({
+            data: { name: functionName },
+            messageId: "missingReturnType",
+            node: reportNode
+          });
+        }
+        return;
+      }
+      if (isSkapxdResultReturnType(returnType)) {
+        return;
+      }
+      context.report({
+        data: { name: functionName },
+        messageId: "invalidReturnType",
+        node: reportNode
+      });
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        reportIfInvalidAsyncReturn(
+          node,
+          getParentFunctionName(node),
+          getParentFunctionReportNode(node)
+        );
+      },
+      FunctionDeclaration(node) {
+        reportIfInvalidAsyncReturn(node, node.id?.name, node.id ?? node);
+      },
+      FunctionExpression(node) {
+        reportIfInvalidAsyncReturn(
+          node,
+          getFunctionExpressionName(node),
+          getParentFunctionReportNode(node)
+        );
+      }
+    };
+  }
+};
+
+// src/utils/get-containing-function.ts
+function getContainingFunction(node) {
+  let currentNode = node.parent;
+  while (currentNode) {
+    if (isFunctionNode(currentNode)) {
+      return currentNode;
+    }
+    currentNode = currentNode.parent;
+  }
+  return null;
+}
+
+// src/utils/get-function-name.ts
+function getFunctionName(node) {
+  if (node.type === "FunctionDeclaration") {
+    return getFunctionNodeName(node);
+  }
+  return getParentFunctionName(node);
+}
+
+// src/utils/get-returned-object-expression.ts
+function getReturnedObjectExpression(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === "ObjectExpression") {
+    return node;
+  }
+  if (node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression" || node.type === "ChainExpression") {
+    return getReturnedObjectExpression(node.expression);
+  }
+  return null;
+}
+
+// src/utils/unwrap-expression.ts
+function unwrapExpression(node) {
+  if (node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSNonNullExpression") {
+    return unwrapExpression(node.expression);
+  }
+  return node;
+}
+
+// src/utils/get-boolean-literal-value.ts
+function getBooleanLiteralValue(node) {
+  const unwrappedNode = unwrapExpression(node);
+  return unwrappedNode.type === "Literal" && typeof unwrappedNode.value === "boolean" ? unwrappedNode.value : null;
+}
+
+// src/utils/is-property-key-named.ts
+function isPropertyKeyNamed(property, propertyName) {
+  if (property.key.type === "Identifier") {
+    return property.key.name === propertyName;
+  }
+  return property.key.type === "Literal" && property.key.value === propertyName;
+}
+
+// src/utils/has-boolean-ok-property.ts
+function hasBooleanOkProperty(node) {
+  return node.properties.some(
+    (property) => property.type === "Property" && isPropertyKeyNamed(property, "ok") && getBooleanLiteralValue(property.value) !== null
+  );
+}
+
+// src/utils/is-exported-function.ts
+function isExportedFunction(node) {
+  const parent = node.parent;
+  if (node.type === "FunctionDeclaration" && (parent?.type === "ExportNamedDeclaration" || parent?.type === "ExportDefaultDeclaration")) {
+    return true;
+  }
+  if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && parent?.type === "VariableDeclarator" && parent.parent?.parent?.type === "ExportNamedDeclaration") {
+    return true;
+  }
+  return false;
+}
+
+// src/rules/no-ad-hoc-ok-result.ts
+var noAdHocOkResult = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prohibe retornar contratos ad hoc con ok en funciones async exportadas."
+    },
+    messages: {
+      adHocOkResult: "No retornes objetos ad hoc con `ok` desde la funcion async `{{name}}`. Usa Result.ok(...) / Result.err(...) con un error discriminado `{ type: ... }`."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      ReturnStatement(node) {
+        const returnedObject = getReturnedObjectExpression(node.argument);
+        if (!returnedObject || !hasBooleanOkProperty(returnedObject)) {
+          return;
+        }
+        const containingFunction = getContainingFunction(node);
+        if (!containingFunction?.async || !isExportedFunction(containingFunction)) {
+          return;
+        }
+        context.report({
+          data: {
+            name: getFunctionName(containingFunction)
+          },
+          messageId: "adHocOkResult",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/utils/get-await-requires-try-safe-options.ts
+function getAwaitRequiresTrySafeOptions(options = {}) {
+  return {
+    allowFilePatterns: options.allowFilePatterns ?? [],
+    trySafeCallNames: options.trySafeCallNames ?? ["trySafe"]
+  };
+}
+
+// src/utils/get-await-scope-name.ts
+function getAwaitScopeName(node) {
+  const containingFunction = getContainingFunction(node);
+  return containingFunction ? getFunctionName(containingFunction) : "top-level";
+}
+
+// src/utils/get-enclosing-try-safe-call.ts
+function getEnclosingTrySafeCall(node, trySafeCallNames) {
+  let currentNode = node.parent;
+  while (currentNode) {
+    if (isFunctionNode(currentNode)) {
+      const parent = currentNode.parent;
+      if (parent?.type === "CallExpression" && parent.arguments.includes(currentNode) && isCalleeNamed(parent.callee, trySafeCallNames)) {
+        return parent;
+      }
+      return null;
+    }
+    currentNode = currentNode.parent;
+  }
+  return null;
+}
+
+// src/utils/contains-await-expression.ts
+function containsAwaitExpression(node) {
+  if (!isAstNode(node)) {
+    return false;
+  }
+  if (node.type === "AwaitExpression") {
+    return true;
+  }
+  if (isFunctionNode(node)) {
+    return false;
+  }
+  return getNodeChildren(node).some((child) => containsAwaitExpression(child));
+}
+
+// src/utils/get-call-expression-example.ts
+function getCallExpressionExample(node, sourceCode) {
+  const calleeText = sourceCode.getText(node.callee);
+  if (node.arguments.length === 0) {
+    return `${calleeText}()`;
+  }
+  if (node.arguments.length === 1 && unwrapExpression(node.arguments[0]).type === "ObjectExpression") {
+    return `${calleeText}({...})`;
+  }
+  return `${calleeText}(...)`;
+}
+
+// src/utils/get-awaited-operation-example.ts
+function getAwaitedOperationExample(node, sourceCode) {
+  const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type === "CallExpression") {
+    return getCallExpressionExample(unwrappedNode, sourceCode);
+  }
+  const expressionText = sourceCode.getText(unwrappedNode).replace(/\s+/g, " ");
+  return expressionText.length > 80 ? `${expressionText.slice(0, 77)}...` : expressionText;
+}
+
+// src/utils/get-try-safe-await-suggestion.ts
+function getTrySafeAwaitSuggestion(node, sourceCode) {
+  const callbackKeyword = containsAwaitExpression(node) ? "async " : "";
+  return `await trySafe(${callbackKeyword}() => ${getAwaitedOperationExample(
+    node,
+    sourceCode
+  )})`;
+}
+
+// src/utils/is-skapxd-result-or-promise-result-expression.ts
+function isSkapxdResultOrPromiseResultExpression(node, typeContext) {
+  return isSkapxdResultOrPromiseResultType(
+    typeContext.services.getTypeAtLocation(node),
+    typeContext
+  );
+}
+
+// src/utils/is-try-safe-call.ts
+function isTrySafeCall(node, trySafeCallNames) {
+  return node?.type === "CallExpression" && isCalleeNamed(node.callee, trySafeCallNames);
+}
+
+// src/rules/await-requires-try-safe.ts
+var awaitRequiresTrySafe = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exige que los await esten protegidos por trySafe."
+    },
+    messages: {
+      unprotectedAwait: "El await dentro de `{{name}}` no esta protegido por trySafe. Envuelve la operacion asi: `{{suggestion}}`."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowFilePatterns: {
+            items: { type: "string" },
+            type: "array"
+          },
+          trySafeCallNames: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getAwaitRequiresTrySafeOptions(context.options[0]);
+    const filename = context.filename ?? context.getFilename();
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const typeContext = getTypeContext(context);
+    function isSkapxdTrySafe(callNode) {
+      if (!callNode) {
+        return false;
+      }
+      if (!typeContext) {
+        return true;
+      }
+      const symbol = typeContext.services.getSymbolAtLocation(callNode.callee);
+      return Boolean(symbol && isSymbolFromSkapxdResult(symbol, typeContext));
+    }
+    return {
+      AwaitExpression(node) {
+        if (matchesAnyPattern(filename, options.allowFilePatterns)) {
+          return;
+        }
+        if (typeContext && isSkapxdResultOrPromiseResultExpression(node.argument, typeContext)) {
+          return;
+        }
+        const directCall = isTrySafeCall(node.argument, options.trySafeCallNames) ? node.argument : null;
+        const enclosingCall = getEnclosingTrySafeCall(
+          node,
+          options.trySafeCallNames
+        );
+        if (isSkapxdTrySafe(directCall) || isSkapxdTrySafe(enclosingCall)) {
+          return;
+        }
+        context.report({
+          data: {
+            name: getAwaitScopeName(node),
+            suggestion: getTrySafeAwaitSuggestion(node.argument, sourceCode)
+          },
+          messageId: "unprotectedAwait",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/utils/get-ok-member-object.ts
+function getOkMemberObject(node) {
+  const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type !== "MemberExpression" || unwrappedNode.object.type !== "Identifier" || !isMemberPropertyNamed(unwrappedNode, "ok")) {
+    return null;
+  }
+  return {
+    name: unwrappedNode.object.name,
+    node: unwrappedNode.object
+  };
+}
+
+// src/utils/is-failed-ok-comparison.ts
+function isFailedOkComparison(operator, comparedValue) {
+  return operator === "===" && comparedValue === false || operator === "!==" && comparedValue === true;
+}
+
+// src/utils/get-failed-result-binary-guard-name.ts
+function getFailedResultBinaryGuardName(node) {
+  const leftResult = getOkMemberObject(node.left);
+  const rightResult = getOkMemberObject(node.right);
+  const leftBoolean = getBooleanLiteralValue(node.left);
+  const rightBoolean = getBooleanLiteralValue(node.right);
+  if (leftResult && rightBoolean !== null) {
+    return isFailedOkComparison(node.operator, rightBoolean) ? leftResult : null;
+  }
+  if (rightResult && leftBoolean !== null) {
+    return isFailedOkComparison(node.operator, leftBoolean) ? rightResult : null;
+  }
+  return null;
+}
+
+// src/utils/get-result-check-argument.ts
+function getResultCheckArgument(node, methodName) {
+  const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type !== "CallExpression" || unwrappedNode.callee.type !== "MemberExpression" || !isMemberPropertyNamed(unwrappedNode.callee, methodName)) {
+    return null;
+  }
+  const argument = unwrappedNode.arguments[0];
+  if (argument?.type !== "Identifier") {
+    return null;
+  }
+  return { name: argument.name, node: argument };
+}
+
+// src/utils/get-failed-result-guard.ts
+function getFailedResultGuard(node) {
+  const unwrappedNode = unwrapExpression(node);
+  if (unwrappedNode.type === "UnaryExpression" && unwrappedNode.operator === "!") {
+    return getOkMemberObject(unwrappedNode.argument) ?? getResultCheckArgument(unwrappedNode.argument, "isOk");
+  }
+  if (unwrappedNode.type === "CallExpression") {
+    return getResultCheckArgument(unwrappedNode, "isErr");
+  }
+  if (unwrappedNode.type === "BinaryExpression" && ["===", "!=="].includes(unwrappedNode.operator)) {
+    return getFailedResultBinaryGuardName(unwrappedNode);
+  }
+  return null;
+}
+
+// src/utils/is-result-err-call.ts
+function isResultErrCall(node) {
+  return node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && isMemberPropertyNamed(node.callee, "err");
+}
+
+// src/utils/get-own-result-err-calls.ts
+function getOwnResultErrCalls(node, isRoot = true) {
+  if (!isAstNode(node)) {
+    return [];
+  }
+  if (isFunctionNode(node) || !isRoot && node.type === "IfStatement") {
+    return [];
+  }
+  const ownCalls = node.type === "CallExpression" && isResultErrCall(node) ? [node] : [];
+  return [
+    ...ownCalls,
+    ...getNodeChildren(node).flatMap((child) => getOwnResultErrCalls(child, false))
+  ];
+}
+
+// src/utils/get-function-return-type.ts
+function getFunctionReturnType(node, typeContext) {
+  if (node.returnType?.typeAnnotation) {
+    return typeContext.services.getTypeFromTypeNode(node.returnType.typeAnnotation);
+  }
+  const functionType = typeContext.services.getTypeAtLocation(node);
+  const signature = functionType.getCallSignatures()[0];
+  return signature?.getReturnType() ?? null;
+}
+
+// src/utils/function-returns-skapxd-result-type.ts
+function functionReturnsSkapxdResultType(node, typeContext) {
+  const returnType = getFunctionReturnType(node, typeContext);
+  return Boolean(returnType && isSkapxdResultOrPromiseResultType(returnType, typeContext));
+}
+
+// src/utils/is-inside-skapxd-result-returning-function.ts
+function isInsideSkapxdResultReturningFunction(node, typeContext) {
+  const containingFunction = getContainingFunction(node);
+  return Boolean(
+    containingFunction && functionReturnsSkapxdResultType(containingFunction, typeContext)
+  );
+}
+
+// src/utils/is-skapxd-result-err-call.ts
+function isSkapxdResultErrCall(node, typeContext) {
+  if (!isResultErrCall(node)) {
+    return false;
+  }
+  const symbol = typeContext.services.getSymbolAtLocation(node.callee.object);
+  return Boolean(symbol && isSymbolFromSkapxdResult(symbol, typeContext));
+}
+
+// src/utils/is-skapxd-result-expression.ts
+function isSkapxdResultExpression(node, typeContext) {
+  return isSkapxdResultType(typeContext.services.getTypeAtLocation(node), typeContext);
+}
+
+// src/utils/is-result-error-member.ts
+function isResultErrorMember(node, resultName) {
+  const unwrappedNode = unwrapExpression(node);
+  return unwrappedNode.type === "MemberExpression" && unwrappedNode.object.type === "Identifier" && unwrappedNode.object.name === resultName && isMemberPropertyNamed(unwrappedNode, "error");
+}
+
+// src/utils/result-err-preserves-cause.ts
+function resultErrPreservesCause(node, resultName) {
+  const unwrappedNode = unwrapExpression(node);
+  if (isResultErrorMember(unwrappedNode, resultName)) {
+    return true;
+  }
+  if (unwrappedNode.type !== "ObjectExpression") {
+    return false;
+  }
+  return unwrappedNode.properties.some((property) => {
+    if (property.type !== "Property" || !isPropertyKeyNamed(property, "cause")) {
+      return false;
+    }
+    return isResultErrorMember(property.value, resultName);
+  });
+}
+
+// src/rules/result-error-requires-cause.ts
+var resultErrorRequiresCause = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Exige preservar result.error como cause cuando una funcion que retorna Result transforma un Result fallido en Result.err."
+    },
+    messages: {
+      missingCause: "El error de `{{name}}` ya existe como `{{name}}.error`. Preservalo en Result.err con `cause: {{name}}.error`."
+    },
+    schema: []
+  },
+  create(context) {
+    const typeContext = getTypeContext(context);
+    return {
+      IfStatement(node) {
+        const resultGuard = getFailedResultGuard(node.test);
+        if (!typeContext || !resultGuard || !isSkapxdResultExpression(resultGuard.node, typeContext) || !isInsideSkapxdResultReturningFunction(node, typeContext)) {
+          return;
+        }
+        for (const resultErrCall of getOwnResultErrCalls(node.consequent)) {
+          if (!isSkapxdResultErrCall(resultErrCall, typeContext)) {
+            continue;
+          }
+          if (resultErrCall.arguments.length === 0) {
+            continue;
+          }
+          if (resultErrPreservesCause(resultErrCall.arguments[0], resultGuard.name)) {
+            continue;
+          }
+          context.report({
+            data: {
+              name: resultGuard.name
+            },
+            messageId: "missingCause",
+            node: resultErrCall
+          });
+        }
+      }
+    };
+  }
+};
+
+// src/utils/count-own-use-state-calls-in-node.ts
+function countOwnUseStateCallsInNode(node) {
+  if (!isAstNode(node)) {
+    return 0;
+  }
+  if (isFunctionNode(node)) {
+    return 0;
+  }
+  const ownCount = node.type === "CallExpression" && isCalleeNamed(node.callee, ["useState"]) ? 1 : 0;
+  return ownCount + getNodeChildren(node).reduce(
+    (total, child) => total + countOwnUseStateCallsInNode(child),
+    0
+  );
+}
+
+// src/utils/count-own-use-state-calls.ts
+function countOwnUseStateCalls(node) {
+  const body = node.body;
+  return isAstNode(body) ? countOwnUseStateCallsInNode(body) : 0;
+}
+
+// src/utils/get-function-line-count.ts
+function getFunctionLineCount(node) {
+  return node.loc ? node.loc.end.line - node.loc.start.line + 1 : 0;
+}
+
+// src/utils/get-max-hook-size-options.ts
+function getMaxHookSizeOptions(options = {}) {
+  return {
+    maxLines: options.maxLines ?? 120,
+    maxUseState: options.maxUseState ?? 1
+  };
+}
+
+// src/utils/is-hook-name.ts
+function isHookName(name) {
+  return /^use[A-Z0-9]/.test(name ?? "");
+}
+
+// src/rules/max-hook-size.ts
+var maxHookSize = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limita el tama\xF1o y cantidad de estados propios en hooks React."
+    },
+    messages: {
+      tooLargeHook: "El hook `{{name}}` es demasiado grande: tiene {{lines}} lineas. Maximo permitido: {{maxLines}} lineas. Extrae efectos, handlers o flujos a hooks/archivos semanticos.",
+      tooManyUseState: "El hook `{{name}}` declara {{useStateCount}} useState. Maximo permitido: {{maxUseState}}. Usa useReducer con acciones semanticas cuando varios campos cambian juntos, o extrae estado a hooks especializados."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          maxLines: { type: "number" },
+          maxUseState: { type: "number" }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const options = getMaxHookSizeOptions(context.options[0]);
+    function reportIfOversizedHook(node, name, reportNode = node) {
+      if (!isHookName(name)) {
+        return;
+      }
+      const lines = getFunctionLineCount(node);
+      const useStateCount = countOwnUseStateCalls(node);
+      if (lines > options.maxLines) {
+        context.report({
+          data: {
+            lines: String(lines),
+            maxLines: String(options.maxLines),
+            name
+          },
+          messageId: "tooLargeHook",
+          node: reportNode
+        });
+      }
+      if (useStateCount > options.maxUseState) {
+        context.report({
+          data: {
+            maxUseState: String(options.maxUseState),
+            name,
+            useStateCount: String(useStateCount)
+          },
+          messageId: "tooManyUseState",
+          node: reportNode
+        });
+      }
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        reportIfOversizedHook(
+          node,
+          getParentFunctionName(node),
+          getParentFunctionReportNode(node)
+        );
+      },
+      FunctionDeclaration(node) {
+        reportIfOversizedHook(node, node.id?.name, node.id ?? node);
+      },
+      FunctionExpression(node) {
+        reportIfOversizedHook(
+          node,
+          getFunctionExpressionName(node),
+          getParentFunctionReportNode(node)
+        );
+      }
+    };
+  }
+};
+
+// src/utils/count-parent-segments.ts
+function countParentSegments(source) {
+  let count = 0;
+  for (const part of source.split("/")) {
+    if (part === "..") {
+      count += 1;
+      continue;
+    }
+    if (part === ".") {
+      continue;
+    }
+    break;
+  }
+  return count;
+}
+
+// src/rules/no-deep-relative-imports.ts
+var noDeepRelativeImports = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Limita la profundidad de los imports relativos (`../`). Empuja hacia estructuras planas o alias de ruta."
+    },
+    messages: {
+      deepRelativeImport: "El import `{{source}}` sube {{depth}} niveles con `../`. Maximo permitido: {{maxDepth}}. Usa un alias de ruta (ej. `@/...`) o acerca el modulo a quien lo usa."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          maxDepth: { type: "number" }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const maxDepth = context.options[0]?.maxDepth ?? 0;
+    function reportIfTooDeep(source) {
+      if (!source || typeof source.value !== "string") {
+        return;
+      }
+      const depth = countParentSegments(source.value);
+      if (depth <= maxDepth) {
+        return;
+      }
+      context.report({
+        data: {
+          depth: String(depth),
+          maxDepth: String(maxDepth),
+          source: source.value
+        },
+        messageId: "deepRelativeImport",
+        node: source
+      });
+    }
+    return {
+      ExportAllDeclaration(node) {
+        reportIfTooDeep(node.source);
+      },
+      ExportNamedDeclaration(node) {
+        reportIfTooDeep(node.source);
+      },
+      ImportDeclaration(node) {
+        reportIfTooDeep(node.source);
+      },
+      ImportExpression(node) {
+        reportIfTooDeep(node.source);
+      }
+    };
+  }
+};
+
+// src/rules/no-functions-inside-components.ts
+var noFunctionsInsideComponents = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prohibe definir funciones dentro de componentes React; se recrean en cada render."
+    },
+    messages: {
+      functionInsideComponent: "No definas funciones dentro del componente `{{component}}`: se recrean en cada render. Muevela a un hook (`useX`) o a un helper fuera del componente."
+    },
+    schema: []
+  },
+  create(context) {
+    function isComponentFunction(node) {
+      return isFunctionNode(node) && isPascalCaseName(getFunctionName(node));
+    }
+    function reportIfInsideComponent(node) {
+      const enclosingFunction = getContainingFunction(node);
+      if (!enclosingFunction || !isComponentFunction(enclosingFunction)) {
+        return;
+      }
+      context.report({
+        data: {
+          component: getFunctionName(enclosingFunction)
+        },
+        messageId: "functionInsideComponent",
+        node
+      });
+    }
+    return {
+      ArrowFunctionExpression: reportIfInsideComponent,
+      FunctionDeclaration: reportIfInsideComponent,
+      FunctionExpression: reportIfInsideComponent
+    };
+  }
+};
+
+// src/rules/no-try-catch.ts
+var noTryCatch = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prohibe try/catch; usa trySafe de @skapxd/result para modelar el error como Result."
+    },
+    messages: {
+      noTryCatch: "Usa `trySafe` de @skapxd/result en lugar de try/catch. El error queda modelado como Result en vez de saltar como excepcion."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      TryStatement(node) {
+        context.report({
+          messageId: "noTryCatch",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/prefer-ts-pattern.ts
+var preferTsPattern = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefiere match() de ts-pattern sobre switch/case y ternarios anidados."
+    },
+    messages: {
+      noSwitch: "Usa `match()` de ts-pattern en lugar de switch/case para un control de flujo exhaustivo y tipado.",
+      noNestedTernary: "Usa `match()` de ts-pattern en lugar de ternarios anidados; mejora la legibilidad y la exhaustividad."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      ConditionalExpression(node) {
+        if (node.parent?.type === "ConditionalExpression") {
+          context.report({
+            messageId: "noNestedTernary",
+            node
+          });
+        }
+      },
+      SwitchStatement(node) {
+        context.report({
+          messageId: "noSwitch",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/rules/no-jsx-ternary-null.ts
+var noJsxTernaryNull = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefiere `condicion && <Elemento />` sobre un ternario con `null` al renderizar JSX."
+    },
+    messages: {
+      preferLogicalAnd: "Usa `condicion && elemento` en lugar de un ternario con `null` para renderizar JSX condicional."
+    },
+    schema: []
+  },
+  create(context) {
+    function isNullLiteral(node) {
+      return node?.type === "Literal" && node.value === null;
+    }
+    return {
+      ConditionalExpression(node) {
+        const container = node.parent;
+        if (container?.type !== "JSXExpressionContainer") {
+          return;
+        }
+        const host = container.parent;
+        if (host?.type !== "JSXElement" && host?.type !== "JSXFragment") {
+          return;
+        }
+        if (!isNullLiteral(node.alternate) && !isNullLiteral(node.consequent)) {
+          return;
+        }
+        context.report({
+          messageId: "preferLogicalAnd",
+          node
+        });
+      }
+    };
+  }
+};
+
+// src/utils/is-promise-type.ts
+function isPromiseType(type, typeContext) {
+  return typeContext.checker.getPromisedTypeOfPromise(type) !== void 0;
+}
+
+// src/rules/no-promise-chain.ts
+var defaultMethods = ["catch", "finally", "then"];
+var noPromiseChain = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prohibe encadenar .then/.catch/.finally en promesas; usa await (envuelto en trySafe)."
+    },
+    messages: {
+      noPromiseChain: "No encadenes `.{{method}}()` en una promesa. La unica forma de tratar funciones asincronas es `await` (envuelto en `trySafe`)."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          methods: {
+            items: { type: "string" },
+            type: "array"
+          }
+        },
+        type: "object"
+      }
+    ]
+  },
+  create(context) {
+    const methods = context.options[0]?.methods ?? defaultMethods;
+    const typeContext = getTypeContext(context);
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") {
+          return;
+        }
+        const method = methods.find((name) => isMemberPropertyNamed(callee, name));
+        if (!method) {
+          return;
+        }
+        if (typeContext) {
+          const type = typeContext.services.getTypeAtLocation(callee.object);
+          if (!isPromiseType(type, typeContext)) {
+            return;
+          }
+        }
+        context.report({
+          data: { method },
+          messageId: "noPromiseChain",
+          node: callee.property
+        });
+      }
+    };
+  }
+};
+
+// src/shared/rules.ts
+var rules = {
+  "one-root-function-per-file": oneRootFunctionPerFile,
+  "jsx-return-name-pascal-case": jsxReturnNamePascalCase,
+  "async-functions-return-result": asyncFunctionsReturnResult,
+  "no-ad-hoc-ok-result": noAdHocOkResult,
+  "await-requires-try-safe": awaitRequiresTrySafe,
+  "result-error-requires-cause": resultErrorRequiresCause,
+  "max-hook-size": maxHookSize,
+  "no-deep-relative-imports": noDeepRelativeImports,
+  "no-functions-inside-components": noFunctionsInsideComponents,
+  "no-try-catch": noTryCatch,
+  "prefer-ts-pattern": preferTsPattern,
+  "no-jsx-ternary-null": noJsxTernaryNull,
+  "no-promise-chain": noPromiseChain
+};
+
+// src/index.ts
+var plugin = {
+  // Diccionario dinámico de configs (cada entrada es un flat config o un array
+  // de ellos). Se tipa laxo, como es convención en los plugins de ESLint, para
+  // que `skapxd.configs.<preset>` sea accesible desde el config del consumidor.
+  configs: {},
+  meta: {
+    name: "@skapxd/eslint-opinionated",
+    version: "0.1.0"
+  },
+  rules
+};
+var sharedConfigs = createSharedConfigs(plugin);
+var nextConfigs = createNextConfigs(plugin);
+var astroConfigs = createAstroConfigs(plugin);
+plugin.configs = {
+  ...sharedConfigs,
+  astro: astroConfigs,
+  next: nextConfigs,
+  shared: sharedConfigs,
+  strict: strictConfig
+};
+var configs = plugin.configs;
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configs,
+  rules
+});
+//# sourceMappingURL=index.js.map