@codeperfect/eslint-plugin 2.5.0 → 2.6.0

package/README.md

@@ -100,8 +100,10 @@ void preferInterfaceTypesRule;
 - `codeperfect/no-import-export-aliases`
 - `codeperfect/no-import-export-extensions`
 - `codeperfect/no-interface-member-docs`
+- `codeperfect/no-multiple-declarators`
 - `codeperfect/no-reexports-outside-barrels`
 - `codeperfect/no-unused-exports`
+- `codeperfect/no-useless-delegation`
 - `codeperfect/prefer-interface-types`
 - `codeperfect/prefer-vi-mocked-import`
 - `codeperfect/require-act-result-capture`

package/dist/application/custom-rules.d.ts

@@ -34,6 +34,9 @@ declare const customRules: readonly [{
 }, {
     readonly rule: Rule.RuleModule;
     readonly ruleName: "no-multiple-declarators";
+}, {
+    readonly rule: Rule.RuleModule;
+    readonly ruleName: "no-useless-delegation";
 }, {
     readonly rule: Rule.RuleModule;
     readonly ruleName: "prefer-interface-types";

package/dist/application/custom-rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom-rules.d.ts","sourceRoot":"","sources":["../../src/application/custom-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsBnC,+DAA+D;AAC/D,UAAU,eAAe;IACvB,kCAAkC;IAClC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC;IAEtB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,mEAAmE;AACnE,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqE8B,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"custom-rules.d.ts","sourceRoot":"","sources":["../../src/application/custom-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAuBnC,+DAA+D;AAC/D,UAAU,eAAe;IACvB,kCAAkC;IAClC,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC;IAEtB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,mEAAmE;AACnE,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyE8B,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC"}

package/dist/application/custom-rules.js

@@ -1,4 +1,4 @@
-import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
+import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, noUselessDelegationRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
 /** Source-of-truth registry for all package-owned custom rules. */
 const customRules = [
     {
@@ -37,6 +37,10 @@ const customRules = [
         rule: noMultipleDeclaratorsRule,
         ruleName: "no-multiple-declarators",
     },
+    {
+        rule: noUselessDelegationRule,
+        ruleName: "no-useless-delegation",
+    },
     {
         rule: preferInterfaceTypesRule,
         ruleName: "prefer-interface-types",
@@ -71,4 +75,4 @@ const customRules = [
     },
 ];
 export { customRules };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLXJ1bGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcGxpY2F0aW9uL2N1c3RvbS1ydWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQ0wsNkJBQTZCLEVBQzdCLDBCQUEwQixFQUMxQix5QkFBeUIsRUFDekIsdUJBQXVCLEVBQ3ZCLHlCQUF5QixFQUN6Qiw0QkFBNEIsRUFDNUIsa0NBQWtDLEVBQ2xDLHlCQUF5QixFQUN6Qiw2QkFBNkIsRUFDN0IsbUJBQW1CLEVBQ25CLHdCQUF3QixFQUN4Qix3QkFBd0IsRUFDeEIsMkJBQTJCLEVBQzNCLDBCQUEwQixFQUMxQix3QkFBd0IsRUFDeEIsc0JBQXNCLEVBQ3RCLG1CQUFtQixHQUNwQixNQUFNLFdBQVcsQ0FBQztBQVduQixtRUFBbUU7QUFDbkUsTUFBTSxXQUFXLEdBQUc7SUFDbEI7UUFDRSxJQUFJLEVBQUUsNkJBQTZCO1FBQ25DLFFBQVEsRUFBRSw4QkFBOEI7S0FDekM7SUFDRDtRQUNFLElBQUksRUFBRSwwQkFBMEI7UUFDaEMsUUFBUSxFQUFFLDJCQUEyQjtLQUN0QztJQUNEO1FBQ0UsSUFBSSxFQUFFLHlCQUF5QjtRQUMvQixRQUFRLEVBQUUseUJBQXlCO0tBQ3BDO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsdUJBQXVCO1FBQzdCLFFBQVEsRUFBRSx1QkFBdUI7S0FDbEM7SUFDRDtRQUNFLElBQUksRUFBRSx5QkFBeUI7UUFDL0IsUUFBUSxFQUFFLDBCQUEwQjtLQUNyQztJQUNEO1FBQ0UsSUFBSSxFQUFFLDRCQUE0QjtRQUNsQyxRQUFRLEVBQUUsNkJBQTZCO0tBQ3hDO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsbUJBQW1CO1FBQ3pCLFFBQVEsRUFBRSxtQkFBbUI7S0FDOUI7SUFDRDtRQUNFLElBQUksRUFBRSw2QkFBNkI7UUFDbkMsUUFBUSxFQUFFLDhCQUE4QjtLQUN6QztJQUNEO1FBQ0UsSUFBSSxFQUFFLHlCQUF5QjtRQUMvQixRQUFRLEVBQUUseUJBQXlCO0tBQ3BDO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsd0JBQXdCO1FBQzlCLFFBQVEsRUFBRSx3QkFBd0I7S0FDbkM7SUFDRDtRQUNFLElBQUksRUFBRSxrQ0FBa0M7UUFDeEMsUUFBUSxFQUFFLDBCQUEwQjtLQUNyQztJQUNEO1FBQ0UsSUFBSSxFQUFFLDBCQUEwQjtRQUNoQyxRQUFRLEVBQUUsMEJBQTBCO0tBQ3JDO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsbUJBQW1CO1FBQ3pCLFFBQVEsRUFBRSxtQkFBbUI7S0FDOUI7SUFDRDtRQUNFLElBQUksRUFBRSx3QkFBd0I7UUFDOUIsUUFBUSxFQUFFLHlCQUF5QjtLQUNwQztJQUNEO1FBQ0UsSUFBSSxFQUFFLDJCQUEyQjtRQUNqQyxRQUFRLEVBQUUsNEJBQTRCO0tBQ3ZDO0lBQ0Q7UUFDRSxJQUFJLEVBQUUsd0JBQXdCO1FBQzlCLFFBQVEsRUFBRSx3QkFBd0I7S0FDbkM7SUFDRDtRQUNFLElBQUksRUFBRSxzQkFBc0I7UUFDNUIsUUFBUSxFQUFFLHNCQUFzQjtLQUNqQztDQUM0QyxDQUFDO0FBRWhELE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUnVsZSB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHtcbiAgYXNzZXJ0QWN0dWFsRXhwZWN0ZWROYW1lc1J1bGUsXG4gIGJhcnJlbEZpbGVzRXhwb3J0c09ubHlSdWxlLFxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxuICBlbmZvcmNlQWFhU3RydWN0dXJlUnVsZSxcbiAgbm9JbXBvcnRFeHBvcnRBbGlhc2VzUnVsZSxcbiAgbm9JbXBvcnRFeHBvcnRFeHRlbnNpb25zUnVsZSxcbiAgbm9JbnRlcmZhY2VNZW1iZXJEb2N1bWVudGF0aW9uUnVsZSxcbiAgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSxcbiAgbm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc1J1bGUsXG4gIG5vVW51c2VkRXhwb3J0c1J1bGUsXG4gIHByZWZlckludGVyZmFjZVR5cGVzUnVsZSxcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXG59IGZyb20gXCIuLi9kb21haW5cIjtcblxuLyoqIEludGVybmFsIHJlZ2lzdHJ5IGVudHJ5IGZvciBhIHBhY2thZ2Utb3duZWQgY3VzdG9tIHJ1bGUuICovXG5pbnRlcmZhY2UgQ3VzdG9tUnVsZUVudHJ5IHtcbiAgLyoqIEVTTGludCBydWxlIGltcGxlbWVudGF0aW9uLiAqL1xuICBydWxlOiBSdWxlLlJ1bGVNb2R1bGU7XG5cbiAgLyoqIEVTTGludCBydWxlIG5hbWUgd2l0aG91dCB0aGUgcGx1Z2luIHByZWZpeC4gKi9cbiAgcnVsZU5hbWU6IHN0cmluZztcbn1cblxuLyoqIFNvdXJjZS1vZi10cnV0aCByZWdpc3RyeSBmb3IgYWxsIHBhY2thZ2Utb3duZWQgY3VzdG9tIHJ1bGVzLiAqL1xuY29uc3QgY3VzdG9tUnVsZXMgPSBbXG4gIHtcbiAgICBydWxlOiBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSxcbiAgICBydWxlTmFtZTogXCJhc3NlcnQtYWN0dWFsLWV4cGVjdGVkLW5hbWVzXCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgICBydWxlTmFtZTogXCJiYXJyZWwtZmlsZXMtZXhwb3J0cy1vbmx5XCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxuICAgIHJ1bGVOYW1lOiBcImNvbnNpc3RlbnQtYmFycmVsLWZpbGVzXCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiBlbmZvcmNlQWFhU3RydWN0dXJlUnVsZSxcbiAgICBydWxlTmFtZTogXCJlbmZvcmNlLWFhYS1zdHJ1Y3R1cmVcIixcbiAgfSxcbiAge1xuICAgIHJ1bGU6IG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gICAgcnVsZU5hbWU6IFwibm8taW1wb3J0LWV4cG9ydC1hbGlhc2VzXCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiBub0ltcG9ydEV4cG9ydEV4dGVuc2lvbnNSdWxlLFxuICAgIHJ1bGVOYW1lOiBcIm5vLWltcG9ydC1leHBvcnQtZXh0ZW5zaW9uc1wiLFxuICB9LFxuICB7XG4gICAgcnVsZTogbm9VbnVzZWRFeHBvcnRzUnVsZSxcbiAgICBydWxlTmFtZTogXCJuby11bnVzZWQtZXhwb3J0c1wiLFxuICB9LFxuICB7XG4gICAgcnVsZTogbm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc1J1bGUsXG4gICAgcnVsZU5hbWU6IFwibm8tcmVleHBvcnRzLW91dHNpZGUtYmFycmVsc1wiLFxuICB9LFxuICB7XG4gICAgcnVsZTogbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSxcbiAgICBydWxlTmFtZTogXCJuby1tdWx0aXBsZS1kZWNsYXJhdG9yc1wiLFxuICB9LFxuICB7XG4gICAgcnVsZTogcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlLFxuICAgIHJ1bGVOYW1lOiBcInByZWZlci1pbnRlcmZhY2UtdHlwZXNcIixcbiAgfSxcbiAge1xuICAgIHJ1bGU6IG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gICAgcnVsZU5hbWU6IFwibm8taW50ZXJmYWNlLW1lbWJlci1kb2NzXCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSxcbiAgICBydWxlTmFtZTogXCJyZXF1aXJlLWV4YW1wbGUtbGFuZ3VhZ2VcIixcbiAgfSxcbiAge1xuICAgIHJ1bGU6IHNpbmdsZUxpbmVKc2RvY1J1bGUsXG4gICAgcnVsZU5hbWU6IFwic2luZ2xlLWxpbmUtanNkb2NcIixcbiAgfSxcbiAge1xuICAgIHJ1bGU6IHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcbiAgICBydWxlTmFtZTogXCJwcmVmZXItdmktbW9ja2VkLWltcG9ydFwiLFxuICB9LFxuICB7XG4gICAgcnVsZTogcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxuICAgIHJ1bGVOYW1lOiBcInJlcXVpcmUtYWN0LXJlc3VsdC1jYXB0dXJlXCIsXG4gIH0sXG4gIHtcbiAgICBydWxlOiByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gICAgcnVsZU5hbWU6IFwicmVxdWlyZS10ZXN0LWNvbXBhbmlvblwiLFxuICB9LFxuICB7XG4gICAgcnVsZTogc2luZ2xlQWN0U3RhdGVtZW50UnVsZSxcbiAgICBydWxlTmFtZTogXCJzaW5nbGUtYWN0LXN0YXRlbWVudFwiLFxuICB9LFxuXSBhcyBjb25zdCBzYXRpc2ZpZXMgcmVhZG9ubHkgQ3VzdG9tUnVsZUVudHJ5W107XG5cbmV4cG9ydCB7IGN1c3RvbVJ1bGVzIH07XG5leHBvcnQgdHlwZSB7IEN1c3RvbVJ1bGVFbnRyeSB9O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/application/index.d.ts

@@ -1,4 +1,4 @@
-export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, noUselessDelegationRule, 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,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"}
+{"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,uBAAuB,EACvB,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, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, noUselessDelegationRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../domain/index.js";
 export { customRules } from "./custom-rules.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwbGljYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLGlDQUFpQyxFQUNqQyxtQkFBbUIsRUFDbkIsd0JBQXdCLEVBQ3hCLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0IsMEJBQTBCLEVBQzFCLHdCQUF3QixFQUN4QixzQkFBc0IsRUFDdEIsbUJBQW1CLEdBQ3BCLE1BQU0sV0FBVyxDQUFDO0FBQ25CLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gIG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxuICBub1Vuc2FmZVZpdGVzdE1vY2tGYWN0b3J5Q2FzdFJ1bGUsXG4gIG5vVW51c2VkRXhwb3J0c1J1bGUsXG4gIHByZWZlckludGVyZmFjZVR5cGVzUnVsZSxcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXG59IGZyb20gXCIuLi9kb21haW5cIjtcbmV4cG9ydCB7IGN1c3RvbVJ1bGVzIH0gZnJvbSBcIi4vY3VzdG9tLXJ1bGVzXCI7XG5leHBvcnQgdHlwZSB7IEN1c3RvbVJ1bGVFbnRyeSB9IGZyb20gXCIuL2N1c3RvbS1ydWxlc1wiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBwbGljYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLGlDQUFpQyxFQUNqQyxtQkFBbUIsRUFDbkIsdUJBQXVCLEVBQ3ZCLHdCQUF3QixFQUN4Qix3QkFBd0IsRUFDeEIsMkJBQTJCLEVBQzNCLDBCQUEwQixFQUMxQix3QkFBd0IsRUFDeEIsc0JBQXNCLEVBQ3RCLG1CQUFtQixHQUNwQixNQUFNLFdBQVcsQ0FBQztBQUNuQixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSxcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXG4gIGNvbnNpc3RlbnRCYXJyZWxGaWxlc1J1bGUsXG4gIGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlLFxuICBub0ltcG9ydEV4cG9ydEFsaWFzZXNSdWxlLFxuICBub0ltcG9ydEV4cG9ydEV4dGVuc2lvbnNSdWxlLFxuICBub0ludGVyZmFjZU1lbWJlckRvY3VtZW50YXRpb25SdWxlLFxuICBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlLFxuICBub1JlZXhwb3J0c091dHNpZGVCYXJyZWxzUnVsZSxcbiAgbm9VbnNhZmVWaXRlc3RNb2NrRmFjdG9yeUNhc3RSdWxlLFxuICBub1VudXNlZEV4cG9ydHNSdWxlLFxuICBub1VzZWxlc3NEZWxlZ2F0aW9uUnVsZSxcbiAgcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlLFxuICBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUsXG4gIHJlcXVpcmVBY3RSZXN1bHRDYXB0dXJlUnVsZSxcbiAgcmVxdWlyZUV4YW1wbGVMYW5ndWFnZVJ1bGUsXG4gIHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSxcbiAgc2luZ2xlQWN0U3RhdGVtZW50UnVsZSxcbiAgc2luZ2xlTGluZUpzZG9jUnVsZSxcbn0gZnJvbSBcIi4uL2RvbWFpblwiO1xuZXhwb3J0IHsgY3VzdG9tUnVsZXMgfSBmcm9tIFwiLi9jdXN0b20tcnVsZXNcIjtcbmV4cG9ydCB0eXBlIHsgQ3VzdG9tUnVsZUVudHJ5IH0gZnJvbSBcIi4vY3VzdG9tLXJ1bGVzXCI7XG4iXX0=

package/dist/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.d.ts

@@ -19,16 +19,6 @@ interface ConsistentBarrelFilesState {
  * ```
  */
 declare const getOptions: (options: readonly unknown[]) => ConsistentBarrelFilesState;
-/**
- * Determines whether a filename is eligible for linting.
- * @param filename Filename to inspect.
- * @returns True when the filename is a lintable module file.
- * @example
- * ```typescript
- * const lintable = isLintableFilename(`${cwd()}/src/index.ts`);
- * ```
- */
-declare const isLintableFilename: (filename: string) => boolean;
 /**
  * Determines whether the rule should lint a file.
  * @param filename Filename to inspect.
@@ -40,6 +30,6 @@ declare const isLintableFilename: (filename: string) => boolean;
  * ```
  */
 declare const shouldLintFile: (filename: string, allowedNames: string[]) => boolean;
-export { getOptions, isLintableFilename, shouldLintFile };
+export { getOptions, shouldLintFile };
 export type { ConsistentBarrelFilesState };
 //# sourceMappingURL=consistent-barrel-files-options.d.ts.map

package/dist/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consistent-barrel-files-options.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.ts"],"names":[],"mappings":"AASA,qCAAqC;AACrC,UAAU,0BAA0B;IAClC,gCAAgC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IAExB,mCAAmC;IACnC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE7B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,0BAcF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,UAAU,MAAM,KAAG,OACf,CAAC;AAkBjC;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAAI,UAAU,MAAM,EAAE,cAAc,MAAM,EAAE,KAAG,OAMlE,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,CAAC;AAC1D,YAAY,EAAE,0BAA0B,EAAE,CAAC"}
+{"version":3,"file":"consistent-barrel-files-options.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.ts"],"names":[],"mappings":"AASA,qCAAqC;AACrC,UAAU,0BAA0B;IAClC,gCAAgC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IAExB,mCAAmC;IACnC,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE7B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,0BAcF,CAAC;AAkBF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAAI,UAAU,MAAM,EAAE,cAAc,MAAM,EAAE,KAAG,OAMlE,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,CAAC;AACtC,YAAY,EAAE,0BAA0B,EAAE,CAAC"}

package/dist/domain/architecture/consistent-barrel-files/consistent-barrel-files-options.js

@@ -23,16 +23,6 @@ const getOptions = (options) => {
         enforce,
     };
 };
-/**
- * Determines whether a filename is eligible for linting.
- * @param filename Filename to inspect.
- * @returns True when the filename is a lintable module file.
- * @example
- * ```typescript
- * const lintable = isLintableFilename(`${cwd()}/src/index.ts`);
- * ```
- */
-const isLintableFilename = (filename) => isLintableModuleFile(filename);
 /**
  * Checks whether a path is nested inside a src directory.
  * @param filename Filename to inspect.
@@ -58,9 +48,9 @@ const isInSourceDirectory = (filename) => {
  * ```
  */
 const shouldLintFile = (filename, allowedNames) => {
-    return (isLintableFilename(filename) &&
+    return (isLintableModuleFile(filename) &&
         isInSourceDirectory(filename) &&
         allowedNames.length > 0);
 };
-export { getOptions, isLintableFilename, shouldLintFile };
-//# sourceMappingURL=data:application/json;base64,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
+export { getOptions, shouldLintFile };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-reexports-outside-barrels-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAUlC,qCAAqC;AACrC,UAAU,8BAA8B;IACtC,sCAAsC;IACtC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B,yCAAyC;IACzC,qBAAqB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,8BAUF,CAAC;AAcF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAEF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,YAAY,GAChB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAEF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GAAI,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KAAG,GAAG,CAAC,MAAM,CAYnE,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,iBAAiB,GACrB,WAAW,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EACtC,eAAe,GAAG,CAAC,MAAM,CAAC,KACzB,OAcF,CAAC;AAEF,OAAO,EACL,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,CAAC"}
+{"version":3,"file":"no-reexports-outside-barrels-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAUlC,qCAAqC;AACrC,UAAU,8BAA8B;IACtC,sCAAsC;IACtC,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B,yCAAyC;IACzC,qBAAqB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GACd,SAAS,SAAS,OAAO,EAAE,KAC1B,8BAUF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAIF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,YAAY,GAChB,UAAU,MAAM,EAChB,SAAS,8BAA8B,KACtC,OAEF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GAAI,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KAAG,GAAG,CAAC,MAAM,CAYnE,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,iBAAiB,GACrB,WAAW,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EACtC,eAAe,GAAG,CAAC,MAAM,CAAC,KACzB,OAcF,CAAC;AAEF,OAAO,EACL,oBAAoB,EACpB,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,cAAc,GACf,CAAC"}

package/dist/domain/architecture/consistent-barrel-files/no-reexports-outside-barrels-utilities.js

@@ -16,16 +16,6 @@ const getOptions = (options) => {
         allowedBarrelNamesSet: new Set(allowedBarrelNames),
     };
 };
-/**
- * Checks whether the filename is valid for linting.
- * @param filename Absolute filename.
- * @returns True when the filename is lintable.
- * @example
- * ```typescript
- * const ok = isLintableFilename("/repo/src/index.ts");
- * ```
- */
-const isLintableFilename = (filename) => isLintableModuleFile(filename);
 /**
  * Determines whether a file should be linted by this rule.
  * @param filename Absolute filename.
@@ -37,7 +27,7 @@ const isLintableFilename = (filename) => isLintableModuleFile(filename);
  * ```
  */
 const shouldLintFile = (filename, options) => {
-    return isLintableFilename(filename) && options.allowedBarrelNames.length > 0;
+    return (isLintableModuleFile(filename) && options.allowedBarrelNames.length > 0);
 };
 /**
  * Determines whether a file is a barrel file under the rule options.
@@ -92,4 +82,4 @@ const hasImportedExport = (statement, importedNames) => {
         importedNames.has(specifier.local.name));
 };
 export { collectImportedNames, getOptions, hasImportedExport, isBarrelFile, shouldLintFile, };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/architecture/consistent-barrel-files/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAQnC;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA6CrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/consistent-barrel-files/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAMnC;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA6CrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/architecture/consistent-barrel-files/rule.js

@@ -1,5 +1,6 @@
+import { isLintableModuleFile } from "./barrel-file-utilities.js";
 import { buildListenerForFile } from "./consistent-barrel-files-listeners.js";
-import { getOptions, isLintableFilename, } from "./consistent-barrel-files-options.js";
+import { getOptions } from "./consistent-barrel-files-options.js";
 /**
  * ESLint rule requiring consistent barrel file usage by folder.
  * @example
@@ -10,7 +11,7 @@ import { getOptions, isLintableFilename, } from "./consistent-barrel-files-optio
 const consistentBarrelFilesRule = {
     create(context) {
         const { filename, options } = context;
-        if (!isLintableFilename(filename)) {
+        if (!isLintableModuleFile(filename)) {
             return {};
         }
         return buildListenerForFile(context, filename, getOptions(options));
@@ -47,4 +48,4 @@ const consistentBarrelFilesRule = {
     },
 };
 export { consistentBarrelFilesRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,8 @@
 import path from "node:path";
+import { collectExportedElements } from "./no-unused-exports-declaration-utilities.js";
+import { getTypeScriptProgram } from "./no-unused-exports-identifier-utilities.js";
 import { DEFAULT_PUBLIC_API_FILES, DEFAULT_TEST_FILE_PATTERNS, getOptions, isLintableFilename, isPublicApiFile, } from "./no-unused-exports-options.js";
-import { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, } from "./no-unused-exports-utilities.js";
+import { classifyExportUsage, collectCrossFileUsages, } from "./no-unused-exports-usage-utilities.js";
 /** ESLint rule flagging exports unused in production code. */
 const noUnusedExportsRule = {
     create(context) {
@@ -79,4 +81,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/core/index.d.ts

@@ -1,3 +1,4 @@
 export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { noUselessDelegationRule } from "./no-useless-delegation/index.js";
 export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/domain/core/index.js

@@ -1,3 +1,4 @@
 export { noMultipleDeclaratorsRule } from "./no-multiple-declarators/index.js";
+export { noUselessDelegationRule } from "./no-useless-delegation/index.js";
 export { preferInterfaceTypesRule } from "./prefer-interface-types/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnNcIjtcbmV4cG9ydCB7IHByZWZlckludGVyZmFjZVR5cGVzUnVsZSB9IGZyb20gXCIuL3ByZWZlci1pbnRlcmZhY2UtdHlwZXNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDdEUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnNcIjtcbmV4cG9ydCB7IG5vVXNlbGVzc0RlbGVnYXRpb25SdWxlIH0gZnJvbSBcIi4vbm8tdXNlbGVzcy1kZWxlZ2F0aW9uXCI7XG5leHBvcnQgeyBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUgfSBmcm9tIFwiLi9wcmVmZXItaW50ZXJmYWNlLXR5cGVzXCI7XG4iXX0=

package/dist/domain/core/no-useless-delegation/index.d.ts

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

package/dist/domain/core/no-useless-delegation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/core/no-useless-delegation/index.js

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

package/dist/domain/core/no-useless-delegation/rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule implementation for functions that only forward their arguments. */
+declare const noUselessDelegationRule: Rule.RuleModule;
+export { noUselessDelegationRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/domain/core/no-useless-delegation/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA0OnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/domain/core/no-useless-delegation/rule.js

@@ -0,0 +1,200 @@
+/**
+ * Resolves a node value when it is an ESTree node.
+ * @param value Candidate AST value.
+ * @returns The value as an ESTree node when it has a type discriminator.
+ * @example
+ * ```typescript
+ * const node = asNode({ type: "Identifier" });
+ * ```
+ */
+const asNode = (value) => typeof value === "object" && value !== null && "type" in value
+    ? value
+    : void 0;
+/**
+ * Resolves a node array while rejecting malformed AST data.
+ * @param value Candidate AST value.
+ * @returns AST nodes when every array item is a node.
+ * @example
+ * ```typescript
+ * const nodes = asNodeArray([{ type: "Identifier" }]);
+ * ```
+ */
+const asNodeArray = (value) => Array.isArray(value) && value.every((item) => asNode(item) !== void 0)
+    ? value
+    : void 0;
+/**
+ * Reads an identifier name from a node.
+ * @param node Candidate identifier node.
+ * @returns Identifier name when the node is an identifier.
+ * @example
+ * ```typescript
+ * const name = getIdentifierName({ name: "run", type: "Identifier" });
+ * ```
+ */
+const getIdentifierName = (node) => node?.type === "Identifier" && typeof node["name"] === "string"
+    ? node["name"]
+    : void 0;
+/**
+ * Gets the called expression from a function with one return statement.
+ * @param functionNode Function node to inspect.
+ * @returns The directly returned call expression when present.
+ * @example
+ * ```typescript
+ * const call = getDelegatedCall(functionNode);
+ * ```
+ */
+const getDelegatedCall = (functionNode) => {
+    if (functionNode.async === true || functionNode.generator === true) {
+        return void 0;
+    }
+    const body = asNode(functionNode["body"]);
+    if (body === void 0) {
+        return void 0;
+    }
+    if (body.type === "CallExpression") {
+        return body;
+    }
+    const statements = asNodeArray(body["body"]);
+    if (body.type !== "BlockStatement" || statements?.length !== 1) {
+        return void 0;
+    }
+    const returnStatement = statements[0];
+    return returnStatement?.type === "ReturnStatement"
+        ? asNode(returnStatement["argument"])
+        : void 0;
+};
+/**
+ * Gets parameter names and whether each parameter is a rest parameter.
+ * @param functionNode Function node to inspect.
+ * @returns Named parameter metadata when every parameter is supported.
+ * @example
+ * ```typescript
+ * const parameters = getParameters(functionNode);
+ * ```
+ */
+const getParameters = (functionNode) => {
+    const parameters = asNodeArray(functionNode["params"]);
+    if (parameters === void 0) {
+        return void 0;
+    }
+    const result = [];
+    for (const parameter of parameters) {
+        const isRest = parameter.type === "RestElement";
+        const name = getIdentifierName(isRest ? asNode(parameter["argument"]) : parameter);
+        if (name === void 0) {
+            return void 0;
+        }
+        result.push({ isRest, name });
+    }
+    return result;
+};
+/**
+ * Determines whether one call argument forwards its corresponding parameter.
+ * @param argument Call argument to inspect.
+ * @param parameter Corresponding function parameter.
+ * @returns Whether the argument forwards the parameter without change.
+ * @example
+ * ```typescript
+ * const forwards = forwardsParameter(argument, parameter);
+ * ```
+ */
+const forwardsParameter = (argument, parameter) => {
+    if (parameter.isRest) {
+        return (argument.type === "SpreadElement" &&
+            getIdentifierName(asNode(argument["argument"])) === parameter.name);
+    }
+    return getIdentifierName(argument) === parameter.name;
+};
+/**
+ * Determines whether a call invokes a method on a literal value.
+ * @param callee Call target to inspect.
+ * @returns Whether the target is a member access on a literal receiver.
+ * @example
+ * ```typescript
+ * const isLiteralCall = isLiteralMemberCall(callee);
+ * ```
+ */
+const isLiteralMemberCall = (callee) => callee.type === "MemberExpression" &&
+    asNode(callee["object"])?.type === "Literal";
+/**
+ * Determines whether a function does nothing except directly call another function.
+ * @param functionNode Function node to inspect.
+ * @param functionName Declared wrapper function name.
+ * @returns Whether the function is an exact synchronous delegation.
+ * @example
+ * ```typescript
+ * const isDelegation = isUselessDelegation(functionNode, "run");
+ * ```
+ */
+const isUselessDelegation = (functionNode, functionName) => {
+    const call = getDelegatedCall(functionNode);
+    const parameters = getParameters(functionNode);
+    const arguments_ = asNodeArray(call?.["arguments"]);
+    const callee = asNode(call?.["callee"]);
+    if (call?.type !== "CallExpression" ||
+        parameters === void 0 ||
+        arguments_ === void 0 ||
+        callee === void 0 ||
+        isLiteralMemberCall(callee) ||
+        getIdentifierName(callee) === functionName ||
+        arguments_.length !== parameters.length) {
+        return false;
+    }
+    return arguments_.every((argument, index) => {
+        const parameter = parameters[index];
+        return parameter !== void 0 && forwardsParameter(argument, parameter);
+    });
+};
+/**
+ * Reports a function when it is a no-op delegation.
+ * @param context Rule execution context.
+ * @param functionNode Function node to inspect.
+ * @param nameNode Declared wrapper name node.
+ * @example
+ * ```typescript
+ * reportIfUselessDelegation(context, functionNode, nameNode);
+ * ```
+ */
+const reportIfUselessDelegation = (context, functionNode, nameNode) => {
+    const functionName = getIdentifierName(nameNode);
+    if (functionName === void 0 ||
+        !isUselessDelegation(functionNode, functionName)) {
+        return;
+    }
+    context.report({
+        messageId: "uselessDelegation",
+        node: nameNode,
+    });
+};
+/** ESLint rule implementation for functions that only forward their arguments. */
+const noUselessDelegationRule = {
+    create: (context) => ({
+        FunctionDeclaration: (node) => {
+            const functionNode = node;
+            reportIfUselessDelegation(context, functionNode, asNode(functionNode["id"]));
+        },
+        VariableDeclarator: (node) => {
+            const declarator = node;
+            const initializer = asNode(declarator["init"]);
+            if (initializer?.type !== "ArrowFunctionExpression" &&
+                initializer?.type !== "FunctionExpression") {
+                return;
+            }
+            reportIfUselessDelegation(context, initializer, asNode(declarator["id"]));
+        },
+    }),
+    meta: {
+        docs: {
+            description: "Disallow named functions that only delegate directly to another call.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-useless-delegation.md",
+        },
+        messages: {
+            uselessDelegation: "This function only delegates to another call; remove the wrapper or call the target directly.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { noUselessDelegationRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"AAsBA;;;;;;;;GAQG;AACH,MAAM,MAAM,GAAG,CAAC,KAAc,EAAoB,EAAE,CAClD,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,IAAI,KAAK;IAC5D,CAAC,CAAE,KAAc;IACjB,CAAC,CAAC,KAAK,CAAC,CAAC;AAEb;;;;;;;;GAQG;AACH,MAAM,WAAW,GAAG,CAAC,KAAc,EAAsB,EAAE,CACzD,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,KAAK,CAAC,CAAC;IACpE,CAAC,CAAE,KAAgB;IACnB,CAAC,CAAC,KAAK,CAAC,CAAC;AAEb;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CAAC,IAAsB,EAAsB,EAAE,CACvE,IAAI,EAAE,IAAI,KAAK,YAAY,IAAI,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,QAAQ;IAC7D,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;IACd,CAAC,CAAC,KAAK,CAAC,CAAC;AAEb;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAG,CAAC,YAAkB,EAAoB,EAAE;IAChE,IAAI,YAAY,CAAC,KAAK,KAAK,IAAI,IAAI,YAAY,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;QACnE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC7C,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,IAAI,UAAU,EAAE,MAAM,KAAK,CAAC,EAAE,CAAC;QAC/D,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,eAAe,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IACtC,OAAO,eAAe,EAAE,IAAI,KAAK,iBAAiB;QAChD,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC,CAAC,KAAK,CAAC,CAAC;AACb,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,aAAa,GAAG,CACpB,YAAkB,EACgB,EAAE;IACpC,MAAM,UAAU,GAAG,WAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvD,IAAI,UAAU,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,MAAM,GAAyB,EAAE,CAAC;IACxC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC;QAChD,MAAM,IAAI,GAAG,iBAAiB,CAC5B,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CACnD,CAAC;QACF,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,CAAC;QAChB,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,iBAAiB,GAAG,CACxB,QAAc,EACd,SAA6B,EACpB,EAAE;IACX,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC;QACrB,OAAO,CACL,QAAQ,CAAC,IAAI,KAAK,eAAe;YACjC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,IAAI,CACnE,CAAC;IACJ,CAAC;IAED,OAAO,iBAAiB,CAAC,QAAQ,CAAC,KAAK,SAAS,CAAC,IAAI,CAAC;AACxD,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,mBAAmB,GAAG,CAAC,MAAY,EAAW,EAAE,CACpD,MAAM,CAAC,IAAI,KAAK,kBAAkB;IAClC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,KAAK,SAAS,CAAC;AAE/C;;;;;;;;;GASG;AACH,MAAM,mBAAmB,GAAG,CAC1B,YAAkB,EAClB,YAAoB,EACX,EAAE;IACX,MAAM,IAAI,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAC5C,MAAM,UAAU,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAExC,IACE,IAAI,EAAE,IAAI,KAAK,gBAAgB;QAC/B,UAAU,KAAK,KAAK,CAAC;QACrB,UAAU,KAAK,KAAK,CAAC;QACrB,MAAM,KAAK,KAAK,CAAC;QACjB,mBAAmB,CAAC,MAAM,CAAC;QAC3B,iBAAiB,CAAC,MAAM,CAAC,KAAK,YAAY;QAC1C,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,EACvC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE;QAC1C,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QACpC,OAAO,SAAS,KAAK,KAAK,CAAC,IAAI,iBAAiB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,yBAAyB,GAAG,CAChC,OAAyB,EACzB,YAAkB,EAClB,QAA0B,EACpB,EAAE;IACR,MAAM,YAAY,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IACjD,IACE,YAAY,KAAK,KAAK,CAAC;QACvB,CAAC,mBAAmB,CAAC,YAAY,EAAE,YAAY,CAAC,EAChD,CAAC;QACD,OAAO;IACT,CAAC;IAED,OAAO,CAAC,MAAM,CAAC;QACb,SAAS,EAAE,mBAAmB;QAC9B,IAAI,EAAE,QAAgC;KACvC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,kFAAkF;AAClF,MAAM,uBAAuB,GAAoB;IAC/C,MAAM,EAAE,CAAC,OAAyB,EAAqB,EAAE,CAAC,CAAC;QACzD,mBAAmB,EAAE,CAAC,IAAe,EAAQ,EAAE;YAC7C,MAAM,YAAY,GAAG,IAAuB,CAAC;YAC7C,yBAAyB,CACvB,OAAO,EACP,YAAY,EACZ,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAC3B,CAAC;QACJ,CAAC;QACD,kBAAkB,EAAE,CAAC,IAAe,EAAQ,EAAE;YAC5C,MAAM,UAAU,GAAG,IAAuB,CAAC;YAC3C,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;YAC/C,IACE,WAAW,EAAE,IAAI,KAAK,yBAAyB;gBAC/C,WAAW,EAAE,IAAI,KAAK,oBAAoB,EAC1C,CAAC;gBACD,OAAO;YACT,CAAC;YAED,yBAAyB,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5E,CAAC;KACF,CAAC;IACF,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,WAAW,EACT,uEAAuE;YACzE,WAAW,EAAE,KAAK;YAClB,GAAG,EAAE,wFAAwF;SAC9F;QACD,QAAQ,EAAE;YACR,iBAAiB,EACf,+FAA+F;SAClG;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACnB;CACF,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\n/** One named parameter and whether it must be spread at the call site. */\ninterface DelegatedParameter {\n  /** Whether this parameter uses rest syntax. */\n  isRest: boolean;\n  /** Parameter identifier name. */\n  name: string;\n}\n\n/** Minimal ESTree node shape used to inspect pass-through functions. */\ninterface Node {\n  /** Dynamically read child nodes and parser-specific properties. */\n  [key: string]: unknown;\n  /** Whether the function is asynchronous. */\n  async?: boolean;\n  /** Whether the function is a generator. */\n  generator?: boolean;\n  /** ESTree discriminator. */\n  type: string;\n}\n\n/**\n * Resolves a node value when it is an ESTree node.\n * @param value Candidate AST value.\n * @returns The value as an ESTree node when it has a type discriminator.\n * @example\n * ```typescript\n * const node = asNode({ type: \"Identifier\" });\n * ```\n */\nconst asNode = (value: unknown): Node | undefined =>\n  typeof value === \"object\" && value !== null && \"type\" in value\n    ? (value as Node)\n    : void 0;\n\n/**\n * Resolves a node array while rejecting malformed AST data.\n * @param value Candidate AST value.\n * @returns AST nodes when every array item is a node.\n * @example\n * ```typescript\n * const nodes = asNodeArray([{ type: \"Identifier\" }]);\n * ```\n */\nconst asNodeArray = (value: unknown): Node[] | undefined =>\n  Array.isArray(value) && value.every((item) => asNode(item) !== void 0)\n    ? (value as Node[])\n    : void 0;\n\n/**\n * Reads an identifier name from a node.\n * @param node Candidate identifier node.\n * @returns Identifier name when the node is an identifier.\n * @example\n * ```typescript\n * const name = getIdentifierName({ name: \"run\", type: \"Identifier\" });\n * ```\n */\nconst getIdentifierName = (node: Node | undefined): string | undefined =>\n  node?.type === \"Identifier\" && typeof node[\"name\"] === \"string\"\n    ? node[\"name\"]\n    : void 0;\n\n/**\n * Gets the called expression from a function with one return statement.\n * @param functionNode Function node to inspect.\n * @returns The directly returned call expression when present.\n * @example\n * ```typescript\n * const call = getDelegatedCall(functionNode);\n * ```\n */\nconst getDelegatedCall = (functionNode: Node): Node | undefined => {\n  if (functionNode.async === true || functionNode.generator === true) {\n    return void 0;\n  }\n\n  const body = asNode(functionNode[\"body\"]);\n  if (body === void 0) {\n    return void 0;\n  }\n\n  if (body.type === \"CallExpression\") {\n    return body;\n  }\n\n  const statements = asNodeArray(body[\"body\"]);\n  if (body.type !== \"BlockStatement\" || statements?.length !== 1) {\n    return void 0;\n  }\n\n  const returnStatement = statements[0];\n  return returnStatement?.type === \"ReturnStatement\"\n    ? asNode(returnStatement[\"argument\"])\n    : void 0;\n};\n\n/**\n * Gets parameter names and whether each parameter is a rest parameter.\n * @param functionNode Function node to inspect.\n * @returns Named parameter metadata when every parameter is supported.\n * @example\n * ```typescript\n * const parameters = getParameters(functionNode);\n * ```\n */\nconst getParameters = (\n  functionNode: Node,\n): DelegatedParameter[] | undefined => {\n  const parameters = asNodeArray(functionNode[\"params\"]);\n  if (parameters === void 0) {\n    return void 0;\n  }\n\n  const result: DelegatedParameter[] = [];\n  for (const parameter of parameters) {\n    const isRest = parameter.type === \"RestElement\";\n    const name = getIdentifierName(\n      isRest ? asNode(parameter[\"argument\"]) : parameter,\n    );\n    if (name === void 0) {\n      return void 0;\n    }\n\n    result.push({ isRest, name });\n  }\n\n  return result;\n};\n\n/**\n * Determines whether one call argument forwards its corresponding parameter.\n * @param argument Call argument to inspect.\n * @param parameter Corresponding function parameter.\n * @returns Whether the argument forwards the parameter without change.\n * @example\n * ```typescript\n * const forwards = forwardsParameter(argument, parameter);\n * ```\n */\nconst forwardsParameter = (\n  argument: Node,\n  parameter: DelegatedParameter,\n): boolean => {\n  if (parameter.isRest) {\n    return (\n      argument.type === \"SpreadElement\" &&\n      getIdentifierName(asNode(argument[\"argument\"])) === parameter.name\n    );\n  }\n\n  return getIdentifierName(argument) === parameter.name;\n};\n\n/**\n * Determines whether a call invokes a method on a literal value.\n * @param callee Call target to inspect.\n * @returns Whether the target is a member access on a literal receiver.\n * @example\n * ```typescript\n * const isLiteralCall = isLiteralMemberCall(callee);\n * ```\n */\nconst isLiteralMemberCall = (callee: Node): boolean =>\n  callee.type === \"MemberExpression\" &&\n  asNode(callee[\"object\"])?.type === \"Literal\";\n\n/**\n * Determines whether a function does nothing except directly call another function.\n * @param functionNode Function node to inspect.\n * @param functionName Declared wrapper function name.\n * @returns Whether the function is an exact synchronous delegation.\n * @example\n * ```typescript\n * const isDelegation = isUselessDelegation(functionNode, \"run\");\n * ```\n */\nconst isUselessDelegation = (\n  functionNode: Node,\n  functionName: string,\n): boolean => {\n  const call = getDelegatedCall(functionNode);\n  const parameters = getParameters(functionNode);\n  const arguments_ = asNodeArray(call?.[\"arguments\"]);\n  const callee = asNode(call?.[\"callee\"]);\n\n  if (\n    call?.type !== \"CallExpression\" ||\n    parameters === void 0 ||\n    arguments_ === void 0 ||\n    callee === void 0 ||\n    isLiteralMemberCall(callee) ||\n    getIdentifierName(callee) === functionName ||\n    arguments_.length !== parameters.length\n  ) {\n    return false;\n  }\n\n  return arguments_.every((argument, index) => {\n    const parameter = parameters[index];\n    return parameter !== void 0 && forwardsParameter(argument, parameter);\n  });\n};\n\n/**\n * Reports a function when it is a no-op delegation.\n * @param context Rule execution context.\n * @param functionNode Function node to inspect.\n * @param nameNode Declared wrapper name node.\n * @example\n * ```typescript\n * reportIfUselessDelegation(context, functionNode, nameNode);\n * ```\n */\nconst reportIfUselessDelegation = (\n  context: Rule.RuleContext,\n  functionNode: Node,\n  nameNode: Node | undefined,\n): void => {\n  const functionName = getIdentifierName(nameNode);\n  if (\n    functionName === void 0 ||\n    !isUselessDelegation(functionNode, functionName)\n  ) {\n    return;\n  }\n\n  context.report({\n    messageId: \"uselessDelegation\",\n    node: nameNode as unknown as Rule.Node,\n  });\n};\n\n/** ESLint rule implementation for functions that only forward their arguments. */\nconst noUselessDelegationRule: Rule.RuleModule = {\n  create: (context: Rule.RuleContext): Rule.RuleListener => ({\n    FunctionDeclaration: (node: Rule.Node): void => {\n      const functionNode = node as unknown as Node;\n      reportIfUselessDelegation(\n        context,\n        functionNode,\n        asNode(functionNode[\"id\"]),\n      );\n    },\n    VariableDeclarator: (node: Rule.Node): void => {\n      const declarator = node as unknown as Node;\n      const initializer = asNode(declarator[\"init\"]);\n      if (\n        initializer?.type !== \"ArrowFunctionExpression\" &&\n        initializer?.type !== \"FunctionExpression\"\n      ) {\n        return;\n      }\n\n      reportIfUselessDelegation(context, initializer, asNode(declarator[\"id\"]));\n    },\n  }),\n  meta: {\n    docs: {\n      description:\n        \"Disallow named functions that only delegate directly to another call.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-useless-delegation.md\",\n    },\n    messages: {\n      uselessDelegation:\n        \"This function only delegates to another call; remove the wrapper or call the target directly.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { noUselessDelegationRule };\n"]}

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 { noMultipleDeclaratorsRule, noUselessDelegationRule, preferInterfaceTypesRule, } from "./core/index.js";
 export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/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,iCAAiC,EACjC,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,EACL,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,QAAQ,CAAC;AAChB,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 { noMultipleDeclaratorsRule, noUselessDelegationRule, preferInterfaceTypesRule, } from "./core/index.js";
 export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/index.js";
 export { assertActualExpectedNamesRule, enforceAaaStructureRule, noUnsafeVitestMockFactoryCastRule, preferViMockedImportRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qiw0QkFBNEIsRUFDNUIsNkJBQTZCLEVBQzdCLG1CQUFtQixHQUNwQixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUM3RSxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQixtQkFBbUIsR0FDcEIsTUFBTSxRQUFRLENBQUM7QUFDaEIsT0FBTyxFQUNMLDZCQUE2QixFQUM3Qix1QkFBdUIsRUFDdkIsaUNBQWlDLEVBQ2pDLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0Isd0JBQXdCLEVBQ3hCLHNCQUFzQixHQUN2QixNQUFNLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XHJcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXHJcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcclxuICBub0ltcG9ydEV4cG9ydEFsaWFzZXNSdWxlLFxyXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXHJcbiAgbm9SZWV4cG9ydHNPdXRzaWRlQmFycmVsc1J1bGUsXHJcbiAgbm9VbnVzZWRFeHBvcnRzUnVsZSxcclxufSBmcm9tIFwiLi9hcmNoaXRlY3R1cmVcIjtcclxuZXhwb3J0IHsgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSwgcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlIH0gZnJvbSBcIi4vY29yZVwiO1xyXG5leHBvcnQge1xyXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXHJcbiAgcmVxdWlyZUV4YW1wbGVMYW5ndWFnZVJ1bGUsXHJcbiAgc2luZ2xlTGluZUpzZG9jUnVsZSxcclxufSBmcm9tIFwiLi9kb2NzXCI7XHJcbmV4cG9ydCB7XHJcbiAgYXNzZXJ0QWN0dWFsRXhwZWN0ZWROYW1lc1J1bGUsXHJcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXHJcbiAgbm9VbnNhZmVWaXRlc3RNb2NrRmFjdG9yeUNhc3RSdWxlLFxyXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcclxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXHJcbiAgcmVxdWlyZVRlc3RDb21wYW5pb25SdWxlLFxyXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXHJcbn0gZnJvbSBcIi4vdGVzdGluZ1wiO1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qiw0QkFBNEIsRUFDNUIsNkJBQTZCLEVBQzdCLG1CQUFtQixHQUNwQixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFDTCx5QkFBeUIsRUFDekIsdUJBQXVCLEVBQ3ZCLHdCQUF3QixHQUN6QixNQUFNLFFBQVEsQ0FBQztBQUNoQixPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQixtQkFBbUIsR0FDcEIsTUFBTSxRQUFRLENBQUM7QUFDaEIsT0FBTyxFQUNMLDZCQUE2QixFQUM3Qix1QkFBdUIsRUFDdkIsaUNBQWlDLEVBQ2pDLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0Isd0JBQXdCLEVBQ3hCLHNCQUFzQixHQUN2QixNQUFNLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGJhcnJlbEZpbGVzRXhwb3J0c09ubHlSdWxlLFxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxuICBub0ltcG9ydEV4cG9ydEFsaWFzZXNSdWxlLFxuICBub0ltcG9ydEV4cG9ydEV4dGVuc2lvbnNSdWxlLFxuICBub1JlZXhwb3J0c091dHNpZGVCYXJyZWxzUnVsZSxcbiAgbm9VbnVzZWRFeHBvcnRzUnVsZSxcbn0gZnJvbSBcIi4vYXJjaGl0ZWN0dXJlXCI7XG5leHBvcnQge1xuICBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlLFxuICBub1VzZWxlc3NEZWxlZ2F0aW9uUnVsZSxcbiAgcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlLFxufSBmcm9tIFwiLi9jb3JlXCI7XG5leHBvcnQge1xuICBub0ludGVyZmFjZU1lbWJlckRvY3VtZW50YXRpb25SdWxlLFxuICByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSxcbiAgc2luZ2xlTGluZUpzZG9jUnVsZSxcbn0gZnJvbSBcIi4vZG9jc1wiO1xuZXhwb3J0IHtcbiAgYXNzZXJ0QWN0dWFsRXhwZWN0ZWROYW1lc1J1bGUsXG4gIGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlLFxuICBub1Vuc2FmZVZpdGVzdE1vY2tGYWN0b3J5Q2FzdFJ1bGUsXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcbiAgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG59IGZyb20gXCIuL3Rlc3RpbmdcIjtcbiJdfQ==

package/dist/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 "./application/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, noUselessDelegationRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
 export type { CustomRuleEntry } from "./application/index.js";
 export { aaa, all, architecture, codeperfectPlugin, core, customRules, documentation, testing, } from "./infrastructure/index.js";
 export type { CodeperfectPreset } from "./infrastructure/index.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/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,eAAe,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,GAAG,EACH,GAAG,EACH,YAAY,EACZ,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,aAAa,EACb,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/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,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,EACxB,2BAA2B,EAC3B,0BAA0B,EAC1B,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EACL,GAAG,EACH,GAAG,EACH,YAAY,EACZ,iBAAiB,EACjB,IAAI,EACJ,WAAW,EACX,aAAa,EACb,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/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 "./application/index.js";
+export { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnusedExportsRule, noUselessDelegationRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./application/index.js";
 export { aaa, all, architecture, codeperfectPlugin, core, customRules, documentation, testing, } from "./infrastructure/index.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLG1CQUFtQixFQUNuQix3QkFBd0IsRUFDeEIsd0JBQXdCLEVBQ3hCLDJCQUEyQixFQUMzQiwwQkFBMEIsRUFDMUIsd0JBQXdCLEVBQ3hCLHNCQUFzQixFQUN0QixtQkFBbUIsR0FDcEIsTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUNMLEdBQUcsRUFDSCxHQUFHLEVBQ0gsWUFBWSxFQUNaLGlCQUFpQixFQUNqQixJQUFJLEVBQ0osV0FBVyxFQUNYLGFBQWEsRUFDYixPQUFPLEdBQ1IsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcbiAgY29uc2lzdGVudEJhcnJlbEZpbGVzUnVsZSxcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXG4gIG5vSW1wb3J0RXhwb3J0QWxpYXNlc1J1bGUsXG4gIG5vSW1wb3J0RXhwb3J0RXh0ZW5zaW9uc1J1bGUsXG4gIG5vSW50ZXJmYWNlTWVtYmVyRG9jdW1lbnRhdGlvblJ1bGUsXG4gIG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUsXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxuICBub1VudXNlZEV4cG9ydHNSdWxlLFxuICBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUsXG4gIHByZWZlclZpTW9ja2VkSW1wb3J0UnVsZSxcbiAgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxuICByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSxcbiAgcmVxdWlyZVRlc3RDb21wYW5pb25SdWxlLFxuICBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlLFxuICBzaW5nbGVMaW5lSnNkb2NSdWxlLFxufSBmcm9tIFwiLi9hcHBsaWNhdGlvblwiO1xuZXhwb3J0IHR5cGUgeyBDdXN0b21SdWxlRW50cnkgfSBmcm9tIFwiLi9hcHBsaWNhdGlvblwiO1xuZXhwb3J0IHtcbiAgYWFhLFxuICBhbGwsXG4gIGFyY2hpdGVjdHVyZSxcbiAgY29kZXBlcmZlY3RQbHVnaW4sXG4gIGNvcmUsXG4gIGN1c3RvbVJ1bGVzLFxuICBkb2N1bWVudGF0aW9uLFxuICB0ZXN0aW5nLFxufSBmcm9tIFwiLi9pbmZyYXN0cnVjdHVyZVwiO1xuZXhwb3J0IHR5cGUgeyBDb2RlcGVyZmVjdFByZXNldCB9IGZyb20gXCIuL2luZnJhc3RydWN0dXJlXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLDZCQUE2QixFQUM3QiwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2Qix5QkFBeUIsRUFDekIsNEJBQTRCLEVBQzVCLGtDQUFrQyxFQUNsQyx5QkFBeUIsRUFDekIsNkJBQTZCLEVBQzdCLG1CQUFtQixFQUNuQix1QkFBdUIsRUFDdkIsd0JBQXdCLEVBQ3hCLHdCQUF3QixFQUN4QiwyQkFBMkIsRUFDM0IsMEJBQTBCLEVBQzFCLHdCQUF3QixFQUN4QixzQkFBc0IsRUFDdEIsbUJBQW1CLEdBQ3BCLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFDTCxHQUFHLEVBQ0gsR0FBRyxFQUNILFlBQVksRUFDWixpQkFBaUIsRUFDakIsSUFBSSxFQUNKLFdBQVcsRUFDWCxhQUFhLEVBQ2IsT0FBTyxHQUNSLE1BQU0sa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSxcbiAgYmFycmVsRmlsZXNFeHBvcnRzT25seVJ1bGUsXG4gIGNvbnNpc3RlbnRCYXJyZWxGaWxlc1J1bGUsXG4gIGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlLFxuICBub0ltcG9ydEV4cG9ydEFsaWFzZXNSdWxlLFxuICBub0ltcG9ydEV4cG9ydEV4dGVuc2lvbnNSdWxlLFxuICBub0ludGVyZmFjZU1lbWJlckRvY3VtZW50YXRpb25SdWxlLFxuICBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlLFxuICBub1JlZXhwb3J0c091dHNpZGVCYXJyZWxzUnVsZSxcbiAgbm9VbnVzZWRFeHBvcnRzUnVsZSxcbiAgbm9Vc2VsZXNzRGVsZWdhdGlvblJ1bGUsXG4gIHByZWZlckludGVyZmFjZVR5cGVzUnVsZSxcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxuICByZXF1aXJlQWN0UmVzdWx0Q2FwdHVyZVJ1bGUsXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxuICByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUsXG4gIHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUsXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXG59IGZyb20gXCIuL2FwcGxpY2F0aW9uXCI7XG5leHBvcnQgdHlwZSB7IEN1c3RvbVJ1bGVFbnRyeSB9IGZyb20gXCIuL2FwcGxpY2F0aW9uXCI7XG5leHBvcnQge1xuICBhYWEsXG4gIGFsbCxcbiAgYXJjaGl0ZWN0dXJlLFxuICBjb2RlcGVyZmVjdFBsdWdpbixcbiAgY29yZSxcbiAgY3VzdG9tUnVsZXMsXG4gIGRvY3VtZW50YXRpb24sXG4gIHRlc3RpbmcsXG59IGZyb20gXCIuL2luZnJhc3RydWN0dXJlXCI7XG5leHBvcnQgdHlwZSB7IENvZGVwZXJmZWN0UHJlc2V0IH0gZnJvbSBcIi4vaW5mcmFzdHJ1Y3R1cmVcIjtcbiJdfQ==

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

@@ -12,6 +12,7 @@ declare const codeperfectRules: {
     readonly "no-reexports-outside-barrels": Rule.RuleModule;
     readonly "no-unsafe-vitest-mock-factory-cast": Rule.RuleModule;
     readonly "no-unused-exports": Rule.RuleModule;
+    readonly "no-useless-delegation": Rule.RuleModule;
     readonly "prefer-interface-types": Rule.RuleModule;
     readonly "prefer-vi-mocked-import": Rule.RuleModule;
     readonly "require-act-result-capture": Rule.RuleModule;
@@ -37,6 +38,7 @@ declare const codeperfectPlugin: {
         readonly "no-reexports-outside-barrels": Rule.RuleModule;
         readonly "no-unsafe-vitest-mock-factory-cast": Rule.RuleModule;
         readonly "no-unused-exports": Rule.RuleModule;
+        readonly "no-useless-delegation": Rule.RuleModule;
         readonly "prefer-interface-types": Rule.RuleModule;
         readonly "prefer-vi-mocked-import": Rule.RuleModule;
         readonly "require-act-result-capture": 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;AAuB3C,mDAAmD;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;CAmB8B,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;AAwB3C,mDAAmD;AACnD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;CAoB8B,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, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "../application/index.js";
+import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaStructureRule, noImportExportAliasesRule, noImportExportExtensionsRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, noUnsafeVitestMockFactoryCastRule, noUnusedExportsRule, noUselessDelegationRule, 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,
@@ -12,6 +12,7 @@ const codeperfectRules = {
     "no-reexports-outside-barrels": noReexportsOutsideBarrelsRule,
     "no-unsafe-vitest-mock-factory-cast": noUnsafeVitestMockFactoryCastRule,
     "no-unused-exports": noUnusedExportsRule,
+    "no-useless-delegation": noUselessDelegationRule,
     "prefer-interface-types": preferInterfaceTypesRule,
     "prefer-vi-mocked-import": preferViMockedImportRule,
     "require-act-result-capture": requireActResultCaptureRule,
@@ -28,4 +29,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;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"}
+{"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;AAiHlE,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

@@ -11,6 +11,7 @@ const architectureRuleNames = [
 /** Rule names grouped into the core preset. */
 const coreRuleNames = [
     "no-multiple-declarators",
+    "no-useless-delegation",
     "prefer-interface-types",
 ];
 /** Rule names grouped into the documentation preset. */
@@ -43,6 +44,7 @@ const allRuleNames = [
     "no-import-export-extensions",
     "no-interface-member-docs",
     "no-multiple-declarators",
+    "no-useless-delegation",
     "no-reexports-outside-barrels",
     "no-unused-exports",
     "no-unsafe-vitest-mock-factory-cast",
@@ -96,4 +98,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,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"]}
+//# 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,uBAAuB;IACvB,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,uBAAuB;IACvB,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  \"no-useless-delegation\",\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-useless-delegation\",\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,24 +1,11 @@
 {
   "name": "@codeperfect/eslint-plugin",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Custom ESLint rules for TypeScript repositories",
-  "keywords": [
-    "eslint",
-    "eslintplugin",
-    "eslint-plugin",
-    "custom-rules",
-    "typescript",
-    "linting"
-  ],
-  "homepage": "https://github.com/parloti/eslint-plugin#readme",
-  "bugs": {
-    "url": "https://github.com/parloti/eslint-plugin/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/parloti/eslint-plugin.git"
-  },
   "license": "MIT",
+  "repository": "github:parloti/eslint-plugin",
+  "homepage": "https://github.com/parloti/eslint-plugin#readme",
+  "bugs": "https://github.com/parloti/eslint-plugin/issues",
   "author": "CodePerfect",
   "type": "module",
   "exports": {
@@ -28,17 +15,18 @@
       "default": "./dist/index.js"
     }
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "\n# ---------------- GENERAL  ---------------- #": "",
-    "postinstall": "patch-package",
+    "prepare": "patch-package && husky",
     "\n# ------------------ SCM  ------------------ #": "",
     "commit": "npx --yes git-cz",
-    "prepare": "husky",
     "\n# ---------------- BUILDING ---------------- #": "",
     "build": "npm run clean && npm run compile && npm run resolve-paths",
     "clean": "npx --yes rimraf dist",
@@ -56,7 +44,7 @@
     "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",
+    "prettier:write": "npx --yes prettier --ignore-unknown --write .",
     "\n    • ------------ helpers  ------------ •": "",
     "check:rules": "npx --yes eslint-config-prettier eslint.config.ts",
     "eslint:inspect": "npx --yes @eslint/config-inspector",
@@ -65,8 +53,7 @@
     "mutation": "npx --yes stryker run",
     "test:all": "npm run test && npm run e2e && npm run mutation",
     "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:all && npm run build --if-present && npm run pack --if-present",
+    "validate": "npm run lint && npm run typecheck && 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",
@@ -75,16 +62,24 @@
     "docs:api": "npx --yes typedoc --options typedoc.json",
     "docs:clean": "npx --yes rimraf docs/api"
   },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "custom-rules",
+    "typescript",
+    "linting"
+  ],
   "dependencies": {
-    "@typescript-eslint/utils": "^8.67.0",
+    "@typescript-eslint/utils": "^8.68.0",
     "minimatch": "^10.2.6"
   },
-  "peerDependencies": {
-    "eslint": ">=10.9.0"
-  },
   "devDependencies": {
     "@codeperfect/commitlint-config-emoji": "^1.0.0",
-    "@codeperfect/eslint-config": "^1.13.0",
+    "@codeperfect/eslint-config": "^1.14.0",
     "@commitlint/cz-commitlint": "^21.2.2",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.7.2",
     "@eslint/js": "^10.0.1",
@@ -93,29 +88,28 @@
     "@stryker-mutator/vitest-runner": "^10.0.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^26.2.0",
-    "@types/signale": "^1.4.7",
-    "@typescript-eslint/rule-tester": "^8.67.0",
+    "@types/node": "^26.4.0",
+    "@typescript-eslint/rule-tester": "^8.68.0",
     "@vitest/coverage-v8": "^4.1.11",
     "@vitest/eslint-plugin": "^1.6.27",
     "chalk": "^6.0.0",
-    "eslint": "^10.9.0",
+    "eslint": "^10.9.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-boundaries": "^7.2.0",
     "eslint-plugin-eslint-plugin": "^7.6.2",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-jasmine": "^4.2.2",
-    "eslint-plugin-jest": "^29.16.1",
+    "eslint-plugin-jest": "^29.16.5",
     "eslint-plugin-jsdoc": "^64.2.1",
     "eslint-plugin-perfectionist": "^5.10.1",
     "eslint-plugin-prettier": "^5.5.6",
-    "eslint-plugin-rxjs-x": "^1.0.5",
+    "eslint-plugin-rxjs-x": "^1.0.6",
     "eslint-plugin-unicorn": "^73.0.0",
     "globals": "^17.11.0",
     "husky": "^9.1.7",
     "jiti": "^2.7.0",
-    "lint-staged": "^17.3.0",
+    "lint-staged": "^17.4.1",
     "lodash-es": "^4.18.1",
     "patch-package": "^8.0.1",
     "prettier": "^3.9.6",
@@ -123,12 +117,12 @@
     "semantic-release": "^25.0.9",
     "tsc-alias": "^1.9.2",
     "typedoc": "^0.28.20",
-    "typedoc-plugin-markdown": "^4.12.0",
+    "typedoc-plugin-markdown": "^4.13.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.67.0",
+    "typescript-eslint": "^8.68.0",
     "vitest": "^4.1.11"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "eslint": ">=10.9.1"
   }
 }

package/dist/domain/architecture/no-unused-exports/no-unused-exports-utilities.d.ts

@@ -1,49 +0,0 @@
-import type { AST, Rule } from "eslint";
-import type * as ts from "typescript";
-import type { ExportedElement, ExportUsage, NoUnusedExportsState } from "./types.js";
-/**
- * Classifies one exported name based on cross-file usages.
- * @param usages Collected usages.
- * @returns Classification label.
- * @example
- * ```typescript
- * const classification = classifyExportUsage(usages);
- * ```
- */
-declare const classifyExportUsage: (usages: ExportUsage[]) => "production" | "test-only" | "unused";
-/**
- * Collects concrete usages of one exported element across the program.
- * @param program TypeScript program.
- * @param sourceFilename Source filename where export is defined.
- * @param state Normalized rule options.
- * @param repoRoot Absolute repository root used for test-file classification.
- * @param exportedElement Exported element to classify.
- * @returns Concrete usages for the exported element.
- * @example
- * ```typescript
- * const usages = collectCrossFileUsages(program, "/repo/src/feature.ts", state, "/repo", exportedElement);
- * ```
- */
-declare const collectCrossFileUsages: (program: ts.Program, sourceFilename: string, state: NoUnusedExportsState, repoRoot: string, exportedElement: ExportedElement) => ExportUsage[];
-/**
- * Collects exported elements from one program body.
- * @param body Program body statements.
- * @returns Exported elements in declaration order.
- * @example
- * ```typescript
- * const exported = collectExportedElements(program.body);
- * ```
- */
-declare const collectExportedElements: (body: AST.Program["body"]) => ExportedElement[];
-/**
- * Resolves TypeScript parser services program when available.
- * @param context Rule context.
- * @returns TypeScript program when available.
- * @example
- * ```typescript
- * const program = getTypeScriptProgram(context);
- * ```
- */
-declare const getTypeScriptProgram: (context: Rule.RuleContext) => ts.Program | undefined;
-export { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, };
-//# sourceMappingURL=no-unused-exports-utilities.d.ts.map

package/dist/domain/architecture/no-unused-exports/no-unused-exports-utilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-unused-exports-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-exports/no-unused-exports-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EACV,eAAe,EACf,WAAW,EACX,oBAAoB,EACrB,MAAM,SAAS,CAAC;AASjB;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GACvB,QAAQ,WAAW,EAAE,KACpB,YAAY,GAAG,WAAW,GAAG,QACO,CAAC;AAExC;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,sBAAsB,GAC1B,SAAS,EAAE,CAAC,OAAO,EACnB,gBAAgB,MAAM,EACtB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,iBAAiB,eAAe,KAC/B,WAAW,EAOX,CAAC;AAEJ;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAC3B,MAAM,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,KACxB,eAAe,EAAmD,CAAC;AAEtE;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,IAAI,CAAC,WAAW,KACxB,EAAE,CAAC,OAAO,GAAG,SAAsD,CAAC;AAEvE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,GACrB,CAAC"}

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

@@ -1,49 +0,0 @@
-import { collectExportedElements as collectExportedElementsFromDeclarations } from "./no-unused-exports-declaration-utilities.js";
-import { getTypeScriptProgram as getTypeScriptProgramFromServices } from "./no-unused-exports-identifier-utilities.js";
-import { classifyExportUsage as classifyExportUsageFromUsages, collectCrossFileUsages as collectCrossFileUsagesFromUsages, } from "./no-unused-exports-usage-utilities.js";
-/**
- * Classifies one exported name based on cross-file usages.
- * @param usages Collected usages.
- * @returns Classification label.
- * @example
- * ```typescript
- * const classification = classifyExportUsage(usages);
- * ```
- */
-const classifyExportUsage = (usages) => classifyExportUsageFromUsages(usages);
-/**
- * Collects concrete usages of one exported element across the program.
- * @param program TypeScript program.
- * @param sourceFilename Source filename where export is defined.
- * @param state Normalized rule options.
- * @param repoRoot Absolute repository root used for test-file classification.
- * @param exportedElement Exported element to classify.
- * @returns Concrete usages for the exported element.
- * @example
- * ```typescript
- * const usages = collectCrossFileUsages(program, "/repo/src/feature.ts", state, "/repo", exportedElement);
- * ```
- */
-const collectCrossFileUsages = (program, sourceFilename, state, repoRoot, exportedElement) => collectCrossFileUsagesFromUsages(program, sourceFilename, state, repoRoot, exportedElement);
-/**
- * Collects exported elements from one program body.
- * @param body Program body statements.
- * @returns Exported elements in declaration order.
- * @example
- * ```typescript
- * const exported = collectExportedElements(program.body);
- * ```
- */
-const collectExportedElements = (body) => collectExportedElementsFromDeclarations(body);
-/**
- * Resolves TypeScript parser services program when available.
- * @param context Rule context.
- * @returns TypeScript program when available.
- * @example
- * ```typescript
- * const program = getTypeScriptProgram(context);
- * ```
- */
-const getTypeScriptProgram = (context) => getTypeScriptProgramFromServices(context);
-export { classifyExportUsage, collectCrossFileUsages, collectExportedElements, getTypeScriptProgram, };
-//# sourceMappingURL=data:application/json;base64,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