@mionjs/devtools 0.8.10 → 0.13.2

package/build/eslint/cjs/src/eslint/rules/formatTypeNames.cjs

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const RUN_TYPES_FORMAT_TYPES = /* @__PURE__ */ new Set(["TypeFormat"]);
-const TYPE_FORMATS_FORMAT_TYPES = /* @__PURE__ */ new Set([
-  // Number formats (numberFormat.runtype.ts + defaultNumberFormats.ts)
-  "FormatNumber",
-  "FormatInteger",
-  "FormatFloat",
-  "FormatPositive",
-  "FormatNegative",
-  "FormatPositiveInt",
-  "FormatNegativeInt",
-  "FormatInt8",
-  "FormatInt16",
-  "FormatInt32",
-  "FormatUInt8",
-  "FormatUInt16",
-  "FormatUInt32",
-  // BigInt formats (bigIntFormat.runtype.ts + defaultBigNumberFormats.ts)
-  "FormatBigInt",
-  "FormatBigPositive",
-  "FormatBigNegative",
-  "FormatBigPositiveInt",
-  "FormatBigNegativeInt",
-  "FormatBigInt64",
-  "FormatBigUInt64",
-  // String format base (stringFormat.runtype.ts)
-  "FormatString",
-  // Date/Time formats (date.runtype.ts, time.runtype.ts, dateTime.runtype.ts)
-  "FormatStringDate",
-  "FormatStringTime",
-  "FormatStringDateTime",
-  // Email formats (email.runtype.ts)
-  "FormatEmail",
-  "FormatEmailStrict",
-  "FormatEmailPattern",
-  "FormatEmailPunycode",
-  // Domain formats (domain.runtype.ts)
-  "FormatDomain",
-  "FormatDomainStrict",
-  // URL formats (url.runtype.ts)
-  "FormatUrl",
-  "FormatUrlFile",
-  "FormatUrlHttp",
-  "FormatUrlSocialMedia",
-  // IP formats (ip.runtype.ts)
-  "FormatIP",
-  "FormatIPv4",
-  "FormatIPv6",
-  "FormatIPWithPort",
-  "FormatIPv4WithPort",
-  "FormatIPv6WithPort",
-  // UUID formats (uuid.runtype.ts)
-  "FormatUUIDv4",
-  "FormatUUIDv7",
-  // Default string formats (defaultStringFormats.runtype.ts)
-  "FormatAlphaNumeric",
-  "FormatAlpha",
-  "FormatNumeric",
-  "FormatLowercase",
-  "FormatUppercase",
-  "FormatCapitalize"
-]);
-const FORMAT_TYPES_BY_PACKAGE = /* @__PURE__ */ new Map([
-  ["@mionjs/run-types", RUN_TYPES_FORMAT_TYPES],
-  ["@mionjs/type-formats", TYPE_FORMATS_FORMAT_TYPES]
-]);
-exports.FORMAT_TYPES_BY_PACKAGE = FORMAT_TYPES_BY_PACKAGE;
-exports.RUN_TYPES_FORMAT_TYPES = RUN_TYPES_FORMAT_TYPES;
-exports.TYPE_FORMATS_FORMAT_TYPES = TYPE_FORMATS_FORMAT_TYPES;
-//# sourceMappingURL=formatTypeNames.cjs.map

