@mionjs/devtools 0.8.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/eslint/cjs/index.cjs

@@ -0,0 +1,41 @@
+"use strict";
+const src_eslint_rules_noTypeofRuntype = require("./src/eslint/rules/no-typeof-runtype.cjs");
+const src_eslint_rules_strongTypedRoutes = require("./src/eslint/rules/strong-typed-routes.cjs");
+const src_eslint_rules_noUnreachableUnionTypes = require("./src/eslint/rules/no-unreachable-union-types.cjs");
+const src_eslint_rules_noMixedUnionProperties = require("./src/eslint/rules/no-mixed-union-properties.cjs");
+const src_eslint_rules_noTypeImports = require("./src/eslint/rules/no-type-imports.cjs");
+const src_eslint_rules_pureFunctions = require("./src/eslint/rules/pure-functions.cjs");
+const src_eslint_rules_noViteClient = require("./src/eslint/rules/no-vite-client.cjs");
+const src_eslint_rules_typeFormatsImports = require("./src/eslint/rules/type-formats-imports.cjs");
+const src_eslint_rules_enforceTypeImports = require("./src/eslint/rules/enforce-type-imports.cjs");
+const plugin = {
+  rules: {
+    "no-typeof-runtype": src_eslint_rules_noTypeofRuntype,
+    "strong-typed-routes": src_eslint_rules_strongTypedRoutes,
+    "no-unreachable-union-types": src_eslint_rules_noUnreachableUnionTypes,
+    "no-mixed-union-properties": src_eslint_rules_noMixedUnionProperties,
+    "no-type-imports": src_eslint_rules_noTypeImports,
+    "pure-functions": src_eslint_rules_pureFunctions,
+    "no-vite-client": src_eslint_rules_noViteClient,
+    "type-formats-imports": src_eslint_rules_typeFormatsImports,
+    "enforce-type-imports": src_eslint_rules_enforceTypeImports
+  },
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: {
+    "@mionjs": plugin
+  },
+  rules: {
+    "@mionjs/no-typeof-runtype": "error",
+    "@mionjs/strong-typed-routes": "error",
+    "@mionjs/no-unreachable-union-types": "error",
+    "@mionjs/no-type-imports": "error",
+    "@mionjs/pure-functions": "error",
+    "@mionjs/type-formats-imports": "error"
+    // disabled as seems is not too useful and overlaps with some ts rules
+    // '@mionjs/no-mixed-union-properties': 'warn',
+  }
+};
+module.exports = plugin;
+//# sourceMappingURL=index.cjs.map

