@mionjs/devtools 0.8.0-alpha.0

package/build/eslint/esm/src/eslint/rules/no-type-imports.js

@@ -0,0 +1,252 @@
+import { AST_NODE_TYPES } from "@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 === 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 === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === 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 === AST_NODE_TYPES.ImportDeclaration) {
+      const isTypeOnlyImport = statement.importKind === "type";
+      for (const specifier of statement.specifiers) {
+        if (specifier.type === 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 !== 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 AST_NODE_TYPES.TSTypeReference:
+      if (typeNode.typeName.type === 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 AST_NODE_TYPES.TSUnionType:
+    case AST_NODE_TYPES.TSIntersectionType:
+      for (const member of typeNode.types) {
+        references.push(...extractTypeReferencesWithNodes(member));
+      }
+      break;
+    case AST_NODE_TYPES.TSArrayType:
+      references.push(...extractTypeReferencesWithNodes(typeNode.elementType));
+      break;
+    case AST_NODE_TYPES.TSTupleType:
+      for (const element of typeNode.elementTypes) {
+        references.push(...extractTypeReferencesWithNodes(element));
+      }
+      break;
+    case AST_NODE_TYPES.TSTypeLiteral:
+      for (const member of typeNode.members) {
+        if (member.type === AST_NODE_TYPES.TSPropertySignature && member.typeAnnotation) {
+          references.push(...extractTypeReferencesWithNodes(member.typeAnnotation.typeAnnotation));
+        }
+      }
+      break;
+    case 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 AST_NODE_TYPES.TSMappedType:
+      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
+      break;
+    case AST_NODE_TYPES.TSIndexedAccessType:
+      references.push(...extractTypeReferencesWithNodes(typeNode.objectType));
+      references.push(...extractTypeReferencesWithNodes(typeNode.indexType));
+      break;
+    case AST_NODE_TYPES.TSTypeOperator:
+      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
+      break;
+    case AST_NODE_TYPES.TSRestType:
+      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
+      break;
+    case AST_NODE_TYPES.TSOptionalType:
+      references.push(...extractTypeReferencesWithNodes(typeNode.typeAnnotation));
+      break;
+    case AST_NODE_TYPES.TSFunctionType:
+    case 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 === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+    return param.typeAnnotation.typeAnnotation;
+  }
+  if (param.type === AST_NODE_TYPES.RestElement && param.typeAnnotation) {
+    return param.typeAnnotation.typeAnnotation;
+  }
+  if (param.type === AST_NODE_TYPES.ArrayPattern && param.typeAnnotation) {
+    return param.typeAnnotation.typeAnnotation;
+  }
+  if (param.type === AST_NODE_TYPES.ObjectPattern && param.typeAnnotation) {
+    return param.typeAnnotation.typeAnnotation;
+  }
+  if (param.type === AST_NODE_TYPES.AssignmentPattern) {
+    if (param.typeAnnotation) {
+      return param.typeAnnotation.typeAnnotation;
+    }
+    if (param.left.type === 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 === AST_NODE_TYPES.ArrowFunctionExpression || handler.type === AST_NODE_TYPES.FunctionExpression) {
+          checkFunctionNode(handler);
+        } else if (handler.type === AST_NODE_TYPES.Identifier) ;
+      },
+      // Check functions with Handler/HeaderHandler type annotations
+      VariableDeclarator(node) {
+        if (!routerImportCache || !typeOnlyImportCache) return;
+        if (node.id.type === AST_NODE_TYPES.Identifier && node.id.typeAnnotation) {
+          const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
+          if (typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && routerImportCache.handlerTypes.has(typeAnnotation.typeName.name)) {
+            if (node.init && (node.init.type === AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === AST_NODE_TYPES.FunctionExpression)) {
+              checkFunctionNode(node.init);
+            }
+          }
+        }
+        if (node.init && node.init.type === AST_NODE_TYPES.TSSatisfiesExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && routerImportCache.handlerTypes.has(node.init.typeAnnotation.typeName.name)) {
+          const expr = node.init.expression;
+          if (expr.type === AST_NODE_TYPES.ArrowFunctionExpression || expr.type === 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;
+          }
+        }
+      }
+    };
+  }
+};
+export {
+  rule as default
+};
+//# sourceMappingURL=no-type-imports.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"no-type-imports.js","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":[],"mappings":"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"}