package/build/eslint/cjs/src/eslint/rules/formatTypeNames.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatTypeNames.cjs","sources":["../../../../../../src/eslint/rules/formatTypeNames.ts"],"sourcesContent":["/* ########\n * 2026 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\n/**\n * Single source of truth for all TypeFormat type names that must NOT use `import type`.\n * Deepkit's type compiler needs actual imports to preserve type metadata for runtime reflection.\n * When new format types are added to @mionjs/type-formats or @mionjs/run-types, update this file.\n */\n\n/** Format type names from @mionjs/run-types that must not use `import type` */\nexport const RUN_TYPES_FORMAT_TYPES = new Set(['TypeFormat']);\n\n/** Format type names from @mionjs/type-formats that must not use `import type` */\nexport const TYPE_FORMATS_FORMAT_TYPES = new Set([\n    // Number formats (numberFormat.runtype.ts + defaultNumberFormats.ts)\n    'FormatNumber',\n    'FormatInteger',\n    'FormatFloat',\n    'FormatPositive',\n    'FormatNegative',\n    'FormatPositiveInt',\n    'FormatNegativeInt',\n    'FormatInt8',\n    'FormatInt16',\n    'FormatInt32',\n    'FormatUInt8',\n    'FormatUInt16',\n    'FormatUInt32',\n\n    // BigInt formats (bigIntFormat.runtype.ts + defaultBigNumberFormats.ts)\n    'FormatBigInt',\n    'FormatBigPositive',\n    'FormatBigNegative',\n    'FormatBigPositiveInt',\n    'FormatBigNegativeInt',\n    'FormatBigInt64',\n    'FormatBigUInt64',\n\n    // String format base (stringFormat.runtype.ts)\n    'FormatString',\n\n    // Date/Time formats (date.runtype.ts, time.runtype.ts, dateTime.runtype.ts)\n    'FormatStringDate',\n    'FormatStringTime',\n    'FormatStringDateTime',\n\n    // Email formats (email.runtype.ts)\n    'FormatEmail',\n    'FormatEmailStrict',\n    'FormatEmailPattern',\n    'FormatEmailPunycode',\n\n    // Domain formats (domain.runtype.ts)\n    'FormatDomain',\n    'FormatDomainStrict',\n\n    // URL formats (url.runtype.ts)\n    'FormatUrl',\n    'FormatUrlFile',\n    'FormatUrlHttp',\n    'FormatUrlSocialMedia',\n\n    // IP formats (ip.runtype.ts)\n    'FormatIP',\n    'FormatIPv4',\n    'FormatIPv6',\n    'FormatIPWithPort',\n    'FormatIPv4WithPort',\n    'FormatIPv6WithPort',\n\n    // UUID formats (uuid.runtype.ts)\n    'FormatUUIDv4',\n    'FormatUUIDv7',\n\n    // Default string formats (defaultStringFormats.runtype.ts)\n    'FormatAlphaNumeric',\n    'FormatAlpha',\n    'FormatNumeric',\n    'FormatLowercase',\n    'FormatUppercase',\n    'FormatCapitalize',\n]);\n\n/** Maps a source package prefix to the set of format type names from that package */\nexport const FORMAT_TYPES_BY_PACKAGE = new Map<string, Set<string>>([\n    ['@mionjs/run-types', RUN_TYPES_FORMAT_TYPES],\n    ['@mionjs/type-formats', TYPE_FORMATS_FORMAT_TYPES],\n]);\n"],"names":[],"mappings":";;AAcO,MAAM,yBAAyB,oBAAI,IAAI,CAAC,YAAY,CAAC;AAGrD,MAAM,gDAAgC,IAAI;AAAA;AAAA,EAE7C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACJ,CAAC;AAGM,MAAM,8CAA8B,IAAyB;AAAA,EAChE,CAAC,qBAAqB,sBAAsB;AAAA,EAC5C,CAAC,wBAAwB,yBAAyB;AACtD,CAAC;;;;"}

package/build/eslint/cjs/src/eslint/rules/formatTypeNames.d.ts

@@ -1,4 +0,0 @@
-export declare const RUN_TYPES_FORMAT_TYPES: Set<string>;
-export declare const TYPE_FORMATS_FORMAT_TYPES: Set<string>;
-export declare const FORMAT_TYPES_BY_PACKAGE: Map<string, Set<string>>;
-//# sourceMappingURL=formatTypeNames.d.ts.map

package/build/eslint/cjs/src/eslint/rules/formatTypeNames.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatTypeNames.d.ts","sourceRoot":"","sources":["../../../../../../src/eslint/rules/formatTypeNames.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,sBAAsB,aAA0B,CAAC;AAG9D,eAAO,MAAM,yBAAyB,aAoEpC,CAAC;AAGH,eAAO,MAAM,uBAAuB,0BAGlC,CAAC"}

package/build/eslint/cjs/src/eslint/rules/no-mixed-union-properties.cjs

@@ -1,220 +0,0 @@
-"use strict";
-const utils = require("@typescript-eslint/utils");
-function getObjectTypeProperties(node) {
-  if (node.type === utils.AST_NODE_TYPES.TSTypeLiteral) {
-    const props = [];
-    for (const member of node.members) {
-      if (member.type === utils.AST_NODE_TYPES.TSPropertySignature && member.key.type === utils.AST_NODE_TYPES.Identifier) {
-        props.push({ name: member.key.name, isOptional: !!member.optional });
-      }
-    }
-    return props;
-  }
-  return null;
-}
-function getUnionObjectTypes(unionNode) {
-  const types = [];
-  for (const typeNode of unionNode.types) {
-    const props = getObjectTypeProperties(typeNode);
-    if (props && props.length > 0) {
-      types.push({ node: typeNode, properties: props });
-    }
-  }
-  return types;
-}
-function getObjectLiteralPropertyNames(node) {
-  const names = [];
-  for (const prop of node.properties) {
-    if (prop.type === utils.AST_NODE_TYPES.Property && prop.key.type === utils.AST_NODE_TYPES.Identifier) {
-      names.push(prop.key.name);
-    }
-  }
-  return names;
-}
-function getMatchingUnionTypes(objectProps, unionTypes) {
-  const matchingIndices = [];
-  for (let i = 0; i < unionTypes.length; i++) {
-    const unionPropNames = new Set(unionTypes[i].properties.map((p) => p.name));
-    if (objectProps.some((prop) => unionPropNames.has(prop))) {
-      matchingIndices.push(i);
-    }
-  }
-  return matchingIndices;
-}
-function getUniquePropertiesPerType(unionTypes) {
-  const allProps = /* @__PURE__ */ new Map();
-  for (let i = 0; i < unionTypes.length; i++) {
-    for (const prop of unionTypes[i].properties) {
-      const existing = allProps.get(prop.name) || [];
-      existing.push(i);
-      allProps.set(prop.name, existing);
-    }
-  }
-  const uniqueProps = /* @__PURE__ */ new Map();
-  for (let i = 0; i < unionTypes.length; i++) {
-    const unique = /* @__PURE__ */ new Set();
-    for (const prop of unionTypes[i].properties) {
-      if ((allProps.get(prop.name) || []).length === 1) {
-        unique.add(prop.name);
-      }
-    }
-    uniqueProps.set(i, unique);
-  }
-  return uniqueProps;
-}
-function resolveTypeReference(node, context) {
-  if (node.type !== utils.AST_NODE_TYPES.TSTypeReference) {
-    return null;
-  }
-  if (node.typeName.type !== utils.AST_NODE_TYPES.Identifier) {
-    return null;
-  }
-  const typeName = node.typeName.name;
-  const sourceCode = context.sourceCode;
-  const program = sourceCode.ast;
-  for (const statement of program.body) {
-    if (statement.type === utils.AST_NODE_TYPES.TSTypeAliasDeclaration) {
-      if (statement.id.name === typeName && statement.typeAnnotation.type === utils.AST_NODE_TYPES.TSUnionType) {
-        return statement.typeAnnotation;
-      }
-    }
-  }
-  return null;
-}
-function getReturnTypeAnnotation(func, context) {
-  const returnType = func.returnType?.typeAnnotation;
-  if (!returnType) {
-    return null;
-  }
-  if (returnType.type === utils.AST_NODE_TYPES.TSUnionType) {
-    return returnType;
-  }
-  if (returnType.type === utils.AST_NODE_TYPES.TSTypeReference) {
-    return resolveTypeReference(returnType, context);
-  }
-  return null;
-}
-function findReturnStatements(func) {
-  const returns = [];
-  if (func.type === utils.AST_NODE_TYPES.ArrowFunctionExpression && func.expression && func.body.type !== utils.AST_NODE_TYPES.BlockStatement) {
-    returns.push(func.body);
-    return returns;
-  }
-  if (func.body.type === utils.AST_NODE_TYPES.BlockStatement) {
-    findReturnsInBlock(func.body, returns);
-  }
-  return returns;
-}
-function findReturnsInBlock(block, returns) {
-  for (const statement of block.body) {
-    if (statement.type === utils.AST_NODE_TYPES.ReturnStatement && statement.argument) {
-      returns.push(statement.argument);
-    } else if (statement.type === utils.AST_NODE_TYPES.IfStatement) {
-      if (statement.consequent.type === utils.AST_NODE_TYPES.BlockStatement) {
-        findReturnsInBlock(statement.consequent, returns);
-      } else if (statement.consequent.type === utils.AST_NODE_TYPES.ReturnStatement && statement.consequent.argument) {
-        returns.push(statement.consequent.argument);
-      }
-      if (statement.alternate?.type === utils.AST_NODE_TYPES.BlockStatement) {
-        findReturnsInBlock(statement.alternate, returns);
-      } else if (statement.alternate?.type === utils.AST_NODE_TYPES.ReturnStatement && statement.alternate.argument) {
-        returns.push(statement.alternate.argument);
-      }
-    }
-  }
-}
-function getConflictDescription(objectProps, unionTypes, matchingIndices) {
-  const uniqueProps = getUniquePropertiesPerType(unionTypes);
-  const conflicts = [];
-  for (const idx of matchingIndices) {
-    const unique = uniqueProps.get(idx) || /* @__PURE__ */ new Set();
-    const matchingProps = objectProps.filter((p) => unique.has(p));
-    if (matchingProps.length > 0) {
-      conflicts.push(`'${matchingProps.join("', '")}' from type ${idx + 1}`);
-    }
-  }
-  return conflicts.join(" and ");
-}
-function isRouterFunction(node, context) {
-  let current = node;
-  while (current) {
-    if (current.type === utils.AST_NODE_TYPES.CallExpression) {
-      return isRouterFunctionCall(current, context);
-    }
-    current = current.parent;
-  }
-  return false;
-}
-function isRouterFunctionCall(node, context) {
-  const routerFunctions = ["route", "middleFn", "headersFn"];
-  if (node.callee.type !== utils.AST_NODE_TYPES.Identifier || !routerFunctions.includes(node.callee.name)) {
-    return false;
-  }
-  return isImportedFromMionRouter(node.callee.name, context);
-}
-function isImportedFromMionRouter(name, context) {
-  const sourceCode = context.sourceCode;
-  const program = sourceCode.ast;
-  for (const statement of program.body) {
-    if (statement.type === utils.AST_NODE_TYPES.ImportDeclaration) {
-      const source = statement.source.value;
-      if (source === "@mionjs/router" || source === "@mionjs/router/") {
-        for (const specifier of statement.specifiers) {
-          if (specifier.type === utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === utils.AST_NODE_TYPES.Identifier && specifier.imported.name === name) {
-            return true;
-          }
-        }
-      }
-    }
-  }
-  return false;
-}
-function checkFunction(func, context) {
-  if (!isRouterFunction(func, context)) return;
-  const unionType = getReturnTypeAnnotation(func, context);
-  if (!unionType) return;
-  const unionTypes = getUnionObjectTypes(unionType);
-  if (unionTypes.length < 2) return;
-  const returnStatements = findReturnStatements(func);
-  for (const returnNode of returnStatements) {
-    if (returnNode.type !== utils.AST_NODE_TYPES.ObjectExpression) continue;
-    const objectProps = getObjectLiteralPropertyNames(returnNode);
-    if (objectProps.length === 0) continue;
-    const matchingIndices = getMatchingUnionTypes(objectProps, unionTypes);
-    const uniqueProps = getUniquePropertiesPerType(unionTypes);
-    const typesWithUniqueMatches = matchingIndices.filter((idx) => {
-      const unique = uniqueProps.get(idx) || /* @__PURE__ */ new Set();
-      return objectProps.some((prop) => unique.has(prop));
-    });
-    if (typesWithUniqueMatches.length > 1) {
-      const conflicts = getConflictDescription(objectProps, unionTypes, typesWithUniqueMatches);
-      context.report({ node: returnNode, messageId: "mixedUnionProperties", data: { conflicts } });
-    }
-  }
-}
-const rule = {
-  meta: {
-    type: "problem",
-    docs: { description: "Detect object literals with properties from multiple union types in router handlers" },
-    messages: {
-      mixedUnionProperties: "Object literal has properties from multiple union types: {{conflicts}}. With loose union matching, only the first matching type will be used for serialization."
-    },
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    return {
-      ArrowFunctionExpression(node) {
-        checkFunction(node, context);
-      },
-      FunctionExpression(node) {
-        checkFunction(node, context);
-      },
-      FunctionDeclaration(node) {
-        checkFunction(node, context);
-      }
-    };
-  }
-};
-module.exports = rule;
-//# sourceMappingURL=no-mixed-union-properties.cjs.map

package/build/eslint/cjs/src/eslint/rules/no-mixed-union-properties.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-mixed-union-properties.cjs","sources":["../../../../../../src/eslint/rules/no-mixed-union-properties.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';\n\ntype PropertyInfo = {name: string; isOptional: boolean};\ntype UnionTypeInfo = {node: TSESTree.TypeNode; properties: PropertyInfo[]};\n\nfunction getObjectTypeProperties(node: TSESTree.TypeNode): PropertyInfo[] | null {\n    if (node.type === AST_NODE_TYPES.TSTypeLiteral) {\n        const props: PropertyInfo[] = [];\n        for (const member of node.members) {\n            if (member.type === AST_NODE_TYPES.TSPropertySignature && member.key.type === AST_NODE_TYPES.Identifier) {\n                props.push({name: member.key.name, isOptional: !!member.optional});\n            }\n        }\n        return props;\n    }\n    return null;\n}\n\nfunction getUnionObjectTypes(unionNode: TSESTree.TSUnionType): UnionTypeInfo[] {\n    const types: UnionTypeInfo[] = [];\n    for (const typeNode of unionNode.types) {\n        const props = getObjectTypeProperties(typeNode);\n        if (props && props.length > 0) {\n            types.push({node: typeNode, properties: props});\n        }\n    }\n    return types;\n}\n\nfunction getObjectLiteralPropertyNames(node: TSESTree.ObjectExpression): string[] {\n    const names: string[] = [];\n    for (const prop of node.properties) {\n        if (prop.type === AST_NODE_TYPES.Property && prop.key.type === AST_NODE_TYPES.Identifier) {\n            names.push(prop.key.name);\n        }\n    }\n    return names;\n}\n\nfunction getMatchingUnionTypes(objectProps: string[], unionTypes: UnionTypeInfo[]): number[] {\n    const matchingIndices: number[] = [];\n    for (let i = 0; i < unionTypes.length; i++) {\n        const unionPropNames = new Set(unionTypes[i].properties.map((p) => p.name));\n        if (objectProps.some((prop) => unionPropNames.has(prop))) {\n            matchingIndices.push(i);\n        }\n    }\n    return matchingIndices;\n}\n\nfunction getUniquePropertiesPerType(unionTypes: UnionTypeInfo[]): Map<number, Set<string>> {\n    const allProps = new Map<string, number[]>();\n    for (let i = 0; i < unionTypes.length; i++) {\n        for (const prop of unionTypes[i].properties) {\n            const existing = allProps.get(prop.name) || [];\n            existing.push(i);\n            allProps.set(prop.name, existing);\n        }\n    }\n    const uniqueProps = new Map<number, Set<string>>();\n    for (let i = 0; i < unionTypes.length; i++) {\n        const unique = new Set<string>();\n        for (const prop of unionTypes[i].properties) {\n            if ((allProps.get(prop.name) || []).length === 1) {\n                unique.add(prop.name);\n            }\n        }\n        uniqueProps.set(i, unique);\n    }\n    return uniqueProps;\n}\n\n/**\n * Resolves a type reference to its actual union type definition\n */\nfunction resolveTypeReference(node: TSESTree.TypeNode, context: TSESLint.RuleContext<any, any>): TSESTree.TSUnionType | null {\n    if (node.type !== AST_NODE_TYPES.TSTypeReference) {\n        return null;\n    }\n\n    // Get the type name\n    if (node.typeName.type !== AST_NODE_TYPES.Identifier) {\n        return null;\n    }\n\n    const typeName = node.typeName.name;\n    const sourceCode = context.sourceCode;\n    const program = sourceCode.ast;\n\n    // Find the type alias declaration\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {\n            if (statement.id.name === typeName && statement.typeAnnotation.type === AST_NODE_TYPES.TSUnionType) {\n                return statement.typeAnnotation;\n            }\n        }\n    }\n\n    return null;\n}\n\nfunction getReturnTypeAnnotation(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,\n    context: TSESLint.RuleContext<any, any>\n): TSESTree.TSUnionType | null {\n    const returnType = func.returnType?.typeAnnotation;\n    if (!returnType) {\n        return null;\n    }\n\n    // Direct union type\n    if (returnType.type === AST_NODE_TYPES.TSUnionType) {\n        return returnType;\n    }\n\n    // Type reference that might resolve to a union type\n    if (returnType.type === AST_NODE_TYPES.TSTypeReference) {\n        return resolveTypeReference(returnType, context);\n    }\n\n    return null;\n}\n\nfunction findReturnStatements(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n): TSESTree.Node[] {\n    const returns: TSESTree.Node[] = [];\n    if (\n        func.type === AST_NODE_TYPES.ArrowFunctionExpression &&\n        func.expression &&\n        func.body.type !== AST_NODE_TYPES.BlockStatement\n    ) {\n        returns.push(func.body);\n        return returns;\n    }\n    if (func.body.type === AST_NODE_TYPES.BlockStatement) {\n        findReturnsInBlock(func.body, returns);\n    }\n    return returns;\n}\n\nfunction findReturnsInBlock(block: TSESTree.BlockStatement, returns: TSESTree.Node[]): void {\n    for (const statement of block.body) {\n        if (statement.type === AST_NODE_TYPES.ReturnStatement && statement.argument) {\n            returns.push(statement.argument);\n        } else if (statement.type === AST_NODE_TYPES.IfStatement) {\n            if (statement.consequent.type === AST_NODE_TYPES.BlockStatement) {\n                findReturnsInBlock(statement.consequent, returns);\n            } else if (statement.consequent.type === AST_NODE_TYPES.ReturnStatement && statement.consequent.argument) {\n                returns.push(statement.consequent.argument);\n            }\n            if (statement.alternate?.type === AST_NODE_TYPES.BlockStatement) {\n                findReturnsInBlock(statement.alternate, returns);\n            } else if (statement.alternate?.type === AST_NODE_TYPES.ReturnStatement && statement.alternate.argument) {\n                returns.push(statement.alternate.argument);\n            }\n        }\n    }\n}\n\nfunction getConflictDescription(objectProps: string[], unionTypes: UnionTypeInfo[], matchingIndices: number[]): string {\n    const uniqueProps = getUniquePropertiesPerType(unionTypes);\n    const conflicts: string[] = [];\n    for (const idx of matchingIndices) {\n        const unique = uniqueProps.get(idx) || new Set();\n        const matchingProps = objectProps.filter((p) => unique.has(p));\n        if (matchingProps.length > 0) {\n            conflicts.push(`'${matchingProps.join(\"', '\")}' from type ${idx + 1}`);\n        }\n    }\n    return conflicts.join(' and ');\n}\n\nfunction isRouterFunction(node: TSESTree.Node, context: TSESLint.RuleContext<any, any>): boolean {\n    let current: TSESTree.Node | undefined = node;\n    while (current) {\n        if (current.type === AST_NODE_TYPES.CallExpression) {\n            return isRouterFunctionCall(current, context);\n        }\n        current = current.parent;\n    }\n    return false;\n}\n\nfunction isRouterFunctionCall(node: TSESTree.CallExpression, context: TSESLint.RuleContext<any, any>): boolean {\n    const routerFunctions = ['route', 'middleFn', 'headersFn'];\n    if (node.callee.type !== AST_NODE_TYPES.Identifier || !routerFunctions.includes(node.callee.name)) {\n        return false;\n    }\n    return isImportedFromMionRouter(node.callee.name, context);\n}\n\nfunction isImportedFromMionRouter(name: string, context: TSESLint.RuleContext<any, any>): boolean {\n    const sourceCode = context.sourceCode;\n    const program = sourceCode.ast;\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n            const source = statement.source.value;\n            if (source === '@mionjs/router' || source === '@mionjs/router/') {\n                for (const specifier of statement.specifiers) {\n                    if (\n                        specifier.type === AST_NODE_TYPES.ImportSpecifier &&\n                        specifier.imported.type === AST_NODE_TYPES.Identifier &&\n                        specifier.imported.name === name\n                    ) {\n                        return true;\n                    }\n                }\n            }\n        }\n    }\n    return false;\n}\n\nfunction checkFunction(\n    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,\n    context: TSESLint.RuleContext<'mixedUnionProperties', []>\n) {\n    if (!isRouterFunction(func, context)) return;\n    const unionType = getReturnTypeAnnotation(func, context);\n    if (!unionType) return;\n    const unionTypes = getUnionObjectTypes(unionType);\n    if (unionTypes.length < 2) return;\n    const returnStatements = findReturnStatements(func);\n    for (const returnNode of returnStatements) {\n        if (returnNode.type !== AST_NODE_TYPES.ObjectExpression) continue;\n        const objectProps = getObjectLiteralPropertyNames(returnNode);\n        if (objectProps.length === 0) continue;\n        const matchingIndices = getMatchingUnionTypes(objectProps, unionTypes);\n        const uniqueProps = getUniquePropertiesPerType(unionTypes);\n        const typesWithUniqueMatches = matchingIndices.filter((idx) => {\n            const unique = uniqueProps.get(idx) || new Set();\n            return objectProps.some((prop) => unique.has(prop));\n        });\n        if (typesWithUniqueMatches.length > 1) {\n            const conflicts = getConflictDescription(objectProps, unionTypes, typesWithUniqueMatches);\n            context.report({node: returnNode, messageId: 'mixedUnionProperties', data: {conflicts}});\n        }\n    }\n}\n\nconst rule: TSESLint.RuleModule<'mixedUnionProperties', []> = {\n    meta: {\n        type: 'problem',\n        docs: {description: 'Detect object literals with properties from multiple union types in router handlers'},\n        messages: {\n            mixedUnionProperties:\n                'Object literal has properties from multiple union types: {{conflicts}}. ' +\n                'With loose union matching, only the first matching type will be used for serialization.',\n        },\n        schema: [],\n    },\n    defaultOptions: [],\n    create(context) {\n        return {\n            ArrowFunctionExpression(node: TSESTree.ArrowFunctionExpression) {\n                checkFunction(node, context);\n            },\n            FunctionExpression(node: TSESTree.FunctionExpression) {\n                checkFunction(node, context);\n            },\n            FunctionDeclaration(node: TSESTree.FunctionDeclaration) {\n                checkFunction(node, context);\n            },\n        };\n    },\n};\n\nexport default rule;\n"],"names":["AST_NODE_TYPES"],"mappings":"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"}

package/build/eslint/cjs/src/eslint/rules/no-mixed-union-properties.d.ts

@@ -1,4 +0,0 @@
-import { TSESLint } from '@typescript-eslint/utils';
-declare const rule: TSESLint.RuleModule<'mixedUnionProperties', []>;
-export default rule;
-//# sourceMappingURL=no-mixed-union-properties.d.ts.map

package/build/eslint/cjs/src/eslint/rules/no-mixed-union-properties.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-mixed-union-properties.d.ts","sourceRoot":"","sources":["../../../../../../src/eslint/rules/no-mixed-union-properties.ts"],"names":[],"mappings":"AAOA,OAAO,EAAW,QAAQ,EAAiB,MAAM,0BAA0B,CAAC;AAiP5E,QAAA,MAAM,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,sBAAsB,EAAE,EAAE,CAyBzD,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/build/eslint/cjs/src/eslint/rules/no-type-imports.cjs

@@ -1,251 +0,0 @@
-"use strict";
-const utils = require("@typescript-eslint/utils");
-const ROUTER_FUNCTIONS = ["route", "middleFn", "headersFn"];
-const HANDLER_TYPES = ["Handler", "HeaderHandler"];
-function buildRouterImportCache(program) {
-  const routerFunctions = /* @__PURE__ */ new Set();
-  const handlerTypes = /* @__PURE__ */ new Set();
-  for (const statement of program.body) {
-    if (statement.type === utils.AST_NODE_TYPES.ImportDeclaration) {
-      const source = statement.source.value;
-      if (source === "@mionjs/router" || source === "@mionjs/router/") {
-        for (const specifier of statement.specifiers) {
-          if (specifier.type === utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === utils.AST_NODE_TYPES.Identifier) {
-            const name = specifier.imported.name;
-            if (ROUTER_FUNCTIONS.includes(name)) {
-              routerFunctions.add(name);
-            }
-            if (HANDLER_TYPES.includes(name)) {
-              handlerTypes.add(name);
-            }
-          }
-        }
-      }
-    }
-  }
-  return { routerFunctions, handlerTypes };
-}
-function buildTypeOnlyImportCache(program) {
-  const typeOnlyImports = /* @__PURE__ */ new Map();
-  for (const statement of program.body) {
-    if (statement.type === utils.AST_NODE_TYPES.ImportDeclaration) {
-      const isTypeOnlyImport = statement.importKind === "type";
-      for (const specifier of statement.specifiers) {
-        if (specifier.type === utils.AST_NODE_TYPES.ImportSpecifier) {
-          const isTypeOnlySpecifier = specifier.importKind === "type";
-          if (isTypeOnlyImport || isTypeOnlySpecifier) {
-            const localName = specifier.local.name;
-            typeOnlyImports.set(localName, statement);
-          }
-        }
-      }
-    }
-  }
-  return { typeOnlyImports };
-}
-function getRouterFunctionName(node, importCache) {
-  if (node.callee.type !== utils.AST_NODE_TYPES.Identifier) return null;
-  const functionName = node.callee.name;
-  if (importCache.routerFunctions.has(functionName)) return functionName;
-  return null;
-}
-function extractTypeReferencesWithNodes(typeNode) {
-  if (!typeNode) return [];
-  const references = [];
-  switch (typeNode.type) {
-    case utils.AST_NODE_TYPES.TSTypeReference:
-      if (typeNode.typeName.type === utils.AST_NODE_TYPES.Identifier) {
-        references.push({ typeName: typeNode.typeName.name, node: typeNode });
-      }
-      if (typeNode.typeArguments) {
-        for (const param of typeNode.typeArguments.params) {
-          references.push(...extractTypeReferencesWithNodes(param));
-        }
-      }
-      break;
-    case utils.AST_NODE_TYPES.TSUnionType:
-    case utils.AST_NODE_TYPES.TSIntersectionType:
-      for (const member of typeNode.types) {
-        references.push(...extractTypeReferencesWithNodes(member));
-      }
-      break;
-    case utils.AST_NODE_TYPES.TSArrayType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.elementType));
-      break;
-    case utils.AST_NODE_TYPES.TSTupleType:
-      for (const element of typeNode.elementTypes) {
-        references.push(...extractTypeReferencesWithNodes(element));
-      }
-      break;
-    case utils.AST_NODE_TYPES.TSTypeLiteral:
-      for (const member of typeNode.members) {
-        if (member.type === utils.AST_NODE_TYPES.TSPropertySignature && member.typeAnnotation) {
-          references.push(...extractTypeReferencesWithNodes(member.typeAnnotation.typeAnnotation));
-        }
-      }
-      break;
-    case utils.AST_NODE_TYPES.TSConditionalType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.checkType));
-      references.push(...extractTypeReferencesWithNodes(typeNode.extendsType));
-      references.push(...extractTypeReferencesWithNodes(typeNode.trueType));
-      references.push(...extractTypeReferencesWithNodes(typeNode.falseType));
-      break;
-    case utils.AST_NODE_TYPES.TSMappedType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
-      break;
-    case utils.AST_NODE_TYPES.TSIndexedAccessType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.objectType));
-      references.push(...extractTypeReferencesWithNodes(typeNode.indexType));
-      break;
-    case utils.AST_NODE_TYPES.TSTypeOperator:
-      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
-      break;
-    case utils.AST_NODE_TYPES.TSRestType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
-      break;
-    case utils.AST_NODE_TYPES.TSOptionalType:
-      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
-      break;
-    case utils.AST_NODE_TYPES.TSFunctionType:
-    case utils.AST_NODE_TYPES.TSConstructorType:
-      for (const param of typeNode.params) {
-        if ("typeAnnotation" in param && param.typeAnnotation) {
-          references.push(...extractTypeReferencesWithNodes(param.typeAnnotation.typeAnnotation));
-        }
-      }
-      if (typeNode.returnType) {
-        references.push(...extractTypeReferencesWithNodes(typeNode.returnType.typeAnnotation));
-      }
-      break;
-  }
-  return references;
-}
-function getParamTypeAnnotation(param) {
-  if (param.type === utils.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
-    return param.typeAnnotation.typeAnnotation;
-  }
-  if (param.type === utils.AST_NODE_TYPES.RestElement && param.typeAnnotation) {
-    return param.typeAnnotation.typeAnnotation;
-  }
-  if (param.type === utils.AST_NODE_TYPES.ArrayPattern && param.typeAnnotation) {
-    return param.typeAnnotation.typeAnnotation;
-  }
-  if (param.type === utils.AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
-    return param.typeAnnotation.typeAnnotation;
-  }
-  if (param.type === utils.AST_NODE_TYPES.AssignmentPattern) {
-    if (param.typeAnnotation) {
-      return param.typeAnnotation.typeAnnotation;
-    }
-    if (param.left.type === utils.AST_NODE_TYPES.Identifier && param.left.typeAnnotation) {
-      return param.left.typeAnnotation.typeAnnotation;
-    }
-  }
-  return null;
-}
-function extractParamTypeReferencesWithNodes(params) {
-  const references = [];
-  for (let i = 1; i < params.length; i++) {
-    const param = params[i];
-    if (param) {
-      const typeAnnotation = getParamTypeAnnotation(param);
-      if (typeAnnotation) {
-        references.push(...extractTypeReferencesWithNodes(typeAnnotation));
-      }
-    }
-  }
-  return references;
-}
-function extractReturnTypeReferencesWithNodes(node) {
-  if (node.returnType) {
-    return extractTypeReferencesWithNodes(node.returnType.typeAnnotation);
-  }
-  return [];
-}
-const rule = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow type-only imports for types used in route/middleFn parameters or return types. Type-only imports are erased at runtime, preventing mion from generating validation and serialization functions."
-    },
-    messages: {
-      noTypeImports: 'Type "{{typeName}}" is imported as type-only but is used in a route/middleFn. Remove the "type" keyword from the import to allow runtime type reflection.'
-    },
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    let routerImportCache = null;
-    let typeOnlyImportCache = null;
-    function checkTypeReferencesWithNodes(typeRefs) {
-      if (!typeOnlyImportCache) return;
-      const reportedTypes = /* @__PURE__ */ new Set();
-      for (const { typeName, node } of typeRefs) {
-        if (reportedTypes.has(typeName)) continue;
-        const importDecl = typeOnlyImportCache.typeOnlyImports.get(typeName);
-        if (importDecl) {
-          reportedTypes.add(typeName);
-          context.report({
-            node,
-            messageId: "noTypeImports",
-            data: { typeName }
-          });
-        }
-      }
-    }
-    function checkFunctionNode(funcNode) {
-      const paramRefs = extractParamTypeReferencesWithNodes(funcNode.params);
-      const returnRefs = extractReturnTypeReferencesWithNodes(funcNode);
-      const allRefs = [...paramRefs, ...returnRefs];
-      checkTypeReferencesWithNodes(allRefs);
-    }
-    return {
-      Program(node) {
-        routerImportCache = buildRouterImportCache(node);
-        typeOnlyImportCache = buildTypeOnlyImportCache(node);
-      },
-      CallExpression(node) {
-        if (!routerImportCache || !typeOnlyImportCache) return;
-        const routerFunctionName = getRouterFunctionName(node, routerImportCache);
-        if (!routerFunctionName) return;
-        const handler = node.arguments[0];
-        if (!handler) return;
-        if (handler.type === utils.AST_NODE_TYPES.ArrowFunctionExpression || handler.type === utils.AST_NODE_TYPES.FunctionExpression) {
-          checkFunctionNode(handler);
-        } else if (handler.type === utils.AST_NODE_TYPES.Identifier) ;
-      },
-      // Check functions with Handler/HeaderHandler type annotations
-      VariableDeclarator(node) {
-        if (!routerImportCache || !typeOnlyImportCache) return;
-        if (node.id.type === utils.AST_NODE_TYPES.Identifier && node.id.typeAnnotation) {
-          const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
-          if (typeAnnotation.type === utils.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === utils.AST_NODE_TYPES.Identifier && routerImportCache.handlerTypes.has(typeAnnotation.typeName.name)) {
-            if (node.init && (node.init.type === utils.AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === utils.AST_NODE_TYPES.FunctionExpression)) {
-              checkFunctionNode(node.init);
-            }
-          }
-        }
-        if (node.init && node.init.type === utils.AST_NODE_TYPES.TSSatisfiesExpression && node.init.typeAnnotation.type === utils.AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === utils.AST_NODE_TYPES.Identifier && routerImportCache.handlerTypes.has(node.init.typeAnnotation.typeName.name)) {
-          const expr = node.init.expression;
-          if (expr.type === utils.AST_NODE_TYPES.ArrowFunctionExpression || expr.type === utils.AST_NODE_TYPES.FunctionExpression) {
-            checkFunctionNode(expr);
-          }
-        }
-      },
-      // Check function declarations with JSDoc tags
-      FunctionDeclaration(node) {
-        if (!routerImportCache || !typeOnlyImportCache) return;
-        const sourceCode = context.sourceCode;
-        const comments = sourceCode.getCommentsBefore(node);
-        for (const comment of comments) {
-          if (comment.type === "Block" && (comment.value.includes("@mion:route") || comment.value.includes("@mion:middleFn") || comment.value.includes("@mion:headersFn"))) {
-            checkFunctionNode(node);
-            break;
-          }
-        }
-      }
-    };
-  }
-};
-module.exports = rule;
-//# sourceMappingURL=no-type-imports.cjs.map

