@mionjs/devtools 0.8.10 → 0.13.0

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

@@ -1,357 +0,0 @@
-/* ########
- * 2024 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';
-
-type PropertyInfo = {
-    name: string;
-    isOptional: boolean;
-};
-
-/**
- * Extracts property names from an object type (interface body, type literal)
- */
-function getObjectTypeProperties(node: TSESTree.TypeNode): PropertyInfo[] | null {
-    if (node.type === AST_NODE_TYPES.TSTypeLiteral) {
-        const props: PropertyInfo[] = [];
-        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;
-}
-
-/**
- * Checks if typeB (earlier in union) blocks typeA (later in union), making typeA unreachable.
- *
- * TypeB blocks TypeA when:
- * - All properties of TypeB (required + optional) exist in TypeA
- * - TypeA has at least as many required properties as TypeB
- * - TypeA is more specific than TypeB (more properties OR same properties but more required)
- *
- * Examples:
- * - {a: string} blocks {a: string; b: number} - TypeB has 'a' (req), TypeA has 'a' (req) + 'b' (req)
- * - {a?: string} does NOT block {b: number; c: string} - TypeB has 'a', TypeA doesn't have 'a'
- * - {a: string; b?: number} blocks {a: string; b: number} - same props, but TypeA has more required
- *
- * @param typeAProps - Properties of the later type (potentially unreachable)
- * @param typeBProps - Properties of the earlier type (potentially blocking)
- * @returns true if typeB blocks typeA
- */
-function isSupersetOf(typeAProps: PropertyInfo[], typeBProps: PropertyInfo[]): boolean {
-    const typeARequired = typeAProps.filter((p) => !p.isOptional);
-    const typeBRequired = typeBProps.filter((p) => !p.isOptional);
-
-    // TypeA must have at least as many required properties as TypeB
-    if (typeARequired.length < typeBRequired.length) return false;
-
-    // TypeA must be more specific: either more properties OR same properties but more required
-    const isMoreSpecific =
-        typeAProps.length > typeBProps.length ||
-        (typeAProps.length === typeBProps.length && typeARequired.length > typeBRequired.length);
-
-    if (!isMoreSpecific) return false;
-
-    // Check if ALL properties of TypeB (required and optional) exist in TypeA
-    for (const propB of typeBProps) {
-        const propA = typeAProps.find((p) => p.name === propB.name);
-        // If TypeB has a prop that TypeA doesn't have, B doesn't block A
-        if (!propA) return false;
-    }
-
-    // TypeA has all properties of TypeB and is more specific, so TypeB blocks TypeA
-    return true;
-}
-
-/**
- * Checks if a union type has interfaces where one is a superset of another
- * and the subset comes before the superset (making the superset unreachable)
- */
-function findUnreachableTypes(unionNode: TSESTree.TSUnionType): {unreachable: TSESTree.TypeNode; blocker: TSESTree.TypeNode}[] {
-    const issues: {unreachable: TSESTree.TypeNode; blocker: TSESTree.TypeNode}[] = [];
-    const typesWithProps: {node: TSESTree.TypeNode; props: PropertyInfo[]}[] = [];
-
-    // Collect all object types with their properties
-    for (const typeNode of unionNode.types) {
-        const props = getObjectTypeProperties(typeNode);
-        if (props && props.length > 0) {
-            typesWithProps.push({node: typeNode, props});
-        }
-    }
-
-    // For each pair of types, check if one is a superset of another
-    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 typeA (earlier) is a subset of typeB (later), typeB is unreachable
-            if (isSupersetOf(typeB.props, typeA.props)) {
-                issues.push({unreachable: typeB.node, blocker: typeA.node});
-            }
-        }
-    }
-
-    return issues;
-}
-
-/**
- * Gets a readable representation of an object type for error messages
- */
-function getTypeDescription(node: TSESTree.TypeNode): string {
-    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';
-}
-
-/**
- * Gets the router function name if the function is a handler for route/middleFn/headersFn
- */
-function getRouterFunctionName(
-    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,
-    context: TSESLint.RuleContext<any, any>
-): string | null {
-    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;
-}
-
-/**
- * Checks if the union type or type reference is in a parameter that should be checked
- */
-function isInCheckableParameter(
-    node: TSESTree.TSUnionType | TSESTree.TSTypeReference,
-    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,
-    routerFunctionName: string
-): boolean {
-    // Find which parameter contains this union type
-    let current: TSESTree.Node | undefined = node.parent;
-    while (current && current !== func) {
-        // Check if we're in a parameter
-        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 as TSESTree.Parameter);
-            if (paramIndex !== -1) {
-                // For route and middleFn: skip first parameter (context)
-                if ((routerFunctionName === 'route' || routerFunctionName === 'middleFn') && paramIndex >= 1) {
-                    return true;
-                }
-                // For headersFn: skip first two parameters (context and headers)
-                if (routerFunctionName === 'headersFn' && paramIndex >= 2) {
-                    return true;
-                }
-                return false;
-            }
-        }
-        current = current.parent;
-    }
-    return false;
-}
-
-/**
- * Checks if the union type or type reference is a return type or parameter type of route/middleFn/headersFn
- */
-function isRouterUnionType(
-    node: TSESTree.TSUnionType | TSESTree.TSTypeReference,
-    context: TSESLint.RuleContext<any, any>
-): boolean {
-    // Check if we're in a return type annotation or parameter type annotation
-    let current: TSESTree.Node | undefined = node.parent;
-    while (current) {
-        // Check if we're in a function that's used in route/middleFn/headersFn
-        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) {
-                // Check if we're in the return type
-                if (current.returnType?.typeAnnotation === node || isDescendantOf(node, current.returnType?.typeAnnotation)) {
-                    return true;
-                }
-                // Check if we're in a parameter type (excluding context and headers params)
-                if (isInCheckableParameter(node, current, routerFunctionName)) {
-                    return true;
-                }
-            }
-        }
-        // Check if we're in a type annotation for Handler/HeaderHandler
-        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) {
-                    // Check if the type annotation references Handler/HeaderHandler
-                    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;
-}
-
-/**
- * Checks if a node is a descendant of another node
- */
-function isDescendantOf(node: TSESTree.Node | undefined, ancestor: TSESTree.Node | undefined): boolean {
-    if (!node || !ancestor) return false;
-    let current: TSESTree.Node | undefined = node;
-    while (current) {
-        if (current === ancestor) return true;
-        current = current.parent;
-    }
-    return false;
-}
-
-/**
- * Checks if a name is imported from @mionjs/router
- */
-function isImportedFromMionRouter(name: string, context: TSESLint.RuleContext<any, any>): boolean {
-    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;
-}
-
-/**
- * Resolves a type reference to its actual union type definition
- */
-function resolveTypeReference(node: TSESTree.TypeNode, context: TSESLint.RuleContext<any, any>): TSESTree.TSUnionType | null {
-    if (node.type !== AST_NODE_TYPES.TSTypeReference) {
-        return null;
-    }
-
-    // Get the type name
-    if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
-        return null;
-    }
-
-    const typeName = node.typeName.name;
-    const sourceCode = context.sourceCode;
-    const program = sourceCode.ast;
-
-    // Find the type alias declaration
-    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: TSESLint.RuleModule<'unreachableUnionType', []> = {
-    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: TSESTree.TSUnionType) {
-                // Only check unions in router context
-                if (!isRouterUnionType(node, context)) {
-                    return;
-                }
-
-                const issues = findUnreachableTypes(node);
-                for (const issue of issues) {
-                    context.report({
-                        node: node,
-                        messageId: 'unreachableUnionType',
-                        data: {
-                            unreachableType: getTypeDescription(issue.unreachable),
-                            blockerType: getTypeDescription(issue.blocker),
-                        },
-                    });
-                }
-            },
-            TSTypeReference(node: TSESTree.TSTypeReference) {
-                // Try to resolve the type reference to a union type
-                const unionType = resolveTypeReference(node, context);
-                if (!unionType) {
-                    return;
-                }
-
-                // Only check if this type reference is used in a router context
-                if (!isRouterUnionType(node, context)) {
-                    return;
-                }
-
-                const issues = findUnreachableTypes(unionType);
-                for (const issue of issues) {
-                    context.report({
-                        node: node,
-                        messageId: 'unreachableUnionType',
-                        data: {
-                            unreachableType: getTypeDescription(issue.unreachable),
-                            blockerType: getTypeDescription(issue.blocker),
-                        },
-                    });
-                }
-            },
-        };
-    },
-};
-
-export default rule;