package/build/eslint/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../src/eslint/index.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 type {ESLint, Linter} from 'eslint';\nimport noTypeofRunType from './rules/no-typeof-runtype.ts';\nimport strongTypedRoutes from './rules/strong-typed-routes.ts';\nimport noUnreachableUnionTypes from './rules/no-unreachable-union-types.ts';\nimport noMixedUnionProperties from './rules/no-mixed-union-properties.ts';\nimport noTypeImports from './rules/no-type-imports.ts';\nimport pureFunctions from './rules/pure-functions.ts';\nimport noViteClient from './rules/no-vite-client.ts';\nimport typeFormatsImports from './rules/type-formats-imports.ts';\nimport enforceTypeImports from './rules/enforce-type-imports.ts';\n\n// configs is set outside the initial object due to circular reference: recommended config references the plugin itself.\nconst plugin: ESLint.Plugin = {\n    rules: {\n        'no-typeof-runtype': noTypeofRunType,\n        'strong-typed-routes': strongTypedRoutes,\n        'no-unreachable-union-types': noUnreachableUnionTypes,\n        'no-mixed-union-properties': noMixedUnionProperties,\n        'no-type-imports': noTypeImports,\n        'pure-functions': pureFunctions,\n        'no-vite-client': noViteClient,\n        'type-formats-imports': typeFormatsImports,\n        'enforce-type-imports': enforceTypeImports,\n    } as unknown as ESLint.Plugin['rules'],\n    configs: {},\n};\n\n// Flat config preset: self-contained with plugin registration and recommended rules.\n// Usage: import mionPlugin from '@mionjs/devtools/eslint'; ... mionPlugin.configs.recommended\nplugin.configs!.recommended = {\n    plugins: {\n        '@mionjs': plugin,\n    },\n    rules: {\n        '@mionjs/no-typeof-runtype': 'error',\n        '@mionjs/strong-typed-routes': 'error',\n        '@mionjs/no-unreachable-union-types': 'error',\n        '@mionjs/no-type-imports': 'error',\n        '@mionjs/pure-functions': 'error',\n        '@mionjs/type-formats-imports': 'error',\n        // disabled as seems is not too useful and overlaps with some ts rules\n        // '@mionjs/no-mixed-union-properties': 'warn',\n    },\n} satisfies Linter.Config;\n\nexport default plugin;\n"],"names":["noTypeofRunType","strongTypedRoutes","noUnreachableUnionTypes","noMixedUnionProperties","noTypeImports","pureFunctions","noViteClient","typeFormatsImports","enforceTypeImports"],"mappings":";;;;;;;;;;AAmBA,MAAM,SAAwB;AAAA,EAC1B,OAAO;AAAA,IACH,qBAAqBA;AAAAA,IACrB,uBAAuBC;AAAAA,IACvB,8BAA8BC;AAAAA,IAC9B,6BAA6BC;AAAAA,IAC7B,mBAAmBC;AAAAA,IACnB,kBAAkBC;AAAAA,IAClB,kBAAkBC;AAAAA,IAClB,wBAAwBC;AAAAA,IACxB,wBAAwBC;AAAAA,EAAA;AAAA,EAE5B,SAAS,CAAA;AACb;AAIA,OAAO,QAAS,cAAc;AAAA,EAC1B,SAAS;AAAA,IACL,WAAW;AAAA,EAAA;AAAA,EAEf,OAAO;AAAA,IACH,6BAA6B;AAAA,IAC7B,+BAA+B;AAAA,IAC/B,sCAAsC;AAAA,IACtC,2BAA2B;AAAA,IAC3B,0BAA0B;AAAA,IAC1B,gCAAgC;AAAA;AAAA;AAAA,EAAA;AAIxC;;"}

package/build/eslint/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/build/eslint/cjs/src/eslint/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+require("./rules/no-typeof-runtype.cjs");
+require("./rules/strong-typed-routes.cjs");
+require("./rules/no-unreachable-union-types.cjs");
+require("./rules/no-mixed-union-properties.cjs");
+require("./rules/no-type-imports.cjs");
+require("./rules/pure-functions.cjs");
+require("./rules/no-vite-client.cjs");
+require("./rules/type-formats-imports.cjs");
+require("./rules/enforce-type-imports.cjs");
+const index = require("../../index.cjs");
+module.exports = index;
+//# sourceMappingURL=index.cjs.map

package/build/eslint/cjs/src/eslint/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;"}

package/build/eslint/cjs/src/eslint/index.d.ts

@@ -0,0 +1,3 @@
+import { ESLint } from 'eslint';
+declare const plugin: ESLint.Plugin;
+export default plugin;

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