package/build/eslint/cjs/src/eslint/rules/no-type-imports.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-type-imports.cjs","sources":["../../../../../../src/eslint/rules/no-type-imports.ts"],"sourcesContent":["/* ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';\n\n/** List of router functions that should have strongly typed handlers */\nconst ROUTER_FUNCTIONS = ['route', 'middleFn', 'headersFn'] as const;\n/** List of handler types that can be used with type annotations */\nconst HANDLER_TYPES = ['Handler', 'HeaderHandler'] as const;\n\n/** Cache for imports from @mionjs/router - computed once per file */\ninterface MionRouterImports {\n    /** Set of function names imported from @mionjs/router (route, middleFn, headersFn) */\n    routerFunctions: Set<string>;\n    /** Set of type names imported from @mionjs/router (Handler, HeaderHandler) */\n    handlerTypes: Set<string>;\n}\n\n/** Cache for type-only imports - computed once per file */\ninterface TypeOnlyImports {\n    /** Map of type name to import declaration node */\n    typeOnlyImports: Map<string, TSESTree.ImportDeclaration>;\n}\n\n/** Type reference with its node for precise error reporting */\ninterface TypeRefWithNode {\n    typeName: string;\n    node: TSESTree.Node;\n}\n\n/** Builds a cache of all imports from @mionjs/router */\nfunction buildRouterImportCache(program: TSESTree.Program): MionRouterImports {\n    const routerFunctions = new Set<string>();\n    const handlerTypes = new Set<string>();\n\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n            const source = statement.source.value;\n            if (source === '@mionjs/router' || source === '@mionjs/router/') {\n                for (const specifier of statement.specifiers) {\n                    if (\n                        specifier.type === AST_NODE_TYPES.ImportSpecifier &&\n                        specifier.imported.type === AST_NODE_TYPES.Identifier\n                    ) {\n                        const name = specifier.imported.name;\n                        if (ROUTER_FUNCTIONS.includes(name as (typeof ROUTER_FUNCTIONS)[number])) {\n                            routerFunctions.add(name);\n                        }\n                        if (HANDLER_TYPES.includes(name as (typeof HANDLER_TYPES)[number])) {\n                            handlerTypes.add(name);\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    return {routerFunctions, handlerTypes};\n}\n\n/** Builds a cache of all type-only imports */\nfunction buildTypeOnlyImportCache(program: TSESTree.Program): TypeOnlyImports {\n    const typeOnlyImports = new Map<string, TSESTree.ImportDeclaration>();\n\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n            // Check if the entire import is type-only: import type { X } from '...'\n            const isTypeOnlyImport = statement.importKind === 'type';\n\n            for (const specifier of statement.specifiers) {\n                if (specifier.type === AST_NODE_TYPES.ImportSpecifier) {\n                    // Check if individual specifier is type-only: import { type X } from '...'\n                    const isTypeOnlySpecifier = specifier.importKind === 'type';\n\n                    if (isTypeOnlyImport || isTypeOnlySpecifier) {\n                        const localName = specifier.local.name;\n                        typeOnlyImports.set(localName, statement);\n                    }\n                }\n            }\n        }\n    }\n\n    return {typeOnlyImports};\n}\n\n/** Checks if a call expression is calling router functions from @mionjs/router */\nfunction getRouterFunctionName(node: TSESTree.CallExpression, importCache: MionRouterImports): string | null {\n    if (node.callee.type !== AST_NODE_TYPES.Identifier) return null;\n    const functionName = node.callee.name;\n    if (importCache.routerFunctions.has(functionName)) return functionName;\n    return null;\n}\n\n/** Extracts all type references with their nodes from a type node recursively */\nfunction extractTypeReferencesWithNodes(typeNode: TSESTree.TypeNode | null | undefined): TypeRefWithNode[] {\n    if (!typeNode) return [];\n\n    const references: TypeRefWithNode[] = [];\n\n    switch (typeNode.type) {\n        case AST_NODE_TYPES.TSTypeReference:\n            if (typeNode.typeName.type === AST_NODE_TYPES.Identifier) {\n                // Report on the type reference node itself (e.g., \"User\" in \": User\")\n                references.push({typeName: typeNode.typeName.name, node: typeNode});\n            }\n            // Also check type arguments (generics)\n            if (typeNode.typeArguments) {\n                for (const param of typeNode.typeArguments.params) {\n                    references.push(...extractTypeReferencesWithNodes(param));\n                }\n            }\n            break;\n\n        case AST_NODE_TYPES.TSUnionType:\n        case AST_NODE_TYPES.TSIntersectionType:\n            for (const member of typeNode.types) {\n                references.push(...extractTypeReferencesWithNodes(member));\n            }\n            break;\n\n        case AST_NODE_TYPES.TSArrayType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.elementType));\n            break;\n\n        case AST_NODE_TYPES.TSTupleType:\n            for (const element of typeNode.elementTypes) {\n                references.push(...extractTypeReferencesWithNodes(element));\n            }\n            break;\n\n        case AST_NODE_TYPES.TSTypeLiteral:\n            for (const member of typeNode.members) {\n                if (member.type === AST_NODE_TYPES.TSPropertySignature && member.typeAnnotation) {\n                    references.push(...extractTypeReferencesWithNodes(member.typeAnnotation.typeAnnotation));\n                }\n            }\n            break;\n\n        case AST_NODE_TYPES.TSConditionalType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.checkType));\n            references.push(...extractTypeReferencesWithNodes(typeNode.extendsType));\n            references.push(...extractTypeReferencesWithNodes(typeNode.trueType));\n            references.push(...extractTypeReferencesWithNodes(typeNode.falseType));\n            break;\n\n        case AST_NODE_TYPES.TSMappedType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));\n            break;\n\n        case AST_NODE_TYPES.TSIndexedAccessType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.objectType));\n            references.push(...extractTypeReferencesWithNodes(typeNode.indexType));\n            break;\n\n        case AST_NODE_TYPES.TSTypeOperator:\n            references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));\n            break;\n\n        case AST_NODE_TYPES.TSRestType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));\n            break;\n\n        case AST_NODE_TYPES.TSOptionalType:\n            references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));\n            break;\n\n        case AST_NODE_TYPES.TSFunctionType:\n        case AST_NODE_TYPES.TSConstructorType:\n            // Check parameters\n            for (const param of typeNode.params) {\n                if ('typeAnnotation' in param && param.typeAnnotation) {\n                    references.push(...extractTypeReferencesWithNodes(param.typeAnnotation.typeAnnotation));\n                }\n            }\n            // Check return type\n            if (typeNode.returnType) {\n                references.push(...extractTypeReferencesWithNodes(typeNode.returnType.typeAnnotation));\n            }\n            break;\n    }\n\n    return references;\n}\n\n/** Gets type annotation from a parameter if it exists */\nfunction getParamTypeAnnotation(param: TSESTree.Parameter): TSESTree.TypeNode | null {\n    if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {\n        return param.typeAnnotation.typeAnnotation;\n    }\n    if (param.type === AST_NODE_TYPES.RestElement && param.typeAnnotation) {\n        return param.typeAnnotation.typeAnnotation;\n    }\n    if (param.type === AST_NODE_TYPES.ArrayPattern && param.typeAnnotation) {\n        return param.typeAnnotation.typeAnnotation;\n    }\n    if (param.type === AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {\n        return param.typeAnnotation.typeAnnotation;\n    }\n    if (param.type === AST_NODE_TYPES.AssignmentPattern) {\n        // Check if there's a type annotation on the pattern itself\n        if (param.typeAnnotation) {\n            return param.typeAnnotation.typeAnnotation;\n        }\n        // Check if there's a type annotation on the left side\n        if (param.left.type === AST_NODE_TYPES.Identifier && param.left.typeAnnotation) {\n            return param.left.typeAnnotation.typeAnnotation;\n        }\n    }\n    return null;\n}\n\n/** Extracts type references with nodes from function parameters (excluding first ctx parameter) */\nfunction extractParamTypeReferencesWithNodes(params: TSESTree.Parameter[]): TypeRefWithNode[] {\n    const references: TypeRefWithNode[] = [];\n\n    // Skip first parameter (ctx)\n    for (let i = 1; i < params.length; i++) {\n        const param = params[i];\n        if (param) {\n            const typeAnnotation = getParamTypeAnnotation(param);\n            if (typeAnnotation) {\n                references.push(...extractTypeReferencesWithNodes(typeAnnotation));\n            }\n        }\n    }\n\n    return references;\n}\n\n/** Extracts type references with nodes from function return type */\nfunction extractReturnTypeReferencesWithNodes(\n    node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n): TypeRefWithNode[] {\n    if (node.returnType) {\n        return extractTypeReferencesWithNodes(node.returnType.typeAnnotation);\n    }\n    return [];\n}\n\nconst rule: TSESLint.RuleModule<'noTypeImports', []> = {\n    meta: {\n        type: 'problem',\n        docs: {\n            description:\n                'Disallow type-only imports for types used in route/middleFn parameters or return types. Type-only imports are erased at runtime, preventing mion from generating validation and serialization functions.',\n        },\n        messages: {\n            noTypeImports:\n                'Type \"{{typeName}}\" is imported as type-only but is used in a route/middleFn. Remove the \"type\" keyword from the import to allow runtime type reflection.',\n        },\n        schema: [],\n    },\n    defaultOptions: [],\n    create(context) {\n        let routerImportCache: MionRouterImports | null = null;\n        let typeOnlyImportCache: TypeOnlyImports | null = null;\n\n        /** Reports type-only imports used in handler, highlighting the specific type reference */\n        function checkTypeReferencesWithNodes(typeRefs: TypeRefWithNode[]): void {\n            if (!typeOnlyImportCache) return;\n\n            // Track reported types to avoid duplicates\n            const reportedTypes = new Set<string>();\n\n            for (const {typeName, node} of typeRefs) {\n                // Skip if already reported this type\n                if (reportedTypes.has(typeName)) continue;\n\n                const importDecl = typeOnlyImportCache.typeOnlyImports.get(typeName);\n                if (importDecl) {\n                    reportedTypes.add(typeName);\n                    context.report({\n                        node,\n                        messageId: 'noTypeImports',\n                        data: {typeName},\n                    });\n                }\n            }\n        }\n\n        /** Checks a function node for type-only imports */\n        function checkFunctionNode(\n            funcNode: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration\n        ): void {\n            const paramRefs = extractParamTypeReferencesWithNodes(funcNode.params);\n            const returnRefs = extractReturnTypeReferencesWithNodes(funcNode);\n            const allRefs = [...paramRefs, ...returnRefs];\n\n            checkTypeReferencesWithNodes(allRefs);\n        }\n\n        return {\n            Program(node) {\n                routerImportCache = buildRouterImportCache(node);\n                typeOnlyImportCache = buildTypeOnlyImportCache(node);\n            },\n\n            CallExpression(node: TSESTree.CallExpression) {\n                if (!routerImportCache || !typeOnlyImportCache) return;\n\n                const routerFunctionName = getRouterFunctionName(node, routerImportCache);\n                if (!routerFunctionName) return;\n\n                // Check the first argument (handler function)\n                const handler = node.arguments[0];\n                if (!handler) return;\n\n                if (\n                    handler.type === AST_NODE_TYPES.ArrowFunctionExpression ||\n                    handler.type === AST_NODE_TYPES.FunctionExpression\n                ) {\n                    checkFunctionNode(handler);\n                } else if (handler.type === AST_NODE_TYPES.Identifier) {\n                    // Handler is a reference to a function - we need to find the function declaration\n                    // This is handled by checking function declarations with Handler/HeaderHandler type annotations\n                }\n            },\n\n            // Check functions with Handler/HeaderHandler type annotations\n            VariableDeclarator(node: TSESTree.VariableDeclarator) {\n                if (!routerImportCache || !typeOnlyImportCache) return;\n\n                // Check if the variable has a Handler or HeaderHandler type annotation\n                if (node.id.type === AST_NODE_TYPES.Identifier && node.id.typeAnnotation) {\n                    const typeAnnotation = node.id.typeAnnotation.typeAnnotation;\n                    if (\n                        typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&\n                        typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&\n                        routerImportCache.handlerTypes.has(typeAnnotation.typeName.name)\n                    ) {\n                        // This is a handler with type annotation\n                        if (\n                            node.init &&\n                            (node.init.type === AST_NODE_TYPES.ArrowFunctionExpression ||\n                                node.init.type === AST_NODE_TYPES.FunctionExpression)\n                        ) {\n                            checkFunctionNode(node.init);\n                        }\n                    }\n                }\n\n                // Check for satisfies expressions\n                if (\n                    node.init &&\n                    node.init.type === AST_NODE_TYPES.TSSatisfiesExpression &&\n                    node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&\n                    node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&\n                    routerImportCache.handlerTypes.has(node.init.typeAnnotation.typeName.name)\n                ) {\n                    const expr = node.init.expression;\n                    if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression || expr.type === AST_NODE_TYPES.FunctionExpression) {\n                        checkFunctionNode(expr);\n                    }\n                }\n            },\n\n            // Check function declarations with JSDoc tags\n            FunctionDeclaration(node: TSESTree.FunctionDeclaration) {\n                if (!routerImportCache || !typeOnlyImportCache) return;\n\n                // Check for JSDoc tags\n                const sourceCode = context.sourceCode;\n                const comments = sourceCode.getCommentsBefore(node);\n\n                for (const comment of comments) {\n                    if (\n                        comment.type === 'Block' &&\n                        (comment.value.includes('@mion:route') ||\n                            comment.value.includes('@mion:middleFn') ||\n                            comment.value.includes('@mion:headersFn'))\n                    ) {\n                        checkFunctionNode(node);\n                        break;\n                    }\n                }\n            },\n        };\n    },\n};\n\nexport default rule;\n"],"names":["AST_NODE_TYPES"],"mappings":"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"}