@codeperfect/eslint-plugin 2.3.0 → 2.4.0

package/dist/application/index.d.ts

@@ -1,4 +1,4 @@
-export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
 export { customRules } from "./custom-rules.js";
 export type { CustomRuleEntry } from "./custom-rules.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/application/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/application/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,kCAAkC,EAClC,yBAAyB,EACzB,6BAA6B,EAC7B,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/application/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,kCAAkC,EAClC,yBAAyB,EACzB,6BAA6B,EAC7B,iCAAiC,EACjC,mBAAmB,EACnB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/application/index.js

@@ -1,3 +1,3 @@
-export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
 export { customRules } from "./custom-rules.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwbGljYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLG1CQUFtQixFQUNuQix3QkFBd0IsRUFDeEIsd0JBQXdCLEVBQ3hCLDJCQUEyQixFQUMzQiwwQkFBMEIsRUFDMUIsd0JBQXdCLEVBQ3hCLHNCQUFzQixFQUN0QixtQkFBbUIsR0FDcEIsTUFBTSxXQUFXLENBQUM7QUFDbkIsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYXNzZXJ0QWN0dWFsRXhwZWN0ZWROYW1lc1J1bGUsXG4gIGJhcnJlbEZpbGVzRXhwb3J0c09ubHlSdWxlLFxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxuICBlbmZvcmNlQWFhU3RydWN0dXJlUnVsZSxcbiAgbm9JbXBvcnRFeHBvcnRBbGlhc2VzUnVsZSxcbiAgbm9JbXBvcnRFeHBvcnRFeHRlbnNpb25zUnVsZSxcbiAgbm9JbnRlcmZhY2VNZW1iZXJEb2N1bWVudGF0aW9uUnVsZSxcbiAgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSxcbiAgbm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc1J1bGUsXG4gIG5vVW51c2VkRXhwb3J0c1J1bGUsXG4gIHByZWZlckludGVyZmFjZVR5cGVzUnVsZSxcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXG59IGZyb20gXCIuLi9kb21haW5cIjtcbmV4cG9ydCB7IGN1c3RvbVJ1bGVzIH0gZnJvbSBcIi4vY3VzdG9tLXJ1bGVzXCI7XG5leHBvcnQgdHlwZSB7IEN1c3RvbVJ1bGVFbnRyeSB9IGZyb20gXCIuL2N1c3RvbS1ydWxlc1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwbGljYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLGlDQUFpQyxFQUNqQyxtQkFBbUIsRUFDbkIsd0JBQXdCLEVBQ3hCLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0IsMEJBQTBCLEVBQzFCLHdCQUF3QixFQUN4QixzQkFBc0IsRUFDdEIsbUJBQW1CLEdBQ3BCLE1BQU0sV0FBVyxDQUFDO0FBQ25CLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gIG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxuICBub1Vuc2FmZVZpdGVzdE1vY2tGYWN0b3J5Q2FzdFJ1bGUsXG4gIG5vVW51c2VkRXhwb3J0c1J1bGUsXG4gIHByZWZlckludGVyZmFjZVR5cGVzUnVsZSxcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXG59IGZyb20gXCIuLi9kb21haW5cIjtcbmV4cG9ydCB7IGN1c3RvbVJ1bGVzIH0gZnJvbSBcIi4vY3VzdG9tLXJ1bGVzXCI7XG5leHBvcnQgdHlwZSB7IEN1c3RvbVJ1bGVFbnRyeSB9IGZyb20gXCIuL2N1c3RvbS1ydWxlc1wiO1xuIl19

package/dist/domain/architecture/no-unused-exports/rule.js