@@ -0,0 +1,121 @@
+"use strict";
+const utils = require("@typescript-eslint/utils");
+const rule = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "Enforce type-only imports from backend code paths to prevent bundling server code into the frontend."
+    },
+    messages: {
+      enforceTypeImport: 'Import from "{{source}}" must use "import type" to avoid importing backend code into the frontend bundle.',
+      enforceTypeExport: 'Re-export from "{{source}}" must use "export type" to avoid importing backend code into the frontend bundle.',
+      sideEffectImport: 'Side-effect import from "{{source}}" imports backend code into the frontend bundle. Remove this import or use "import type".'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          backendSources: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            description: "Array of regex patterns matching import sources that should use type-only imports."
+          }
+        },
+        required: ["backendSources"],
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [{ backendSources: [] }],
+  create(context) {
+    const options = context.options[0];
+    if (!options || !options.backendSources.length) return {};
+    const patterns = options.backendSources.map((p) => new RegExp(p));
+    function matchesBackend(source) {
+      return patterns.some((p) => p.test(source));
+    }
+    function hasAllValueSpecifiers(specifiers) {
+      return specifiers.every((s) => {
+        if (s.type === utils.AST_NODE_TYPES.ImportSpecifier) return s.importKind !== "type";
+        return true;
+      });
+    }
+    function fixImport(fixer, node) {
+      const sourceCode = context.sourceCode;
+      if (hasAllValueSpecifiers(node.specifiers)) {
+        const importToken = sourceCode.getFirstToken(node);
+        return fixer.insertTextAfter(importToken, " type");
+      }
+      const fixes = [];
+      for (const specifier of node.specifiers) {
+        if (specifier.type === utils.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
+          fixes.push(fixer.insertTextBefore(specifier, "type "));
+        }
+      }
+      return fixes;
+    }
+    function fixExport(fixer, node) {
+      const sourceCode = context.sourceCode;
+      const allValue = node.specifiers.every((s) => s.exportKind !== "type");
+      if (allValue) {
+        const exportToken = sourceCode.getFirstToken(node);
+        return fixer.insertTextAfter(exportToken, " type");
+      }
+      const fixes = [];
+      for (const specifier of node.specifiers) {
+        if (specifier.exportKind !== "type") {
+          fixes.push(fixer.insertTextBefore(specifier, "type "));
+        }
+      }
+      return fixes;
+    }
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        if (!matchesBackend(source)) return;
+        if (node.importKind === "type") return;
+        if (node.specifiers.length === 0) {
+          context.report({
+            node,
+            messageId: "sideEffectImport",
+            data: { source }
+          });
+          return;
+        }
+        const hasValueSpecifier = node.specifiers.some((s) => {
+          if (s.type === utils.AST_NODE_TYPES.ImportSpecifier) return s.importKind !== "type";
+          return true;
+        });
+        if (!hasValueSpecifier) return;
+        context.report({
+          node,
+          messageId: "enforceTypeImport",
+          data: { source },
+          fix(fixer) {
+            return fixImport(fixer, node);
+          }
+        });
+      },
+      ExportNamedDeclaration(node) {
+        if (!node.source) return;
+        const source = node.source.value;
+        if (!matchesBackend(source)) return;
+        if (node.exportKind === "type") return;
+        const hasValueSpecifier = node.specifiers.some((s) => s.exportKind !== "type");
+        if (!hasValueSpecifier) return;
+        context.report({
+          node,
+          messageId: "enforceTypeExport",
+          data: { source },
+          fix(fixer) {
+            return fixExport(fixer, node);
+          }
+        });
+      }
+    };
+  }
+};
+module.exports = rule;
+//# sourceMappingURL=enforce-type-imports.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"enforce-type-imports.cjs","sources":["../../../../../../src/eslint/rules/enforce-type-imports.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\nimport {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';\n\nexport interface Options {\n    backendSources: string[];\n}\n\ntype MessageIds = 'enforceTypeImport' | 'enforceTypeExport' | 'sideEffectImport';\n\n/** Enforce type-only imports from backend code to prevent bundling server code into the frontend. */\nconst rule: TSESLint.RuleModule<MessageIds, [Options]> = {\n    meta: {\n        type: 'suggestion',\n        fixable: 'code',\n        docs: {\n            description: 'Enforce type-only imports from backend code paths to prevent bundling server code into the frontend.',\n        },\n        messages: {\n            enforceTypeImport:\n                'Import from \"{{source}}\" must use \"import type\" to avoid importing backend code into the frontend bundle.',\n            enforceTypeExport:\n                'Re-export from \"{{source}}\" must use \"export type\" to avoid importing backend code into the frontend bundle.',\n            sideEffectImport:\n                'Side-effect import from \"{{source}}\" imports backend code into the frontend bundle. Remove this import or use \"import type\".',\n        },\n        schema: [\n            {\n                type: 'object',\n                properties: {\n                    backendSources: {\n                        type: 'array',\n                        items: {type: 'string'},\n                        minItems: 1,\n                        description: 'Array of regex patterns matching import sources that should use type-only imports.',\n                    },\n                },\n                required: ['backendSources'],\n                additionalProperties: false,\n            },\n        ],\n    },\n    defaultOptions: [{backendSources: []}],\n    create(context) {\n        const options = context.options[0];\n        if (!options || !options.backendSources.length) return {};\n\n        const patterns = options.backendSources.map((p) => new RegExp(p));\n\n        function matchesBackend(source: string): boolean {\n            return patterns.some((p) => p.test(source));\n        }\n\n        function hasAllValueSpecifiers(specifiers: TSESTree.ImportClause[]): boolean {\n            return specifiers.every((s) => {\n                if (s.type === AST_NODE_TYPES.ImportSpecifier) return s.importKind !== 'type';\n                return true; // default and namespace imports are always value\n            });\n        }\n\n        function fixImport(fixer: TSESLint.RuleFixer, node: TSESTree.ImportDeclaration): TSESLint.RuleFix | TSESLint.RuleFix[] {\n            const sourceCode = context.sourceCode;\n            if (hasAllValueSpecifiers(node.specifiers)) {\n                // convert entire declaration: insert 'type ' after 'import'\n                const importToken = sourceCode.getFirstToken(node)!;\n                return fixer.insertTextAfter(importToken, ' type');\n            }\n            // mixed: add 'type' to each value specifier\n            const fixes: TSESLint.RuleFix[] = [];\n            for (const specifier of node.specifiers) {\n                if (specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== 'type') {\n                    fixes.push(fixer.insertTextBefore(specifier, 'type '));\n                }\n            }\n            return fixes;\n        }\n\n        function fixExport(\n            fixer: TSESLint.RuleFixer,\n            node: TSESTree.ExportNamedDeclaration\n        ): TSESLint.RuleFix | TSESLint.RuleFix[] {\n            const sourceCode = context.sourceCode;\n            const allValue = node.specifiers.every((s) => s.exportKind !== 'type');\n            if (allValue) {\n                const exportToken = sourceCode.getFirstToken(node)!;\n                return fixer.insertTextAfter(exportToken, ' type');\n            }\n            const fixes: TSESLint.RuleFix[] = [];\n            for (const specifier of node.specifiers) {\n                if (specifier.exportKind !== 'type') {\n                    fixes.push(fixer.insertTextBefore(specifier, 'type '));\n                }\n            }\n            return fixes;\n        }\n\n        return {\n            ImportDeclaration(node: TSESTree.ImportDeclaration) {\n                const source = node.source.value;\n                if (!matchesBackend(source)) return;\n                if (node.importKind === 'type') return;\n\n                // side-effect import (no specifiers)\n                if (node.specifiers.length === 0) {\n                    context.report({\n                        node,\n                        messageId: 'sideEffectImport',\n                        data: {source},\n                    });\n                    return;\n                }\n\n                // check if all specifiers are already type-only\n                const hasValueSpecifier = node.specifiers.some((s) => {\n                    if (s.type === AST_NODE_TYPES.ImportSpecifier) return s.importKind !== 'type';\n                    return true;\n                });\n                if (!hasValueSpecifier) return;\n\n                context.report({\n                    node,\n                    messageId: 'enforceTypeImport',\n                    data: {source},\n                    fix(fixer) {\n                        return fixImport(fixer, node);\n                    },\n                });\n            },\n\n            ExportNamedDeclaration(node: TSESTree.ExportNamedDeclaration) {\n                if (!node.source) return;\n                const source = node.source.value;\n                if (!matchesBackend(source)) return;\n                if (node.exportKind === 'type') return;\n\n                const hasValueSpecifier = node.specifiers.some((s) => s.exportKind !== 'type');\n                if (!hasValueSpecifier) return;\n\n                context.report({\n                    node,\n                    messageId: 'enforceTypeExport',\n                    data: {source},\n                    fix(fixer) {\n                        return fixExport(fixer, node);\n                    },\n                });\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/enforce-type-imports.d.ts

@@ -0,0 +1,7 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export interface Options {
+    backendSources: string[];
+}
+type MessageIds = 'enforceTypeImport' | 'enforceTypeExport' | 'sideEffectImport';
+declare const rule: TSESLint.RuleModule<MessageIds, [Options]>;
+export default rule;

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

@@ -0,0 +1,71 @@
+"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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,3 @@
+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>>;

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

@@ -0,0 +1,220 @@
+"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

@@ -0,0 +1 @@
+{"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

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