package/build/eslint/esm/src/eslint/rules/no-typeof-runtype.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'noTypeof', []>;
+export default rule;

package/build/eslint/esm/src/eslint/rules/no-typeof-runtype.js

@@ -0,0 +1,73 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+function containsTypeof(typeNode) {
+  if (!typeNode) return false;
+  switch (typeNode.type) {
+    case AST_NODE_TYPES.TSTypeQuery:
+      return true;
+    case AST_NODE_TYPES.TSUnionType:
+    case AST_NODE_TYPES.TSIntersectionType:
+      return typeNode.types.some(containsTypeof);
+    case AST_NODE_TYPES.TSTupleType:
+      return typeNode.elementTypes.some(containsTypeof);
+    default:
+      return false;
+  }
+}
+function isRunTypeFromMionKit(node, context) {
+  const runTypeFunctions = ["runType", "isTypeFn", "typeErrorsFn", "mockTypeFn", "toJavascriptFn"];
+  if (node.callee.type !== AST_NODE_TYPES.Identifier || !runTypeFunctions.includes(node.callee.name)) {
+    return false;
+  }
+  const sourceCode = context.sourceCode;
+  const program = sourceCode.ast;
+  for (const statement of program.body) {
+    if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+      const source = statement.source.value;
+      if (source === "@mionjs/run-types" || source === "@mionjs/run-types/" || typeof source === "string" && (source.endsWith("/runType") || source.endsWith("/runTypeFunctions"))) {
+        for (const specifier of statement.specifiers) {
+          if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && runTypeFunctions.includes(specifier.imported.name)) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow using `typeof` with run-type functions from @mionjs/run-types"
+    },
+    messages: {
+      noTypeof: "Do not use `typeof` with `{{functionName}}()`. Use explicit type definitions instead."
+    },
+    schema: []
+    // No options
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (isRunTypeFromMionKit(node, context)) {
+          const typeArguments = node.typeArguments || node.typeParameters;
+          if (typeArguments?.params.some(containsTypeof)) {
+            const functionName = node.callee.name;
+            context.report({
+              node,
+              messageId: "noTypeof",
+              data: {
+                functionName
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+export {
+  rule as default
+};
+//# sourceMappingURL=no-typeof-runtype.js.map

package/build/eslint/esm/src/eslint/rules/no-typeof-runtype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-typeof-runtype.js","sources":["../../../../../../src/eslint/rules/no-typeof-runtype.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/**\n * Recursively checks if a type node contains `typeof`.\n * @param typeNode The type node to check.\n * @returns True if `typeof` is found, otherwise false.\n */\nfunction containsTypeof(typeNode: TSESTree.Node | null): boolean {\n    if (!typeNode) return false;\n\n    switch (typeNode.type) {\n        case AST_NODE_TYPES.TSTypeQuery:\n            return true;\n        case AST_NODE_TYPES.TSUnionType:\n        case AST_NODE_TYPES.TSIntersectionType:\n            return typeNode.types.some(containsTypeof);\n        case AST_NODE_TYPES.TSTupleType:\n            return typeNode.elementTypes.some(containsTypeof);\n        default:\n            return false;\n    }\n}\n\n/**\n * Checks if a call expression is calling runType or related functions from @mionjs/run-types\n * @param node The call expression node\n * @param context The ESLint context\n * @returns True if it's a runType or related function call from @mionjs/run-types\n */\nfunction isRunTypeFromMionKit(node: TSESTree.CallExpression, context: TSESLint.RuleContext<any, any>): boolean {\n    // List of functions that should not use typeof\n    const runTypeFunctions = ['runType', 'isTypeFn', 'typeErrorsFn', 'mockTypeFn', 'toJavascriptFn'];\n\n    // Check if the callee is an identifier with one of the runType function names\n    if (node.callee.type !== AST_NODE_TYPES.Identifier || !runTypeFunctions.includes(node.callee.name)) {\n        return false;\n    }\n\n    // Get the source code to check imports\n    const sourceCode = context.sourceCode;\n    const program = sourceCode.ast;\n\n    // Look for import statements that import runType or related functions from @mionjs/run-types or relative paths\n    for (const statement of program.body) {\n        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n            const source = statement.source.value;\n            // Check for @mionjs/run-types package or relative imports that end with runType or runTypeFunctions\n            if (\n                source === '@mionjs/run-types' ||\n                source === '@mionjs/run-types/' ||\n                (typeof source === 'string' && (source.endsWith('/runType') || source.endsWith('/runTypeFunctions')))\n            ) {\n                // Check if any of the runType functions are imported\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                        runTypeFunctions.includes(specifier.imported.name)\n                    ) {\n                        return true;\n                    }\n                }\n            }\n        }\n    }\n\n    return false;\n}\n\nconst rule: TSESLint.RuleModule<'noTypeof', []> = {\n    meta: {\n        type: 'problem',\n        docs: {\n            description: 'Disallow using `typeof` with run-type functions from @mionjs/run-types',\n        },\n        messages: {\n            noTypeof: 'Do not use `typeof` with `{{functionName}}()`. Use explicit type definitions instead.',\n        },\n        schema: [], // No options\n    },\n    defaultOptions: [],\n    create(context) {\n        return {\n            CallExpression(node: TSESTree.CallExpression) {\n                // Ensure the function being called is a run-type function from @mionjs/run-types\n                if (isRunTypeFromMionKit(node, context)) {\n                    // Check if type arguments contain typeof\n                    const typeArguments = (node as any).typeArguments || (node as any).typeParameters;\n                    if (typeArguments?.params.some(containsTypeof)) {\n                        const functionName = (node.callee as TSESTree.Identifier).name;\n                        context.report({\n                            node,\n                            messageId: 'noTypeof',\n                            data: {\n                                functionName,\n                            },\n                        });\n                    }\n                }\n            },\n        };\n    },\n};\n\nexport default rule;\n"],"names":[],"mappings":";AAcA,SAAS,eAAe,UAAyC;AAC7D,MAAI,CAAC,SAAU,QAAO;AAEtB,UAAQ,SAAS,MAAA;AAAA,IACb,KAAK,eAAe;AAChB,aAAO;AAAA,IACX,KAAK,eAAe;AAAA,IACpB,KAAK,eAAe;AAChB,aAAO,SAAS,MAAM,KAAK,cAAc;AAAA,IAC7C,KAAK,eAAe;AAChB,aAAO,SAAS,aAAa,KAAK,cAAc;AAAA,IACpD;AACI,aAAO;AAAA,EAAA;AAEnB;AAQA,SAAS,qBAAqB,MAA+B,SAAkD;AAE3G,QAAM,mBAAmB,CAAC,WAAW,YAAY,gBAAgB,cAAc,gBAAgB;AAG/F,MAAI,KAAK,OAAO,SAAS,eAAe,cAAc,CAAC,iBAAiB,SAAS,KAAK,OAAO,IAAI,GAAG;AAChG,WAAO;AAAA,EACX;AAGA,QAAM,aAAa,QAAQ;AAC3B,QAAM,UAAU,WAAW;AAG3B,aAAW,aAAa,QAAQ,MAAM;AAClC,QAAI,UAAU,SAAS,eAAe,mBAAmB;AACrD,YAAM,SAAS,UAAU,OAAO;AAEhC,UACI,WAAW,uBACX,WAAW,wBACV,OAAO,WAAW,aAAa,OAAO,SAAS,UAAU,KAAK,OAAO,SAAS,mBAAmB,IACpG;AAEE,mBAAW,aAAa,UAAU,YAAY;AAC1C,cACI,UAAU,SAAS,eAAe,mBAClC,UAAU,SAAS,SAAS,eAAe,cAC3C,iBAAiB,SAAS,UAAU,SAAS,IAAI,GACnD;AACE,mBAAO;AAAA,UACX;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AAEA,SAAO;AACX;AAEA,MAAM,OAA4C;AAAA,EAC9C,MAAM;AAAA,IACF,MAAM;AAAA,IACN,MAAM;AAAA,MACF,aAAa;AAAA,IAAA;AAAA,IAEjB,UAAU;AAAA,MACN,UAAU;AAAA,IAAA;AAAA,IAEd,QAAQ,CAAA;AAAA;AAAA,EAAC;AAAA,EAEb,gBAAgB,CAAA;AAAA,EAChB,OAAO,SAAS;AACZ,WAAO;AAAA,MACH,eAAe,MAA+B;AAE1C,YAAI,qBAAqB,MAAM,OAAO,GAAG;AAErC,gBAAM,gBAAiB,KAAa,iBAAkB,KAAa;AACnE,cAAI,eAAe,OAAO,KAAK,cAAc,GAAG;AAC5C,kBAAM,eAAgB,KAAK,OAA+B;AAC1D,oBAAQ,OAAO;AAAA,cACX;AAAA,cACA,WAAW;AAAA,cACX,MAAM;AAAA,gBACF;AAAA,cAAA;AAAA,YACJ,CACH;AAAA,UACL;AAAA,QACJ;AAAA,MACJ;AAAA,IAAA;AAAA,EAER;AACJ;"}

package/build/eslint/esm/src/eslint/rules/no-unreachable-union-types.d.ts

@@ -0,0 +1,3 @@
+import { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<'unreachableUnionType', []>;
+export default rule;

package/build/eslint/esm/src/eslint/rules/no-unreachable-union-types.js

@@ -0,0 +1,221 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+function getObjectTypeProperties(node) {
+  if (node.type === AST_NODE_TYPES.TSTypeLiteral) {
+    const props = [];
+    for (const member of node.members) {
+      if (member.type === AST_NODE_TYPES.TSPropertySignature && member.key.type === AST_NODE_TYPES.Identifier) {
+        props.push({ name: member.key.name, isOptional: !!member.optional });
+      }
+    }
+    return props;
+  }
+  return null;
+}
+function isSupersetOf(typeAProps, typeBProps) {
+  const typeARequired = typeAProps.filter((p) => !p.isOptional);
+  const typeBRequired = typeBProps.filter((p) => !p.isOptional);
+  if (typeARequired.length < typeBRequired.length) return false;
+  const isMoreSpecific = typeAProps.length > typeBProps.length || typeAProps.length === typeBProps.length && typeARequired.length > typeBRequired.length;
+  if (!isMoreSpecific) return false;
+  for (const propB of typeBProps) {
+    const propA = typeAProps.find((p) => p.name === propB.name);
+    if (!propA) return false;
+  }
+  return true;
+}
+function findUnreachableTypes(unionNode) {
+  const issues = [];
+  const typesWithProps = [];
+  for (const typeNode of unionNode.types) {
+    const props = getObjectTypeProperties(typeNode);
+    if (props && props.length > 0) {
+      typesWithProps.push({ node: typeNode, props });
+    }
+  }
+  for (let i = 0; i < typesWithProps.length; i++) {
+    for (let j = i + 1; j < typesWithProps.length; j++) {
+      const typeA = typesWithProps[i];
+      const typeB = typesWithProps[j];
+      if (isSupersetOf(typeB.props, typeA.props)) {
+        issues.push({ unreachable: typeB.node, blocker: typeA.node });
+      }
+    }
+  }
+  return issues;
+}
+function getTypeDescription(node) {
+  if (node.type === AST_NODE_TYPES.TSTypeLiteral) {
+    const props = getObjectTypeProperties(node);
+    if (props) {
+      return `{${props.map((p) => p.isOptional ? `${p.name}?` : p.name).join(", ")}}`;
+    }
+  }
+  return "object type";
+}
+function getRouterFunctionName(func, context) {
+  const parent = func.parent;
+  if (parent?.type === AST_NODE_TYPES.CallExpression) {
+    if (parent.callee.type === AST_NODE_TYPES.Identifier) {
+      const functionName = parent.callee.name;
+      if (["route", "middleFn", "headersFn"].includes(functionName) && isImportedFromMionRouter(functionName, context)) {
+        return functionName;
+      }
+    }
+  }
+  return null;
+}
+function isInCheckableParameter(node, func, routerFunctionName) {
+  let current = node.parent;
+  while (current && current !== func) {
+    if (current.type === AST_NODE_TYPES.Identifier || current.type === AST_NODE_TYPES.ArrayPattern || current.type === AST_NODE_TYPES.ObjectPattern) {
+      const paramIndex = func.params.indexOf(current);
+      if (paramIndex !== -1) {
+        if ((routerFunctionName === "route" || routerFunctionName === "middleFn") && paramIndex >= 1) {
+          return true;
+        }
+        if (routerFunctionName === "headersFn" && paramIndex >= 2) {
+          return true;
+        }
+        return false;
+      }
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isRouterUnionType(node, context) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === AST_NODE_TYPES.ArrowFunctionExpression || current.type === AST_NODE_TYPES.FunctionExpression || current.type === AST_NODE_TYPES.FunctionDeclaration) {
+      const routerFunctionName = getRouterFunctionName(current, context);
+      if (routerFunctionName) {
+        if (current.returnType?.typeAnnotation === node || isDescendantOf(node, current.returnType?.typeAnnotation)) {
+          return true;
+        }
+        if (isInCheckableParameter(node, current, routerFunctionName)) {
+          return true;
+        }
+      }
+    }
+    if (current.type === AST_NODE_TYPES.TSTypeAnnotation) {
+      const typeAnnotationParent = current.parent;
+      if (typeAnnotationParent?.type === AST_NODE_TYPES.Identifier) {
+        const declarator = typeAnnotationParent.parent;
+        if (declarator?.type === AST_NODE_TYPES.VariableDeclarator) {
+          if (current.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {
+            const typeName = current.typeAnnotation.typeName;
+            if (typeName.type === AST_NODE_TYPES.Identifier) {
+              if ((typeName.name === "Handler" || typeName.name === "HeaderHandler") && isImportedFromMionRouter(typeName.name, context)) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isDescendantOf(node, ancestor) {
+  if (!node || !ancestor) return false;
+  let current = node;
+  while (current) {
+    if (current === ancestor) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function isImportedFromMionRouter(name, context) {
+  const sourceCode = context.sourceCode;
+  const program = sourceCode.ast;
+  for (const statement of program.body) {
+    if (statement.type === 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 === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === name) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+function resolveTypeReference(node, context) {
+  if (node.type !== AST_NODE_TYPES.TSTypeReference) {
+    return null;
+  }
+  if (node.typeName.type !== 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 === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      if (statement.id.name === typeName && statement.typeAnnotation.type === AST_NODE_TYPES.TSUnionType) {
+        return statement.typeAnnotation;
+      }
+    }
+  }
+  return null;
+}
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Detect union types where one interface is unreachable at runtime when using isType function because a subset type comes before it"
+    },
+    messages: {
+      unreachableUnionType: "Union type {{unreachableType}} is unreachable at runtime when doing type checking because {{blockerType}} will always match first. To fix this move the more specific type {{unreachableType}} first within the union, ie: {{unreachableType}} | {{blockerType}} "
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSUnionType(node) {
+        if (!isRouterUnionType(node, context)) {
+          return;
+        }
+        const issues = findUnreachableTypes(node);
+        for (const issue of issues) {
+          context.report({
+            node,
+            messageId: "unreachableUnionType",
+            data: {
+              unreachableType: getTypeDescription(issue.unreachable),
+              blockerType: getTypeDescription(issue.blocker)
+            }
+          });
+        }
+      },
+      TSTypeReference(node) {
+        const unionType = resolveTypeReference(node, context);
+        if (!unionType) {
+          return;
+        }
+        if (!isRouterUnionType(node, context)) {
+          return;
+        }
+        const issues = findUnreachableTypes(unionType);
+        for (const issue of issues) {
+          context.report({
+            node,
+            messageId: "unreachableUnionType",
+            data: {
+              unreachableType: getTypeDescription(issue.unreachable),
+              blockerType: getTypeDescription(issue.blocker)
+            }
+          });
+        }
+      }
+    };
+  }
+};
+export {
+  rule as default
+};
+//# sourceMappingURL=no-unreachable-union-types.js.map