@@ -52,8 +52,8 @@ const noUnusedExportsRule = {
             url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-unused-exports.md",
         },
         messages: {
-            unusedExport: "Export '{{exportedName}}' is never consumed by any file in the project.",
-            usedOnlyInTests: "Export '{{exportedName}}' is consumed only by test files.",
+            unusedExport: "Export '{{exportedName}}' is never consumed by any file in the project; make it private by removing the export.",
+            usedOnlyInTests: "Export '{{exportedName}}' is consumed only by test files; move it to the test file or a test utilities folder.",
         },
         schema: [
             {
@@ -79,4 +79,4 @@ const noUnusedExportsRule = {
     },
 };
 export { noUnusedExportsRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/index.d.ts

@@ -1,5 +1,5 @@
 export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noImportExportAliasesRule, noImportExportExtensionsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, } from "./architecture/index.js";
 export { noMultipleDeclaratorsRule, preferInterfaceTypesRule } from "./core/index.js";
 export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/index.js";
-export { assertActualExpectedNamesRule, enforceAaaStructureRule, preferViMockedImportRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
+export { assertActualExpectedNamesRule, enforceAaaStructureRule, noUnsafeVitestMockFactoryCastRule, preferViMockedImportRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAC7E,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,wBAAwB,EACxB,2BAA2B,EAC3B,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,EAC7B,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAC7E,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,6BAA6B,EAC7B,uBAAuB,EACvB,iCAAiC,EACjC,wBAAwB,EACxB,2BAA2B,EAC3B,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}

package/dist/domain/index.js

@@ -1,5 +1,5 @@
 export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noImportExportAliasesRule, noImportExportExtensionsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, } from "./architecture/index.js";
 export { noMultipleDeclaratorsRule, preferInterfaceTypesRule } from "./core/index.js";
 export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/index.js";
-export { assertActualExpectedNamesRule, enforceAaaStructureRule, preferViMockedImportRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qiw0QkFBNEIsRUFDNUIsNkJBQTZCLEVBQzdCLG1CQUFtQixHQUNwQixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUM3RSxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQixtQkFBbUIsR0FDcEIsTUFBTSxRQUFRLENBQUM7QUFDaEIsT0FBTyxFQUNMLDZCQUE2QixFQUM3Qix1QkFBdUIsRUFDdkIsd0JBQXdCLEVBQ3hCLDJCQUEyQixFQUMzQix3QkFBd0IsRUFDeEIsc0JBQXNCLEdBQ3ZCLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcclxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcclxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxyXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXHJcbiAgbm9JbXBvcnRFeHBvcnRFeHRlbnNpb25zUnVsZSxcclxuICBub1JlZXhwb3J0c091dHNpZGVCYXJyZWxzUnVsZSxcclxuICBub1VudXNlZEV4cG9ydHNSdWxlLFxyXG59IGZyb20gXCIuL2FyY2hpdGVjdHVyZVwiO1xyXG5leHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlLCBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUgfSBmcm9tIFwiLi9jb3JlXCI7XHJcbmV4cG9ydCB7XHJcbiAgbm9JbnRlcmZhY2VNZW1iZXJEb2N1bWVudGF0aW9uUnVsZSxcclxuICByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSxcclxuICBzaW5nbGVMaW5lSnNkb2NSdWxlLFxyXG59IGZyb20gXCIuL2RvY3NcIjtcclxuZXhwb3J0IHtcclxuICBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSxcclxuICBlbmZvcmNlQWFhU3RydWN0dXJlUnVsZSxcclxuICBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUsXHJcbiAgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxyXG4gIHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSxcclxuICBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlLFxyXG59IGZyb20gXCIuL3Rlc3RpbmdcIjtcclxuIl19
+export { assertActualExpectedNamesRule, enforceAaaStructureRule, noUnsafeVitestMockFactoryCastRule, preferViMockedImportRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qiw0QkFBNEIsRUFDNUIsNkJBQTZCLEVBQzdCLG1CQUFtQixHQUNwQixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUM3RSxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQixtQkFBbUIsR0FDcEIsTUFBTSxRQUFRLENBQUM7QUFDaEIsT0FBTyxFQUNMLDZCQUE2QixFQUM3Qix1QkFBdUIsRUFDdkIsaUNBQWlDLEVBQ2pDLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0Isd0JBQXdCLEVBQ3hCLHNCQUFzQixHQUN2QixNQUFNLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XHJcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXHJcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcclxuICBub0ltcG9ydEV4cG9ydEFsaWFzZXNSdWxlLFxyXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXHJcbiAgbm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc1J1bGUsXHJcbiAgbm9VbnVzZWRFeHBvcnRzUnVsZSxcclxufSBmcm9tIFwiLi9hcmNoaXRlY3R1cmVcIjtcclxuZXhwb3J0IHsgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSwgcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlIH0gZnJvbSBcIi4vY29yZVwiO1xyXG5leHBvcnQge1xyXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXHJcbiAgcmVxdWlyZUV4YW1wbGVMYW5ndWFnZVJ1bGUsXHJcbiAgc2luZ2xlTGluZUpzZG9jUnVsZSxcclxufSBmcm9tIFwiLi9kb2NzXCI7XHJcbmV4cG9ydCB7XHJcbiAgYXNzZXJ0QWN0dWFsRXhwZWN0ZWROYW1lc1J1bGUsXHJcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXHJcbiAgbm9VbnNhZmVWaXRlc3RNb2NrRmFjdG9yeUNhc3RSdWxlLFxyXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcclxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXHJcbiAgcmVxdWlyZVRlc3RDb21wYW5pb25SdWxlLFxyXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXHJcbn0gZnJvbSBcIi4vdGVzdGluZ1wiO1xyXG4iXX0=

package/dist/domain/testing/index.d.ts

@@ -1,5 +1,6 @@
 export { assertActualExpectedNamesRule } from "./assert-actual-expected-names/index.js";
 export { enforceAaaStructureRule } from "./enforce-aaa-structure/index.js";
+export { noUnsafeVitestMockFactoryCastRule } from "./no-unsafe-vitest-mock-factory-cast/index.js";
 export { preferViMockedImportRule } from "./prefer-vi-mocked-import/index.js";
 export { requireActResultCaptureRule } from "./require-act-result-capture/index.js";
 export { requireTestCompanionRule } from "./require-test-companion/index.js";

package/dist/domain/testing/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,iCAAiC,EAAE,MAAM,sCAAsC,CAAC;AACzF,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/domain/testing/index.js

@@ -1,7 +1,8 @@
 export { assertActualExpectedNamesRule } from "./assert-actual-expected-names/index.js";
 export { enforceAaaStructureRule } from "./enforce-aaa-structure/index.js";
+export { noUnsafeVitestMockFactoryCastRule } from "./no-unsafe-vitest-mock-factory-cast/index.js";
 export { preferViMockedImportRule } from "./prefer-vi-mocked-import/index.js";
 export { requireActResultCaptureRule } from "./require-act-result-capture/index.js";
 export { requireTestCompanionRule } from "./require-test-companion/index.js";
 export { singleActStatementRule } from "./single-act-statement/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0UsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDcEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSB9IGZyb20gXCIuL2Fzc2VydC1hY3R1YWwtZXhwZWN0ZWQtbmFtZXNcIjtcbmV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vZW5mb3JjZS1hYWEtc3RydWN0dXJlXCI7XG5leHBvcnQgeyBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUgfSBmcm9tIFwiLi9wcmVmZXItdmktbW9ja2VkLWltcG9ydFwiO1xuZXhwb3J0IHsgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlIH0gZnJvbSBcIi4vcmVxdWlyZS1hY3QtcmVzdWx0LWNhcHR1cmVcIjtcbmV4cG9ydCB7IHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtdGVzdC1jb21wYW5pb25cIjtcbmV4cG9ydCB7IHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUgfSBmcm9tIFwiLi9zaW5nbGUtYWN0LXN0YXRlbWVudFwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLGlDQUFpQyxFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDekYsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0UsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDcEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSB9IGZyb20gXCIuL2Fzc2VydC1hY3R1YWwtZXhwZWN0ZWQtbmFtZXNcIjtcbmV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vZW5mb3JjZS1hYWEtc3RydWN0dXJlXCI7XG5leHBvcnQgeyBub1Vuc2FmZVZpdGVzdE1vY2tGYWN0b3J5Q2FzdFJ1bGUgfSBmcm9tIFwiLi9uby11bnNhZmUtdml0ZXN0LW1vY2stZmFjdG9yeS1jYXN0XCI7XG5leHBvcnQgeyBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUgfSBmcm9tIFwiLi9wcmVmZXItdmktbW9ja2VkLWltcG9ydFwiO1xuZXhwb3J0IHsgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlIH0gZnJvbSBcIi4vcmVxdWlyZS1hY3QtcmVzdWx0LWNhcHR1cmVcIjtcbmV4cG9ydCB7IHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtdGVzdC1jb21wYW5pb25cIjtcbmV4cG9ydCB7IHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUgfSBmcm9tIFwiLi9zaW5nbGUtYWN0LXN0YXRlbWVudFwiO1xuIl19

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/index.d.ts

@@ -0,0 +1,2 @@
+export { noUnsafeVitestMockFactoryCastRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/no-unsafe-vitest-mock-factory-cast/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/index.js

@@ -0,0 +1,2 @@
+export { noUnsafeVitestMockFactoryCastRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3Rpbmcvbm8tdW5zYWZlLXZpdGVzdC1tb2NrLWZhY3RvcnktY2FzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsaUNBQWlDLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub1Vuc2FmZVZpdGVzdE1vY2tGYWN0b3J5Q2FzdFJ1bGUgfSBmcm9tIFwiLi9ydWxlXCI7XG4iXX0=

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** Disallows casted `vi.mock` and `vi.doMock` factories. */
+declare const noUnsafeVitestMockFactoryCastRule: Rule.RuleModule;
+export { noUnsafeVitestMockFactoryCastRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/no-unsafe-vitest-mock-factory-cast/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAuDnC,4DAA4D;AAC5D,QAAA,MAAM,iCAAiC,EAAE,IAAI,CAAC,UAkC7C,CAAC;AAyjBF,OAAO,EAAE,iCAAiC,EAAE,CAAC"}

package/dist/domain/testing/no-unsafe-vitest-mock-factory-cast/rule.js

@@ -0,0 +1,467 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+/** Supported `vi` mock method names. */
+const supportedMockNames = new Set(["doMock", "mock"]);
+/** Default suffix for generated namespace imports. */
+const moduleTypeSuffix = "Module";
+/** Disallows casted `vi.mock` and `vi.doMock` factories. */
+const noUnsafeVitestMockFactoryCastRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const match = getMockFactoryMatch(node);
+                if (match === void 0) {
+                    return;
+                }
+                context.report({
+                    fix: match.canAutofix
+                        ? (fixer) => buildFixes(context, fixer, match)
+                        : void 0,
+                    messageId: "noUnsafeVitestMockFactoryCast",
+                    node: match.node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Disallow casted vi.mock and vi.doMock factories and prefer createMockProxy(...) for partial module mocks.",
+            recommended: true,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-unsafe-vitest-mock-factory-cast.md",
+        },
+        fixable: "code",
+        messages: {
+            noUnsafeVitestMockFactoryCast: "Avoid casting vi.mock/vi.doMock factory results; use createMockProxy(...) with a type-only module import instead.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+/**
+ * Builds all fixes for one unsafe mock factory.
+ * @param context Rule context.
+ * @param fixer ESLint fixer.
+ * @param match Unsafe mock factory details.
+ * @returns All fixer operations.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function buildFixes(context, fixer, match) {
+    const sourceCode = context.sourceCode;
+    const moduleTypeImport = resolveModuleTypeImport(sourceCode, match.moduleSpecifier);
+    const factoryText = `createMockProxy<typeof ${moduleTypeImport.namespaceName}>(${sourceCode.getText(match.mockExpression)})`;
+    const fixes = [
+        fixer.replaceTextRange(match.mockFactoryNode.range, factoryText),
+    ];
+    if (!moduleTypeImport.isExisting) {
+        const importText = `import type * as ${moduleTypeImport.namespaceName} from ${JSON.stringify(match.moduleSpecifier)};`;
+        const insertionRange = getImportInsertionRange(sourceCode);
+        fixes.push(insertionRange === void 0
+            ? fixer.insertTextBeforeRange([0, 0], `${importText}\n\n`)
+            : fixer.insertTextAfterRange(insertionRange, `\n${importText}`));
+    }
+    return fixes;
+}
+/**
+ * Collects declaration identifiers from top-level declarations.
+ * @param declaration Declaration node.
+ * @param names Output name set.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function collectDeclarationNames(declaration, names) {
+    if (declaration.type === AST_NODE_TYPES.FunctionDeclaration ||
+        declaration.type === AST_NODE_TYPES.ClassDeclaration) {
+        if (declaration.id !== null) {
+            names.add(declaration.id.name);
+        }
+        return;
+    }
+    if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {
+        for (const variableDeclaration of declaration.declarations) {
+            collectPatternNames(variableDeclaration.id, names);
+        }
+        return;
+    }
+    if (declaration.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        declaration.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        declaration.type === AST_NODE_TYPES.TSEnumDeclaration) {
+        names.add(declaration.id.name);
+        return;
+    }
+    if (declaration.id.type === AST_NODE_TYPES.Identifier) {
+        names.add(declaration.id.name);
+    }
+}
+/**
+ * Collects identifiers from a binding pattern.
+ * @param pattern Binding pattern.
+ * @param names Output name set.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function collectPatternNames(pattern, names) {
+    if (pattern.type === AST_NODE_TYPES.Identifier) {
+        names.add(pattern.name);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.AssignmentPattern) {
+        collectPatternNames(pattern.left, names);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.RestElement) {
+        collectPatternNames(pattern.argument, names);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.ArrayPattern) {
+        for (const element of pattern.elements) {
+            if (element !== null) {
+                collectPatternNames(element, names);
+            }
+        }
+    }
+    if (pattern.type === AST_NODE_TYPES.ObjectPattern) {
+        for (const property of pattern.properties) {
+            if (property.type === AST_NODE_TYPES.Property) {
+                collectPatternNames(property.value, names);
+            }
+            if (property.type === AST_NODE_TYPES.RestElement) {
+                collectPatternNames(property.argument, names);
+            }
+        }
+    }
+}
+/**
+ * Collects top-level binding names to avoid collisions with inserted imports.
+ * @param statements Program statements.
+ * @returns All top-level names in the file.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function collectTopLevelNames(statements) {
+    const names = new Set();
+    for (const statement of statements) {
+        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+            for (const specifier of statement.specifiers) {
+                names.add(specifier.local.name);
+            }
+            continue;
+        }
+        if (statement.type === AST_NODE_TYPES.ExportNamedDeclaration) {
+            if (statement.declaration !== null &&
+                isNamedDeclaration(statement.declaration)) {
+                collectDeclarationNames(statement.declaration, names);
+            }
+            continue;
+        }
+        if (statement.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
+            if (isNamedDeclaration(statement.declaration)) {
+                collectDeclarationNames(statement.declaration, names);
+            }
+            continue;
+        }
+        if (isNamedDeclaration(statement)) {
+            collectDeclarationNames(statement, names);
+        }
+    }
+    return names;
+}
+/**
+ * Creates a namespace import name from a module specifier.
+ * @param moduleSpecifier Module path.
+ * @returns PascalCase namespace name.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function createNamespaceName(moduleSpecifier) {
+    const baseName = moduleSpecifier
+        .split("/")
+        .findLast((segment) => segment.length > 0 && segment !== ".")
+        ?.replace(/\.[^./\\]+$/, "") ?? "Module";
+    const pascalName = baseName
+        .replaceAll(/[^\dA-Za-z]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => segment.slice(0, 1).toUpperCase() + segment.slice(1))
+        .join("");
+    return pascalName.endsWith(moduleTypeSuffix)
+        ? pascalName
+        : `${pascalName}${moduleTypeSuffix}`;
+}
+/**
+ * Returns the casted expression only when the factory is safe to autofix.
+ * @param node Factory expression to inspect.
+ * @returns Cast-free expression when the factory can be safely replaced.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getAutofixableMockExpression(node) {
+    if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.async || node.params.length > 0) {
+            return void 0;
+        }
+        if (node.body.type === AST_NODE_TYPES.BlockStatement) {
+            return getAutofixableReturnedCastedExpression(node.body.body);
+        }
+        return getCastedExpression(node.body);
+    }
+    if (node.async || node.generator || node.params.length > 0) {
+        return void 0;
+    }
+    return getAutofixableReturnedCastedExpression(node.body.body);
+}
+/**
+ * Finds a casted return value from a single-return factory body.
+ * @param statements Function body statements.
+ * @returns Returned expression when the factory has exactly one return statement.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getAutofixableReturnedCastedExpression(statements) {
+    if (statements.length !== 1) {
+        return void 0;
+    }
+    const [statement] = statements;
+    if (statement.argument === null) {
+        return void 0;
+    }
+    return getCastedExpression(statement.argument);
+}
+/**
+ * Returns the inner expression if the input is a cast expression.
+ * @param expression Expression to inspect.
+ * @returns Inner expression when the input contains a cast.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getCastedExpression(expression) {
+    if (expression.type === AST_NODE_TYPES.TSAsExpression) {
+        return stripCastExpressions(expression.expression);
+    }
+    if (expression.type === AST_NODE_TYPES.TSTypeAssertion) {
+        const innerExpression = expression.expression;
+        return stripCastExpressions(innerExpression);
+    }
+    return void 0;
+}
+/**
+ * Returns the partial mock expression after removing a cast wrapper.
+ * @param node Factory expression to inspect.
+ * @returns Cast-free expression when the factory is unsafe.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getCastedMockExpression(node) {
+    if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === AST_NODE_TYPES.BlockStatement) {
+            return getReturnedCastedExpression(node.body.body);
+        }
+        return getCastedExpression(node.body);
+    }
+    return getReturnedCastedExpression(node.body.body);
+}
+/**
+ * Returns the range after the final import declaration.
+ * @param sourceCode Source code to inspect.
+ * @returns Range of the last import statement when present.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getImportInsertionRange(sourceCode) {
+    let lastImportRange;
+    for (const statement of sourceCode.ast.body) {
+        if (statement.type === AST_NODE_TYPES.ImportDeclaration &&
+            statement.range !== void 0) {
+            lastImportRange = statement.range;
+        }
+    }
+    return lastImportRange;
+}
+/**
+ * Collects the most appropriate mock-factory match from a `CallExpression`.
+ * @param node Call expression to inspect.
+ * @returns Unsafe mock factory details when the factory uses a cast.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getMockFactoryMatch(node) {
+    if (!isVitestMockCall(node) || node.arguments.length < 2) {
+        return void 0;
+    }
+    const [mockSpecifierNode, mockFactoryNode] = node.arguments;
+    if (mockSpecifierNode.type === AST_NODE_TYPES.SpreadElement ||
+        mockFactoryNode.type === AST_NODE_TYPES.SpreadElement) {
+        return void 0;
+    }
+    if (mockFactoryNode.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+        mockFactoryNode.type !== AST_NODE_TYPES.FunctionExpression) {
+        return void 0;
+    }
+    const moduleSpecifier = getModuleSpecifier(mockSpecifierNode);
+    if (moduleSpecifier === void 0) {
+        return void 0;
+    }
+    const mockExpression = getCastedMockExpression(mockFactoryNode);
+    if (mockExpression === void 0) {
+        return void 0;
+    }
+    const autofixableExpression = getAutofixableMockExpression(mockFactoryNode);
+    return {
+        canAutofix: autofixableExpression !== void 0,
+        mockExpression: autofixableExpression ?? mockExpression,
+        mockFactoryNode,
+        mockSpecifierNode,
+        moduleSpecifier,
+        node,
+    };
+}
+/**
+ * Extracts a string module specifier from the first mock argument.
+ * @param node First mock argument.
+ * @returns Module specifier when statically known.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getModuleSpecifier(node) {
+    if (node.type === AST_NODE_TYPES.Literal && typeof node.value === "string") {
+        return node.value;
+    }
+    if (node.type === AST_NODE_TYPES.ImportExpression &&
+        node.source.type === AST_NODE_TYPES.Literal &&
+        typeof node.source.value === "string") {
+        return node.source.value;
+    }
+    return void 0;
+}
+/**
+ * Finds the casted return value inside a function body.
+ * @param statements Function body statements.
+ * @returns Returned expression when it is casted.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function getReturnedCastedExpression(statements) {
+    for (const statement of statements) {
+        if (statement.type !== AST_NODE_TYPES.ReturnStatement) {
+            continue;
+        }
+        return statement.argument === null
+            ? void 0
+            : getCastedExpression(statement.argument);
+    }
+    return void 0;
+}
+/**
+ * Checks whether a node is a declaration that introduces top-level names.
+ * @param node Node to inspect.
+ * @returns True when the node is a supported declaration.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function isNamedDeclaration(node) {
+    return (node.type === AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === AST_NODE_TYPES.ClassDeclaration ||
+        node.type === AST_NODE_TYPES.VariableDeclaration ||
+        node.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||
+        node.type === AST_NODE_TYPES.TSInterfaceDeclaration ||
+        node.type === AST_NODE_TYPES.TSEnumDeclaration ||
+        node.type === AST_NODE_TYPES.TSModuleDeclaration);
+}
+/**
+ * Checks whether a call targets `vi.mock` or `vi.doMock`.
+ * @param node Call expression to inspect.
+ * @returns True when the callee is a supported Vitest mock method.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function isVitestMockCall(node) {
+    if (node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+        node.callee.object.type !== AST_NODE_TYPES.Identifier ||
+        node.callee.object.name !== "vi" ||
+        node.callee.property.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+    }
+    return supportedMockNames.has(node.callee.property.name);
+}
+/**
+ * Resolves the namespace import to use for `typeof Namespace`.
+ * @param sourceCode Source code for import inspection.
+ * @param moduleSpecifier Module path being mocked.
+ * @returns Existing or generated namespace import details.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function resolveModuleTypeImport(sourceCode, moduleSpecifier) {
+    const statements = sourceCode.ast.body;
+    const preferredName = createNamespaceName(moduleSpecifier);
+    for (const statement of statements) {
+        if (statement.type !== AST_NODE_TYPES.ImportDeclaration ||
+            statement.source.value !== moduleSpecifier) {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                return { isExisting: true, namespaceName: specifier.local.name };
+            }
+        }
+    }
+    const usedNames = collectTopLevelNames(statements);
+    let namespaceName = preferredName;
+    let suffix = 1;
+    while (usedNames.has(namespaceName)) {
+        namespaceName = `${preferredName}${suffix.toFixed(0)}`;
+        suffix += 1;
+    }
+    return { isExisting: false, namespaceName };
+}
+/**
+ * Removes nested cast wrappers from an expression.
+ * @param expression Expression to normalize.
+ * @returns Expression without any surrounding casts.
+ * @example
+ * ```ts
+ * // Internal helper for no-unsafe-vitest-mock-factory-cast.
+ * ```
+ */
+function stripCastExpressions(expression) {
+    if (expression.type === AST_NODE_TYPES.TSAsExpression) {
+        return stripCastExpressions(expression.expression);
+    }
+    if (expression.type === AST_NODE_TYPES.TSTypeAssertion) {
+        return stripCastExpressions(expression.expression);
+    }
+    return expression;
+}
+export { noUnsafeVitestMockFactoryCastRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/testing/no-unsafe-vitest-mock-factory-cast/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { AST_NODE_TYPES, type TSESTree } from \"@typescript-eslint/utils\";\n\n/** Unsafe mock-factory match details. */\ninterface MockFactoryMatch {\n  /** Whether the match can be safely autofixed. */\n  canAutofix: boolean;\n\n  /** Cast-free partial mock expression. */\n  mockExpression: TSESTree.Expression;\n\n  /** Second argument to the Vitest mock call. */\n  mockFactoryNode:\n    | TSESTree.ArrowFunctionExpression\n    | TSESTree.FunctionExpression;\n\n  /** First argument to the Vitest mock call. */\n  mockSpecifierNode: TSESTree.Expression;\n\n  /** Mocked module specifier. */\n  moduleSpecifier: string;\n\n  /** Report node. */\n  node: TSESTree.Node;\n}\n\n/** Namespace import details for the mocked module. */\ninterface ModuleTypeImport {\n  /** Whether the namespace import already exists in the file. */\n  isExisting: boolean;\n\n  /** Namespace identifier used in `typeof Namespace`. */\n  namespaceName: string;\n}\n\n/** Supported declaration shapes that can introduce top-level names. */\ntype NamedDeclaration =\n  | TSESTree.ClassDeclaration\n  | TSESTree.FunctionDeclaration\n  | TSESTree.TSEnumDeclaration\n  | TSESTree.TSInterfaceDeclaration\n  | TSESTree.TSModuleDeclaration\n  | TSESTree.TSTypeAliasDeclaration\n  | TSESTree.VariableDeclaration;\n\n/** Minimal source-code surface used by the rule. */\ntype SourceCodeLike = Pick<Rule.RuleContext[\"sourceCode\"], \"ast\" | \"getText\">;\n\n/** Supported `vi` mock method names. */\nconst supportedMockNames = new Set([\"doMock\", \"mock\"]);\n\n/** Default suffix for generated namespace imports. */\nconst moduleTypeSuffix = \"Module\";\n\n/** Disallows casted `vi.mock` and `vi.doMock` factories. */\nconst noUnsafeVitestMockFactoryCastRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      CallExpression(node): void {\n        const match = getMockFactoryMatch(node as TSESTree.CallExpression);\n        if (match === void 0) {\n          return;\n        }\n\n        context.report({\n          fix: match.canAutofix\n            ? (fixer): Rule.Fix[] => buildFixes(context, fixer, match)\n            : void 0,\n          messageId: \"noUnsafeVitestMockFactoryCast\",\n          node: match.node,\n        });\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: {\n      description:\n        \"Disallow casted vi.mock and vi.doMock factories and prefer createMockProxy(...) for partial module mocks.\",\n      recommended: true,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-unsafe-vitest-mock-factory-cast.md\",\n    },\n    fixable: \"code\",\n    messages: {\n      noUnsafeVitestMockFactoryCast:\n        \"Avoid casting vi.mock/vi.doMock factory results; use createMockProxy(...) with a type-only module import instead.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\n/** CallExpression argument that is not a spread element. */\ntype NonSpreadCallExpressionArgument = Exclude<\n  TSESTree.CallExpressionArgument,\n  TSESTree.SpreadElement\n>;\n\n/**\n * Builds all fixes for one unsafe mock factory.\n * @param context Rule context.\n * @param fixer ESLint fixer.\n * @param match Unsafe mock factory details.\n * @returns All fixer operations.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction buildFixes(\n  context: Rule.RuleContext,\n  fixer: Rule.RuleFixer,\n  match: MockFactoryMatch,\n): Rule.Fix[] {\n  const sourceCode = context.sourceCode;\n  const moduleTypeImport = resolveModuleTypeImport(\n    sourceCode,\n    match.moduleSpecifier,\n  );\n  const factoryText = `createMockProxy<typeof ${moduleTypeImport.namespaceName}>(${sourceCode.getText(match.mockExpression as never)})`;\n  const fixes: Rule.Fix[] = [\n    fixer.replaceTextRange(match.mockFactoryNode.range, factoryText),\n  ];\n\n  if (!moduleTypeImport.isExisting) {\n    const importText = `import type * as ${moduleTypeImport.namespaceName} from ${JSON.stringify(match.moduleSpecifier)};`;\n    const insertionRange = getImportInsertionRange(sourceCode);\n\n    fixes.push(\n      insertionRange === void 0\n        ? fixer.insertTextBeforeRange([0, 0], `${importText}\\n\\n`)\n        : fixer.insertTextAfterRange(insertionRange, `\\n${importText}`),\n    );\n  }\n\n  return fixes;\n}\n\n/**\n * Collects declaration identifiers from top-level declarations.\n * @param declaration Declaration node.\n * @param names Output name set.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction collectDeclarationNames(\n  declaration: NamedDeclaration,\n  names: Set<string>,\n): void {\n  if (\n    declaration.type === AST_NODE_TYPES.FunctionDeclaration ||\n    declaration.type === AST_NODE_TYPES.ClassDeclaration\n  ) {\n    if (declaration.id !== null) {\n      names.add(declaration.id.name);\n    }\n    return;\n  }\n\n  if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {\n    for (const variableDeclaration of declaration.declarations) {\n      collectPatternNames(variableDeclaration.id, names);\n    }\n    return;\n  }\n\n  if (\n    declaration.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||\n    declaration.type === AST_NODE_TYPES.TSInterfaceDeclaration ||\n    declaration.type === AST_NODE_TYPES.TSEnumDeclaration\n  ) {\n    names.add(declaration.id.name);\n    return;\n  }\n\n  if (declaration.id.type === AST_NODE_TYPES.Identifier) {\n    names.add(declaration.id.name);\n  }\n}\n\n/**\n * Collects identifiers from a binding pattern.\n * @param pattern Binding pattern.\n * @param names Output name set.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction collectPatternNames(pattern: TSESTree.Node, names: Set<string>): void {\n  if (pattern.type === AST_NODE_TYPES.Identifier) {\n    names.add(pattern.name);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.AssignmentPattern) {\n    collectPatternNames(pattern.left, names);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.RestElement) {\n    collectPatternNames(pattern.argument, names);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.ArrayPattern) {\n    for (const element of pattern.elements) {\n      if (element !== null) {\n        collectPatternNames(element, names);\n      }\n    }\n  }\n\n  if (pattern.type === AST_NODE_TYPES.ObjectPattern) {\n    for (const property of pattern.properties) {\n      if (property.type === AST_NODE_TYPES.Property) {\n        collectPatternNames(property.value, names);\n      }\n\n      if (property.type === AST_NODE_TYPES.RestElement) {\n        collectPatternNames(property.argument, names);\n      }\n    }\n  }\n}\n\n/**\n * Collects top-level binding names to avoid collisions with inserted imports.\n * @param statements Program statements.\n * @returns All top-level names in the file.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction collectTopLevelNames(statements: readonly unknown[]): Set<string> {\n  const names = new Set<string>();\n\n  for (const statement of statements as TSESTree.ProgramStatement[]) {\n    if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n      for (const specifier of statement.specifiers) {\n        names.add(specifier.local.name);\n      }\n      continue;\n    }\n\n    if (statement.type === AST_NODE_TYPES.ExportNamedDeclaration) {\n      if (\n        statement.declaration !== null &&\n        isNamedDeclaration(statement.declaration)\n      ) {\n        collectDeclarationNames(statement.declaration, names);\n      }\n      continue;\n    }\n\n    if (statement.type === AST_NODE_TYPES.ExportDefaultDeclaration) {\n      if (isNamedDeclaration(statement.declaration)) {\n        collectDeclarationNames(statement.declaration, names);\n      }\n      continue;\n    }\n\n    if (isNamedDeclaration(statement)) {\n      collectDeclarationNames(statement, names);\n    }\n  }\n\n  return names;\n}\n\n/**\n * Creates a namespace import name from a module specifier.\n * @param moduleSpecifier Module path.\n * @returns PascalCase namespace name.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction createNamespaceName(moduleSpecifier: string): string {\n  const baseName =\n    moduleSpecifier\n      .split(\"/\")\n      .findLast((segment) => segment.length > 0 && segment !== \".\")\n      ?.replace(/\\.[^./\\\\]+$/, \"\") ?? \"Module\";\n\n  const pascalName = baseName\n    .replaceAll(/[^\\dA-Za-z]+/g, \" \")\n    .split(\" \")\n    .filter((segment) => segment.length > 0)\n    .map((segment) => segment.slice(0, 1).toUpperCase() + segment.slice(1))\n    .join(\"\");\n\n  return pascalName.endsWith(moduleTypeSuffix)\n    ? pascalName\n    : `${pascalName}${moduleTypeSuffix}`;\n}\n\n/**\n * Returns the casted expression only when the factory is safe to autofix.\n * @param node Factory expression to inspect.\n * @returns Cast-free expression when the factory can be safely replaced.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getAutofixableMockExpression(\n  node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression,\n): TSESTree.Expression | undefined {\n  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {\n    if (node.async || node.params.length > 0) {\n      return void 0;\n    }\n\n    if (node.body.type === AST_NODE_TYPES.BlockStatement) {\n      return getAutofixableReturnedCastedExpression(node.body.body);\n    }\n\n    return getCastedExpression(node.body);\n  }\n\n  if (node.async || node.generator || node.params.length > 0) {\n    return void 0;\n  }\n\n  return getAutofixableReturnedCastedExpression(node.body.body);\n}\n\n/**\n * Finds a casted return value from a single-return factory body.\n * @param statements Function body statements.\n * @returns Returned expression when the factory has exactly one return statement.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getAutofixableReturnedCastedExpression(\n  statements: TSESTree.Statement[],\n): TSESTree.Expression | undefined {\n  if (statements.length !== 1) {\n    return void 0;\n  }\n\n  const [statement] = statements as [TSESTree.ReturnStatement];\n  if (statement.argument === null) {\n    return void 0;\n  }\n\n  return getCastedExpression(statement.argument);\n}\n\n/**\n * Returns the inner expression if the input is a cast expression.\n * @param expression Expression to inspect.\n * @returns Inner expression when the input contains a cast.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getCastedExpression(\n  expression: TSESTree.Expression,\n): TSESTree.Expression | undefined {\n  if (expression.type === AST_NODE_TYPES.TSAsExpression) {\n    return stripCastExpressions(expression.expression);\n  }\n\n  if (expression.type === AST_NODE_TYPES.TSTypeAssertion) {\n    const innerExpression = expression.expression;\n    return stripCastExpressions(innerExpression);\n  }\n\n  return void 0;\n}\n\n/**\n * Returns the partial mock expression after removing a cast wrapper.\n * @param node Factory expression to inspect.\n * @returns Cast-free expression when the factory is unsafe.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getCastedMockExpression(\n  node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression,\n): TSESTree.Expression | undefined {\n  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {\n    if (node.body.type === AST_NODE_TYPES.BlockStatement) {\n      return getReturnedCastedExpression(node.body.body);\n    }\n\n    return getCastedExpression(node.body);\n  }\n\n  return getReturnedCastedExpression(node.body.body);\n}\n\n/**\n * Returns the range after the final import declaration.\n * @param sourceCode Source code to inspect.\n * @returns Range of the last import statement when present.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getImportInsertionRange(\n  sourceCode: SourceCodeLike,\n): [number, number] | undefined {\n  let lastImportRange: [number, number] | undefined;\n\n  for (const statement of sourceCode.ast.body as unknown as {\n    /** Statement range when provided by parser options. */\n    range?: [number, number];\n\n    /** Top-level statement node type. */\n    type: TSESTree.ProgramStatement[\"type\"];\n  }[]) {\n    if (\n      statement.type === AST_NODE_TYPES.ImportDeclaration &&\n      statement.range !== void 0\n    ) {\n      lastImportRange = statement.range;\n    }\n  }\n\n  return lastImportRange;\n}\n\n/**\n * Collects the most appropriate mock-factory match from a `CallExpression`.\n * @param node Call expression to inspect.\n * @returns Unsafe mock factory details when the factory uses a cast.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getMockFactoryMatch(\n  node: TSESTree.CallExpression,\n): MockFactoryMatch | undefined {\n  if (!isVitestMockCall(node) || node.arguments.length < 2) {\n    return void 0;\n  }\n\n  const [mockSpecifierNode, mockFactoryNode] = node.arguments as [\n    TSESTree.CallExpressionArgument,\n    TSESTree.CallExpressionArgument,\n    ...TSESTree.CallExpressionArgument[],\n  ];\n\n  if (\n    mockSpecifierNode.type === AST_NODE_TYPES.SpreadElement ||\n    mockFactoryNode.type === AST_NODE_TYPES.SpreadElement\n  ) {\n    return void 0;\n  }\n\n  if (\n    mockFactoryNode.type !== AST_NODE_TYPES.ArrowFunctionExpression &&\n    mockFactoryNode.type !== AST_NODE_TYPES.FunctionExpression\n  ) {\n    return void 0;\n  }\n\n  const moduleSpecifier = getModuleSpecifier(mockSpecifierNode);\n  if (moduleSpecifier === void 0) {\n    return void 0;\n  }\n\n  const mockExpression = getCastedMockExpression(mockFactoryNode);\n  if (mockExpression === void 0) {\n    return void 0;\n  }\n\n  const autofixableExpression = getAutofixableMockExpression(mockFactoryNode);\n\n  return {\n    canAutofix: autofixableExpression !== void 0,\n    mockExpression: autofixableExpression ?? mockExpression,\n    mockFactoryNode,\n    mockSpecifierNode,\n    moduleSpecifier,\n    node,\n  };\n}\n\n/**\n * Extracts a string module specifier from the first mock argument.\n * @param node First mock argument.\n * @returns Module specifier when statically known.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getModuleSpecifier(\n  node: NonSpreadCallExpressionArgument,\n): string | undefined {\n  if (node.type === AST_NODE_TYPES.Literal && typeof node.value === \"string\") {\n    return node.value;\n  }\n\n  if (\n    node.type === AST_NODE_TYPES.ImportExpression &&\n    node.source.type === AST_NODE_TYPES.Literal &&\n    typeof node.source.value === \"string\"\n  ) {\n    return node.source.value;\n  }\n\n  return void 0;\n}\n\n/**\n * Finds the casted return value inside a function body.\n * @param statements Function body statements.\n * @returns Returned expression when it is casted.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction getReturnedCastedExpression(\n  statements: TSESTree.Statement[],\n): TSESTree.Expression | undefined {\n  for (const statement of statements) {\n    if (statement.type !== AST_NODE_TYPES.ReturnStatement) {\n      continue;\n    }\n\n    return statement.argument === null\n      ? void 0\n      : getCastedExpression(statement.argument);\n  }\n\n  return void 0;\n}\n\n/**\n * Checks whether a node is a declaration that introduces top-level names.\n * @param node Node to inspect.\n * @returns True when the node is a supported declaration.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction isNamedDeclaration(\n  node:\n    | TSESTree.ExportDefaultDeclaration[\"declaration\"]\n    | TSESTree.ProgramStatement,\n): node is NamedDeclaration {\n  return (\n    node.type === AST_NODE_TYPES.FunctionDeclaration ||\n    node.type === AST_NODE_TYPES.ClassDeclaration ||\n    node.type === AST_NODE_TYPES.VariableDeclaration ||\n    node.type === AST_NODE_TYPES.TSTypeAliasDeclaration ||\n    node.type === AST_NODE_TYPES.TSInterfaceDeclaration ||\n    node.type === AST_NODE_TYPES.TSEnumDeclaration ||\n    node.type === AST_NODE_TYPES.TSModuleDeclaration\n  );\n}\n\n/**\n * Checks whether a call targets `vi.mock` or `vi.doMock`.\n * @param node Call expression to inspect.\n * @returns True when the callee is a supported Vitest mock method.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction isVitestMockCall(node: TSESTree.CallExpression): boolean {\n  if (\n    node.callee.type !== AST_NODE_TYPES.MemberExpression ||\n    node.callee.object.type !== AST_NODE_TYPES.Identifier ||\n    node.callee.object.name !== \"vi\" ||\n    node.callee.property.type !== AST_NODE_TYPES.Identifier\n  ) {\n    return false;\n  }\n\n  return supportedMockNames.has(node.callee.property.name);\n}\n\n/**\n * Resolves the namespace import to use for `typeof Namespace`.\n * @param sourceCode Source code for import inspection.\n * @param moduleSpecifier Module path being mocked.\n * @returns Existing or generated namespace import details.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction resolveModuleTypeImport(\n  sourceCode: SourceCodeLike,\n  moduleSpecifier: string,\n): ModuleTypeImport {\n  const statements = sourceCode.ast.body;\n  const preferredName = createNamespaceName(moduleSpecifier);\n\n  for (const statement of statements as TSESTree.ProgramStatement[]) {\n    if (\n      statement.type !== AST_NODE_TYPES.ImportDeclaration ||\n      statement.source.value !== moduleSpecifier\n    ) {\n      continue;\n    }\n\n    for (const specifier of statement.specifiers) {\n      if (specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {\n        return { isExisting: true, namespaceName: specifier.local.name };\n      }\n    }\n  }\n\n  const usedNames = collectTopLevelNames(statements);\n  let namespaceName = preferredName;\n  let suffix = 1;\n\n  while (usedNames.has(namespaceName)) {\n    namespaceName = `${preferredName}${suffix.toFixed(0)}`;\n    suffix += 1;\n  }\n\n  return { isExisting: false, namespaceName };\n}\n\n/**\n * Removes nested cast wrappers from an expression.\n * @param expression Expression to normalize.\n * @returns Expression without any surrounding casts.\n * @example\n * ```ts\n * // Internal helper for no-unsafe-vitest-mock-factory-cast.\n * ```\n */\nfunction stripCastExpressions(\n  expression: TSESTree.Expression,\n): TSESTree.Expression {\n  if (expression.type === AST_NODE_TYPES.TSAsExpression) {\n    return stripCastExpressions(expression.expression);\n  }\n\n  if (expression.type === AST_NODE_TYPES.TSTypeAssertion) {\n    return stripCastExpressions(expression.expression);\n  }\n\n  return expression;\n}\n\nexport { noUnsafeVitestMockFactoryCastRule };\n"]}

package/dist/infrastructure/codeperfect-plugin.d.ts

@@ -10,6 +10,7 @@ declare const codeperfectRules: {
     readonly "no-interface-member-docs": Rule.RuleModule;
     readonly "no-multiple-declarators": Rule.RuleModule;
     readonly "no-reexports-outside-barrels": Rule.RuleModule;
+    readonly "no-unsafe-vitest-mock-factory-cast": Rule.RuleModule;
     readonly "no-unused-exports": Rule.RuleModule;
     readonly "prefer-interface-types": Rule.RuleModule;
     readonly "prefer-vi-mocked-import": Rule.RuleModule;
@@ -34,6 +35,7 @@ declare const codeperfectPlugin: {
         readonly "no-interface-member-docs": Rule.RuleModule;
         readonly "no-multiple-declarators": Rule.RuleModule;
         readonly "no-reexports-outside-barrels": Rule.RuleModule;
+        readonly "no-unsafe-vitest-mock-factory-cast": Rule.RuleModule;
         readonly "no-unused-exports": Rule.RuleModule;
         readonly "prefer-interface-types": Rule.RuleModule;
         readonly "prefer-vi-mocked-import": Rule.RuleModule;

package/dist/infrastructure/codeperfect-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codeperfect-plugin.d.ts","sourceRoot":"","sources":["../../src/infrastructure/codeperfect-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsB3C,mDAAmD;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;CAkB8B,CAAC;AAErD,oDAAoD;AACpD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;CAKkC,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"codeperfect-plugin.d.ts","sourceRoot":"","sources":["../../src/infrastructure/codeperfect-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,IAAI,EAAE,MAAM,QAAQ,CAAC;AAuB3C,mDAAmD;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;CAmB8B,CAAC;AAErD,oDAAoD;AACpD,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;CAKkC,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/infrastructure/codeperfect-plugin.js

@@ -1,4 +1,4 @@
-import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../application/index.js";
+import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../application/index.js";
 /** Rule registry exposed by the package plugin. */
 const codeperfectRules = {
     "assert-actual-expected-names": assertActualExpectedNamesRule,
@@ -10,6 +10,7 @@ const codeperfectRules = {
     "no-interface-member-docs": noInterfaceMemberDocumentationRule,
     "no-multiple-declarators": noMultipleDeclaratorsRule,
     "no-reexports-outside-barrels": noReexportsOutsideBarrelsRule,
+    "no-unsafe-vitest-mock-factory-cast": noUnsafeVitestMockFactoryCastRule,
     "no-unused-exports": noUnusedExportsRule,
     "prefer-interface-types": preferInterfaceTypesRule,
     "prefer-vi-mocked-import": preferViMockedImportRule,
@@ -27,4 +28,4 @@ const codeperfectPlugin = {
     rules: codeperfectRules,
 };
 export { codeperfectPlugin, codeperfectRules };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/infrastructure/presets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,gEAAgE;AAChE,KAAK,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;AA6GlE,oDAAoD;AACpD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,sDAAsD;AACtD,QAAA,MAAM,YAAY,mBAAsC,CAAC;AAEzD,sCAAsC;AACtC,QAAA,MAAM,IAAI,mBAA8B,CAAC;AAEzC,+CAA+C;AAC/C,QAAA,MAAM,aAAa,mBAAuC,CAAC;AAE3D,yCAAyC;AACzC,QAAA,MAAM,OAAO,mBAAiC,CAAC;AAE/C,sDAAsD;AACtD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIrC,gEAAgE;AAChE,KAAK,iBAAiB,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,CAAC;AA+GlE,oDAAoD;AACpD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,sDAAsD;AACtD,QAAA,MAAM,YAAY,mBAAsC,CAAC;AAEzD,sCAAsC;AACtC,QAAA,MAAM,IAAI,mBAA8B,CAAC;AAEzC,+CAA+C;AAC/C,QAAA,MAAM,aAAa,mBAAuC,CAAC;AAE3D,yCAAyC;AACzC,QAAA,MAAM,OAAO,mBAAiC,CAAC;AAE/C,sDAAsD;AACtD,QAAA,MAAM,GAAG,mBAA6B,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;AAChE,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/infrastructure/presets.js

@@ -27,6 +27,7 @@ const aaaRuleNames = [
 const testingRuleNames = [
     "assert-actual-expected-names",
     "enforce-aaa-structure",
+    "no-unsafe-vitest-mock-factory-cast",
     "prefer-vi-mocked-import",
     "require-act-result-capture",
     "require-test-companion",
@@ -44,6 +45,7 @@ const allRuleNames = [
     "no-multiple-declarators",
     "no-reexports-outside-barrels",
     "no-unused-exports",
+    "no-unsafe-vitest-mock-factory-cast",
     "prefer-interface-types",
     "prefer-vi-mocked-import",
     "require-act-result-capture",
@@ -94,4 +96,4 @@ const testing = createPreset(testingRuleNames);
 /** Preset that enables AAA-specific testing rules. */
 const aaa = createPreset(aaaRuleNames);
 export { aaa, all, architecture, core, documentation, testing };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"presets.js","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAgB3E,uDAAuD;AACvD,MAAM,qBAAqB,GAAG;IAC5B,2BAA2B;IAC3B,yBAAyB;IACzB,0BAA0B;IAC1B,6BAA6B;IAC7B,mBAAmB;IACnB,8BAA8B;CACmB,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,aAAa,GAAG;IACpB,yBAAyB;IACzB,wBAAwB;CACyB,CAAC;AAEpD,wDAAwD;AACxD,MAAM,sBAAsB,GAAG;IAC7B,0BAA0B;IAC1B,0BAA0B;IAC1B,mBAAmB;CAC8B,CAAC;AAEpD,sDAAsD;AACtD,MAAM,YAAY,GAAG;IACnB,uBAAuB;CAC0B,CAAC;AAEpD,0DAA0D;AAC1D,MAAM,gBAAgB,GAAG;IACvB,8BAA8B;IAC9B,uBAAuB;IACvB,yBAAyB;IACzB,4BAA4B;IAC5B,wBAAwB;IACxB,sBAAsB;CAC2B,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,YAAY,GAAG;IACnB,8BAA8B;IAC9B,2BAA2B;IAC3B,yBAAyB;IACzB,uBAAuB;IACvB,0BAA0B;IAC1B,6BAA6B;IAC7B,0BAA0B;IAC1B,yBAAyB;IACzB,8BAA8B;IAC9B,mBAAmB;IACnB,wBAAwB;IACxB,yBAAyB;IACzB,4BAA4B;IAC5B,0BAA0B;IAC1B,wBAAwB;IACxB,sBAAsB;IACtB,mBAAmB;CAC8B,CAAC;AAEpD;;;;;;;;GAQG;AACH,SAAS,YAAY,CACnB,SAAyC;IAEzC,OAAO;QACL,OAAO,EAAE;YACP,WAAW,EAAE,iBAAiB;SAC/B;QACD,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC;KAC9B,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAClB,SAAyC;IAEzC,OAAO,MAAM,CAAC,WAAW,CACvB,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,eAAe,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC,CAClE,CAAC;AACJ,CAAC;AAED,oDAAoD;AACpD,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEvC,sDAAsD;AACtD,MAAM,YAAY,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAEzD,sCAAsC;AACtC,MAAM,IAAI,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAEzC,+CAA+C;AAC/C,MAAM,aAAa,GAAG,YAAY,CAAC,sBAAsB,CAAC,CAAC;AAE3D,yCAAyC;AACzC,MAAM,OAAO,GAAG,YAAY,CAAC,gBAAgB,CAAC,CAAC;AAE/C,sDAAsD;AACtD,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport { codeperfectPlugin, codeperfectRules } from \"./codeperfect-plugin\";\n\n/** Represents a ready-to-use preset exported by the package. */\ntype CodeperfectPreset = Pick<Linter.Config, \"plugins\" | \"rules\">;\n\n/** Represents the enabled rule entries inside a preset. */\ntype CodeperfectRuleEntries = Partial<\n  Record<CodeperfectRuleKey, Linter.RuleEntry>\n>;\n\n/** Namespaces a package-owned rule under the `codeperfect/` prefix. */\ntype CodeperfectRuleKey = `codeperfect/${CodeperfectRuleName}`;\n\n/** Enumerates the package-owned rule names. */\ntype CodeperfectRuleName = keyof typeof codeperfectRules;\n\n/** Rule names grouped into the architecture preset. */\nconst architectureRuleNames = [\n  \"barrel-files-exports-only\",\n  \"consistent-barrel-files\",\n  \"no-import-export-aliases\",\n  \"no-import-export-extensions\",\n  \"no-unused-exports\",\n  \"no-reexports-outside-barrels\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the core preset. */\nconst coreRuleNames = [\n  \"no-multiple-declarators\",\n  \"prefer-interface-types\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the documentation preset. */\nconst documentationRuleNames = [\n  \"no-interface-member-docs\",\n  \"require-example-language\",\n  \"single-line-jsdoc\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the AAA-focused preset. */\nconst aaaRuleNames = [\n  \"enforce-aaa-structure\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the broader testing preset. */\nconst testingRuleNames = [\n  \"assert-actual-expected-names\",\n  \"enforce-aaa-structure\",\n  \"prefer-vi-mocked-import\",\n  \"require-act-result-capture\",\n  \"require-test-companion\",\n  \"single-act-statement\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names used by the all-rules preset. */\nconst allRuleNames = [\n  \"assert-actual-expected-names\",\n  \"barrel-files-exports-only\",\n  \"consistent-barrel-files\",\n  \"enforce-aaa-structure\",\n  \"no-import-export-aliases\",\n  \"no-import-export-extensions\",\n  \"no-interface-member-docs\",\n  \"no-multiple-declarators\",\n  \"no-reexports-outside-barrels\",\n  \"no-unused-exports\",\n  \"prefer-interface-types\",\n  \"prefer-vi-mocked-import\",\n  \"require-act-result-capture\",\n  \"require-example-language\",\n  \"require-test-companion\",\n  \"single-act-statement\",\n  \"single-line-jsdoc\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/**\n * Creates a preset for the provided rule names.\n * @param ruleNames Rule names to enable.\n * @returns ESLint preset containing the package plugin and enabled rules.\n * @example\n * ```typescript\n * const preset = createPreset([\"no-multiple-declarators\"]);\n * ```\n */\nfunction createPreset(\n  ruleNames: readonly CodeperfectRuleName[],\n): CodeperfectPreset {\n  return {\n    plugins: {\n      codeperfect: codeperfectPlugin,\n    },\n    rules: createRules(ruleNames),\n  };\n}\n\n/**\n * Creates the rule entry map for a preset.\n * @param ruleNames Rule names to enable.\n * @returns Rule entry map keyed by `codeperfect/` rule name.\n * @example\n * ```typescript\n * const rules = createRules([\"prefer-interface-types\"]);\n * ```\n */\nfunction createRules(\n  ruleNames: readonly CodeperfectRuleName[],\n): CodeperfectRuleEntries {\n  return Object.fromEntries(\n    ruleNames.map((ruleName) => [`codeperfect/${ruleName}`, \"error\"]),\n  );\n}\n\n/** Preset that enables every package-owned rule. */\nconst all = createPreset(allRuleNames);\n\n/** Preset that enables architecture-focused rules. */\nconst architecture = createPreset(architectureRuleNames);\n\n/** Preset that enables core rules. */\nconst core = createPreset(coreRuleNames);\n\n/** Preset that enables documentation rules. */\nconst documentation = createPreset(documentationRuleNames);\n\n/** Preset that enables testing rules. */\nconst testing = createPreset(testingRuleNames);\n\n/** Preset that enables AAA-specific testing rules. */\nconst aaa = createPreset(aaaRuleNames);\n\nexport { aaa, all, architecture, core, documentation, testing };\nexport type { CodeperfectPreset };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"presets.js","sourceRoot":"","sources":["../../src/infrastructure/presets.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAgB3E,uDAAuD;AACvD,MAAM,qBAAqB,GAAG;IAC5B,2BAA2B;IAC3B,yBAAyB;IACzB,0BAA0B;IAC1B,6BAA6B;IAC7B,mBAAmB;IACnB,8BAA8B;CACmB,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,aAAa,GAAG;IACpB,yBAAyB;IACzB,wBAAwB;CACyB,CAAC;AAEpD,wDAAwD;AACxD,MAAM,sBAAsB,GAAG;IAC7B,0BAA0B;IAC1B,0BAA0B;IAC1B,mBAAmB;CAC8B,CAAC;AAEpD,sDAAsD;AACtD,MAAM,YAAY,GAAG;IACnB,uBAAuB;CAC0B,CAAC;AAEpD,0DAA0D;AAC1D,MAAM,gBAAgB,GAAG;IACvB,8BAA8B;IAC9B,uBAAuB;IACvB,oCAAoC;IACpC,yBAAyB;IACzB,4BAA4B;IAC5B,wBAAwB;IACxB,sBAAsB;CAC2B,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,YAAY,GAAG;IACnB,8BAA8B;IAC9B,2BAA2B;IAC3B,yBAAyB;IACzB,uBAAuB;IACvB,0BAA0B;IAC1B,6BAA6B;IAC7B,0BAA0B;IAC1B,yBAAyB;IACzB,8BAA8B;IAC9B,mBAAmB;IACnB,oCAAoC;IACpC,wBAAwB;IACxB,yBAAyB;IACzB,4BAA4B;IAC5B,0BAA0B;IAC1B,wBAAwB;IACxB,sBAAsB;IACtB,mBAAmB;CAC8B,CAAC;AAEpD;;;;;;;;GAQG;AACH,SAAS,YAAY,CACnB,SAAyC;IAEzC,OAAO;QACL,OAAO,EAAE;YACP,WAAW,EAAE,iBAAiB;SAC/B;QACD,KAAK,EAAE,WAAW,CAAC,SAAS,CAAC;KAC9B,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAClB,SAAyC;IAEzC,OAAO,MAAM,CAAC,WAAW,CACvB,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,eAAe,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC,CAClE,CAAC;AACJ,CAAC;AAED,oDAAoD;AACpD,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEvC,sDAAsD;AACtD,MAAM,YAAY,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAC;AAEzD,sCAAsC;AACtC,MAAM,IAAI,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAEzC,+CAA+C;AAC/C,MAAM,aAAa,GAAG,YAAY,CAAC,sBAAsB,CAAC,CAAC;AAE3D,yCAAyC;AACzC,MAAM,OAAO,GAAG,YAAY,CAAC,gBAAgB,CAAC,CAAC;AAE/C,sDAAsD;AACtD,MAAM,GAAG,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC","sourcesContent":["import type { Linter } from \"eslint\";\n\nimport { codeperfectPlugin, codeperfectRules } from \"./codeperfect-plugin\";\n\n/** Represents a ready-to-use preset exported by the package. */\ntype CodeperfectPreset = Pick<Linter.Config, \"plugins\" | \"rules\">;\n\n/** Represents the enabled rule entries inside a preset. */\ntype CodeperfectRuleEntries = Partial<\n  Record<CodeperfectRuleKey, Linter.RuleEntry>\n>;\n\n/** Namespaces a package-owned rule under the `codeperfect/` prefix. */\ntype CodeperfectRuleKey = `codeperfect/${CodeperfectRuleName}`;\n\n/** Enumerates the package-owned rule names. */\ntype CodeperfectRuleName = keyof typeof codeperfectRules;\n\n/** Rule names grouped into the architecture preset. */\nconst architectureRuleNames = [\n  \"barrel-files-exports-only\",\n  \"consistent-barrel-files\",\n  \"no-import-export-aliases\",\n  \"no-import-export-extensions\",\n  \"no-unused-exports\",\n  \"no-reexports-outside-barrels\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the core preset. */\nconst coreRuleNames = [\n  \"no-multiple-declarators\",\n  \"prefer-interface-types\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the documentation preset. */\nconst documentationRuleNames = [\n  \"no-interface-member-docs\",\n  \"require-example-language\",\n  \"single-line-jsdoc\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the AAA-focused preset. */\nconst aaaRuleNames = [\n  \"enforce-aaa-structure\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names grouped into the broader testing preset. */\nconst testingRuleNames = [\n  \"assert-actual-expected-names\",\n  \"enforce-aaa-structure\",\n  \"no-unsafe-vitest-mock-factory-cast\",\n  \"prefer-vi-mocked-import\",\n  \"require-act-result-capture\",\n  \"require-test-companion\",\n  \"single-act-statement\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/** Rule names used by the all-rules preset. */\nconst allRuleNames = [\n  \"assert-actual-expected-names\",\n  \"barrel-files-exports-only\",\n  \"consistent-barrel-files\",\n  \"enforce-aaa-structure\",\n  \"no-import-export-aliases\",\n  \"no-import-export-extensions\",\n  \"no-interface-member-docs\",\n  \"no-multiple-declarators\",\n  \"no-reexports-outside-barrels\",\n  \"no-unused-exports\",\n  \"no-unsafe-vitest-mock-factory-cast\",\n  \"prefer-interface-types\",\n  \"prefer-vi-mocked-import\",\n  \"require-act-result-capture\",\n  \"require-example-language\",\n  \"require-test-companion\",\n  \"single-act-statement\",\n  \"single-line-jsdoc\",\n] as const satisfies readonly CodeperfectRuleName[];\n\n/**\n * Creates a preset for the provided rule names.\n * @param ruleNames Rule names to enable.\n * @returns ESLint preset containing the package plugin and enabled rules.\n * @example\n * ```typescript\n * const preset = createPreset([\"no-multiple-declarators\"]);\n * ```\n */\nfunction createPreset(\n  ruleNames: readonly CodeperfectRuleName[],\n): CodeperfectPreset {\n  return {\n    plugins: {\n      codeperfect: codeperfectPlugin,\n    },\n    rules: createRules(ruleNames),\n  };\n}\n\n/**\n * Creates the rule entry map for a preset.\n * @param ruleNames Rule names to enable.\n * @returns Rule entry map keyed by `codeperfect/` rule name.\n * @example\n * ```typescript\n * const rules = createRules([\"prefer-interface-types\"]);\n * ```\n */\nfunction createRules(\n  ruleNames: readonly CodeperfectRuleName[],\n): CodeperfectRuleEntries {\n  return Object.fromEntries(\n    ruleNames.map((ruleName) => [`codeperfect/${ruleName}`, \"error\"]),\n  );\n}\n\n/** Preset that enables every package-owned rule. */\nconst all = createPreset(allRuleNames);\n\n/** Preset that enables architecture-focused rules. */\nconst architecture = createPreset(architectureRuleNames);\n\n/** Preset that enables core rules. */\nconst core = createPreset(coreRuleNames);\n\n/** Preset that enables documentation rules. */\nconst documentation = createPreset(documentationRuleNames);\n\n/** Preset that enables testing rules. */\nconst testing = createPreset(testingRuleNames);\n\n/** Preset that enables AAA-specific testing rules. */\nconst aaa = createPreset(aaaRuleNames);\n\nexport { aaa, all, architecture, core, documentation, testing };\nexport type { CodeperfectPreset };\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeperfect/eslint-plugin",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Custom ESLint rules for TypeScript repositories",
   "keywords": [
     "eslint",
@@ -34,56 +34,59 @@
     "dist"
   ],
   "scripts": {
-    "\n# --------------- SCM --------------- #": "",
+    "\n# ---------------- GENERAL  ---------------- #": "",
+    "postinstall": "patch-package",
+    "\n# ------------------ SCM  ------------------ #": "",
     "commit": "npx --yes git-cz",
     "prepare": "husky",
-    "\n# --------------- BUILDING --------------- #": "",
+    "\n# ---------------- BUILDING ---------------- #": "",
     "build": "npm run clean && npm run compile && npm run resolve-paths",
     "clean": "npx --yes rimraf dist",
-    "compile": "tsc --build --force ./tsconfig.build.json",
+    "\n    • ---------- compilation  ---------- •": "",
     "pack": "npm pack --pack-destination dist",
+    "compile": "tsc --build --force ./tsconfig.build.json",
     "resolve-paths": "tsc-alias --project ./tsconfig.build.json --resolve-full-paths",
-    "\n# --------------- LINTING --------------- #": "",
-    "\t• --------------- checking --------------- •": "",
+    "\n# ---------------- LINTING  ---------------- #": "",
+    "\n    • ------------ checking ------------ •": "",
     "eslint": "npx --yes eslint --max-warnings=0",
     "lint": "npm run lint:run",
     "lint:run": "npm run prettier && npm run eslint",
-    "lint:staged": "npx --yes tsx scripts/lint-staged.ts",
     "prettier": "npx --yes prettier --ignore-unknown --check .",
-    "\n\t• --------------- fixing --------------- •": "",
+    "\n    • ------------- fixing ------------- •": "",
     "eslint:fix": "npm run check:rules && npm run eslint -- --fix",
     "lint:fix": "npm run prettier:write && npm run eslint:fix",
+    "lint:staged": "npx --yes tsx scripts/lint-staged.ts",
     "prettier:write": "npm run prettier -- --write",
-    "\n\t• --------------- helpers --------------- •": "",
+    "\n    • ------------ helpers  ------------ •": "",
     "check:rules": "npx --yes eslint-config-prettier eslint.config.ts",
     "eslint:inspect": "npx --yes @eslint/config-inspector",
-    "\n# --------------- TESTING --------------- #": "",
+    "\n# ---------------- TESTING  ---------------- #": "",
+    "e2e": "npx --yes vitest run --config vitest.config.e2e.ts",
+    "mutation": "npx --yes stryker run",
+    "test:all": "npm run test --if-present && npm run e2e --if-present && npm run mutation --if-present",
     "typecheck": "tsc --noEmit",
     "typecheck:spec": "tsc -p tsconfig.spec.json --noEmit",
-    "validate": "npm run lint && npm run typecheck && npm run typecheck:spec && npm run test && npm run build && npm run pack",
-    "\n\t• --------------- unit --------------- •": "",
-    "mutation": "npx --yes stryker run",
-    "tdd": "npx --yes vitest run --watch --silent=true --coverage.enabled=false",
-    "test": "npm run unit && npm run mutation",
-    "unit": "npx --yes vitest run",
-    "\n# --------------- DOCS --------------- #": "",
-    "docs:api": "npx --yes typedoc --options typedoc.json",
-    "docs:clean": "npx --yes rimraf docs/api",
+    "validate": "npm run lint && npm run typecheck && npm run typecheck:spec && npm run test:all && npm run build --if-present && npm run pack --if-present",
+    "\n    • -------------- unit -------------- •": "",
+    "test": "npx --yes vitest run",
+    "tdd": "npm run test -- --watch --silent=true --coverage.enabled=false",
+    "\n# ------------------ DOCS ------------------ #": "",
     "docs": "npm run docs:clean && npm run docs:api",
-    "postinstall": "patch-package"
+    "docs:api": "npx --yes typedoc --options typedoc.json",
+    "docs:clean": "npx --yes rimraf docs/api"
   },
   "dependencies": {
     "@typescript-eslint/utils": "^8.60.0",
     "minimatch": "^10.2.5"
   },
   "peerDependencies": {
-    "eslint": ">=10.4.0"
+    "eslint": ">=10.4.1"
   },
   "devDependencies": {
     "@codeperfect/commitlint-config-emoji": "^1.0.0",
-    "@codeperfect/eslint-config": "^1.10.0",
-    "@commitlint/cz-commitlint": "^21.0.1",
-    "@eslint-community/eslint-plugin-eslint-comments": "^4.7.1",
+    "@codeperfect/eslint-config": "^1.11.0",
+    "@commitlint/cz-commitlint": "^21.0.2",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.7.2",
     "@eslint/js": "^10.0.1",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/typescript-checker": "^9.6.1",
@@ -94,9 +97,9 @@
     "@types/signale": "^1.4.7",
     "@typescript-eslint/rule-tester": "^8.60.0",
     "@vitest/coverage-v8": "^4.1.7",
-    "@vitest/eslint-plugin": "^1.6.18",
+    "@vitest/eslint-plugin": "^1.6.19",
     "chalk": "^5.6.2",
-    "eslint": "^10.4.0",
+    "eslint": "^10.4.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-boundaries": "^6.0.2",
@@ -106,13 +109,13 @@
     "eslint-plugin-jest": "^29.15.2",
     "eslint-plugin-jsdoc": "^63.0.0",
     "eslint-plugin-perfectionist": "^5.9.0",
-    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-rxjs-x": "^1.0.2",
     "eslint-plugin-unicorn": "^64.0.0",
     "globals": "^17.6.0",
     "husky": "^9.1.7",
     "jiti": "^2.7.0",
-    "lint-staged": "^17.0.5",
+    "lint-staged": "^17.0.7",
     "lodash-es": "^4.18.1",
     "patch-package": "^8.0.1",
     "prettier": "^3.8.3",

package/dist/.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts","../src/application/custom-rules.ts","../src/application/index.ts","../src/domain/custom-rule-documentation.ts","../src/domain/index.ts","../src/domain/architecture/index.ts","../src/domain/architecture/consistent-barrel-files/barrel-file-utilities.ts","../src/domain/architecture/consistent-barrel-files/consistent-barrel-files-listeners.ts","../src/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.ts","../src/domain/architecture/consistent-barrel-files/exports-only-rule.ts","../src/domain/architecture/consistent-barrel-files/index.ts","../src/domain/architecture/consistent-barrel-files/no-import-export-aliases-rule.ts","../src/domain/architecture/consistent-barrel-files/no-import-export-extensions-rule.ts","../src/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-rule.ts","../src/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts","../src/domain/architecture/consistent-barrel-files/rule.ts","../src/domain/architecture/consistent-barrel-files/types.ts","../src/domain/architecture/no-unused-exports/index.ts","../src/domain/architecture/no-unused-exports/no-unused-exports-options.ts","../src/domain/architecture/no-unused-exports/no-unused-exports-utilities.ts","../src/domain/architecture/no-unused-exports/rule.ts","../src/domain/architecture/no-unused-exports/types.ts","../src/domain/core/index.ts","../src/domain/core/no-multiple-declarators/index.ts","../src/domain/core/no-multiple-declarators/rule.ts","../src/domain/core/no-multiple-declarators/types.ts","../src/domain/core/prefer-interface-types/index.ts","../src/domain/core/prefer-interface-types/rule.ts","../src/domain/docs/index.ts","../src/domain/docs/no-interface-member-docs/comment-utilities.ts","../src/domain/docs/no-interface-member-docs/index.ts","../src/domain/docs/no-interface-member-docs/parameter-tags.ts","../src/domain/docs/no-interface-member-docs/parameter-utilities.ts","../src/domain/docs/no-interface-member-docs/rule.ts","../src/domain/docs/no-interface-member-docs/types.ts","../src/domain/docs/require-example-language/empty-fence-fixes.ts","../src/domain/docs/require-example-language/example-utilities.ts","../src/domain/docs/require-example-language/examples.ts","../src/domain/docs/require-example-language/fixes.ts","../src/domain/docs/require-example-language/index.ts","../src/domain/docs/require-example-language/reporting.ts","../src/domain/docs/require-example-language/rule.ts","../src/domain/docs/require-example-language/types.ts","../src/domain/docs/single-line-jsdoc/index.ts","../src/domain/docs/single-line-jsdoc/rule.ts","../src/domain/docs/single-line-jsdoc/single-line-jsdoc-content.ts","../src/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts","../src/domain/testing/index.ts","../src/domain/testing/aaa/analyzer.analysis.helpers.ts","../src/domain/testing/aaa/analyzer.analysis.ts","../src/domain/testing/aaa/analyzer.assertions.helpers.ts","../src/domain/testing/aaa/analyzer.assertions.operands.ts","../src/domain/testing/aaa/analyzer.assertions.ts","../src/domain/testing/aaa/analyzer.classification.helpers.ts","../src/domain/testing/aaa/analyzer.classification.traversal.ts","../src/domain/testing/aaa/analyzer.classification.ts","../src/domain/testing/aaa/analyzer.super.helpers.ts","../src/domain/testing/aaa/analyzer.super.ts","../src/domain/testing/aaa/index.ts","../src/domain/testing/aaa/types.ts","../src/domain/testing/assert-actual-expected-names/index.ts","../src/domain/testing/assert-actual-expected-names/rule.ts","../src/domain/testing/enforce-aaa-phase-purity/index.ts","../src/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.ts","../src/domain/testing/enforce-aaa-phase-purity/phase-purity-identifiers.ts","../src/domain/testing/enforce-aaa-phase-purity/phase-purity-reporting.ts","../src/domain/testing/enforce-aaa-structure/index.ts","../src/domain/testing/enforce-aaa-structure/missing-section-fixes.ts","../src/domain/testing/enforce-aaa-structure/rule.ts","../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts","../src/domain/testing/prefer-vi-mocked-import/fix-import-updates.ts","../src/domain/testing/prefer-vi-mocked-import/fix-imports.ts","../src/domain/testing/prefer-vi-mocked-import/fix.ts","../src/domain/testing/prefer-vi-mocked-import/index.ts","../src/domain/testing/prefer-vi-mocked-import/match-bindings.ts","../src/domain/testing/prefer-vi-mocked-import/match-declarations.ts","../src/domain/testing/prefer-vi-mocked-import/match-helpers.ts","../src/domain/testing/prefer-vi-mocked-import/match-imports.ts","../src/domain/testing/prefer-vi-mocked-import/match-rewrites.ts","../src/domain/testing/prefer-vi-mocked-import/match-walk.ts","../src/domain/testing/prefer-vi-mocked-import/match.ts","../src/domain/testing/prefer-vi-mocked-import/rule.ts","../src/domain/testing/prefer-vi-mocked-import/types.ts","../src/domain/testing/require-act-result-capture/index.ts","../src/domain/testing/require-act-result-capture/rule.ts","../src/domain/testing/require-test-companion/index.ts","../src/domain/testing/require-test-companion/require-test-companion-listeners.ts","../src/domain/testing/require-test-companion/require-test-companion-options.ts","../src/domain/testing/require-test-companion/rule.ts","../src/domain/testing/require-test-companion/types.ts","../src/domain/testing/single-act-statement/index.ts","../src/domain/testing/single-act-statement/rule.ts","../src/infrastructure/codeperfect-plugin.ts","../src/infrastructure/index.ts","../src/infrastructure/presets.ts"],"version":"6.0.3"}