package/src/eslint/rules/no-vite-client.ts

@@ -1,101 +0,0 @@
-/* ########
- * 2026 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';
-import {PURE_FN_SOURCE_PACKAGES} from '../../pureFns/purityRules.ts';
-
-type MessageIds = 'missingPureFnName' | 'missingMapFromName' | 'nameNotStringLiteral' | 'registerPureFnFactoryNotAllowed';
-
-/** Enforces non-Vite client constraints: requires names for pureServerFn/mapFrom and disallows registerPureFnFactory */
-const rule: TSESLint.RuleModule<MessageIds, []> = {
-    meta: {
-        type: 'problem',
-        docs: {
-            description:
-                'Enforce non-Vite client constraints: require name/bodyHash string literal for pureServerFn() and mapFrom(), and disallow registerPureFnFactory() which requires Vite transforms.',
-        },
-        messages: {
-            missingPureFnName:
-                'pureServerFn() requires a name as the second argument (string literal) for non-Vite environments.',
-            missingMapFromName: 'mapFrom() requires a name as the third argument (string literal) for non-Vite environments.',
-            nameNotStringLiteral: '{{callee}}() name argument must be a string literal, not a variable or expression.',
-            registerPureFnFactoryNotAllowed:
-                'registerPureFnFactory() is not supported in non-Vite environments. It requires Vite build-time transforms.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        let pureFnNames: Map<string, string> | null = null;
-
-        return {
-            Program(node: TSESTree.Program) {
-                pureFnNames = new Map();
-                for (const statement of node.body) {
-                    if (statement.type !== AST_NODE_TYPES.ImportDeclaration) continue;
-                    const source = statement.source.value;
-                    if (!PURE_FN_SOURCE_PACKAGES.includes(source as (typeof PURE_FN_SOURCE_PACKAGES)[number])) continue;
-
-                    for (const specifier of statement.specifiers) {
-                        if (
-                            specifier.type === AST_NODE_TYPES.ImportSpecifier &&
-                            specifier.imported.type === AST_NODE_TYPES.Identifier
-                        ) {
-                            const importedName = specifier.imported.name;
-                            if (
-                                importedName === 'pureServerFn' ||
-                                importedName === 'mapFrom' ||
-                                importedName === 'registerPureFnFactory'
-                            ) {
-                                pureFnNames.set(specifier.local.name, importedName);
-                            }
-                        }
-                    }
-                }
-            },
-
-            CallExpression(node: TSESTree.CallExpression) {
-                if (!pureFnNames || pureFnNames.size === 0) return;
-                if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
-                const importedName = pureFnNames.get(node.callee.name);
-                if (!importedName) return;
-
-                if (importedName === 'pureServerFn') {
-                    if (node.arguments.length < 2) {
-                        context.report({node, messageId: 'missingPureFnName'});
-                    } else if (
-                        node.arguments[1].type !== AST_NODE_TYPES.Literal ||
-                        typeof (node.arguments[1] as TSESTree.Literal).value !== 'string'
-                    ) {
-                        context.report({
-                            node: node.arguments[1],
-                            messageId: 'nameNotStringLiteral',
-                            data: {callee: 'pureServerFn'},
-                        });
-                    }
-                } else if (importedName === 'mapFrom') {
-                    if (node.arguments.length < 3) {
-                        context.report({node, messageId: 'missingMapFromName'});
-                    } else if (
-                        node.arguments[2].type !== AST_NODE_TYPES.Literal ||
-                        typeof (node.arguments[2] as TSESTree.Literal).value !== 'string'
-                    ) {
-                        context.report({
-                            node: node.arguments[2],
-                            messageId: 'nameNotStringLiteral',
-                            data: {callee: 'mapFrom'},
-                        });
-                    }
-                } else if (importedName === 'registerPureFnFactory') {
-                    context.report({node, messageId: 'registerPureFnFactoryNotAllowed'});
-                }
-            },
-        };
-    },
-};
-
-export default rule;