@codeperfect/eslint-plugin 2.11.0 → 3.1.0

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.d.ts

@@ -0,0 +1,18 @@
+import * as ts from "typescript";
+import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Checks whether a member has a concrete reference in production TypeScript.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param member Member whose production usage is being checked.
+ * @returns True when production code references the member.
+ * @example
+ * ```typescript
+ * const used = hasProductionUsage(program, state, repoRoot, member);
+ * ```
+ */
+declare const hasProductionUsage: (program: ts.Program, state: NoUnusedExportsState, repoRoot: string, member: PublicMember) => boolean;
+export { hasProductionUsage };
+//# sourceMappingURL=member-usage-utilities.d.ts.map

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member-usage-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAyFnE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,kBAAkB,GACtB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,QAAQ,YAAY,KACnB,OAuEF,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-public-members/member-usage-utilities.js

@@ -0,0 +1,128 @@
+import path from "node:path";
+import * as ts from "typescript";
+import { isTestFile } from "../no-unused-exports/no-unused-exports-options.js";
+import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+import { collectHeritageMemberSymbols } from "./member-contract-utilities.js";
+import { isCallArgumentMember, isObjectContractHandoff, } from "./member-usage-handoff-utilities.js";
+import { isComputedMemberRead, isStructuralPropertyRead, } from "./member-usage-reference-utilities.js";
+/**
+ * Resolves destructured member names or direct reference symbols.
+ * @param node Candidate reference node.
+ * @param checker TypeScript type checker.
+ * @returns Referenced member symbol when available.
+ * @example
+ * ```typescript
+ * const symbol = getUsageSymbol(propertyIdentifier, checker);
+ * ```
+ */
+const getUsageSymbol = (node, checker) => {
+    const parent = node.parent;
+    if (ts.isIdentifier(node) &&
+        ts.isBindingElement(parent) &&
+        parent.name === node &&
+        parent.propertyName === void 0 &&
+        ts.isObjectBindingPattern(parent.parent)) {
+        const owner = parent.parent.parent;
+        const sourceType = ts.isVariableDeclaration(owner)
+            ? owner.initializer === void 0
+                ? void 0
+                : checker.getTypeAtLocation(owner.initializer)
+            : ts.isParameter(owner)
+                ? checker.getTypeAtLocation(owner)
+                : void 0;
+        return sourceType === void 0
+            ? checker.getSymbolAtLocation(node)
+            : checker.getPropertyOfType(sourceType, node.text);
+    }
+    return checker.getSymbolAtLocation(node);
+};
+/**
+ * Identifies declaration names that are not member references.
+ * @param node Candidate reference node.
+ * @returns True when the node is only declaring a name.
+ * @example
+ * ```typescript
+ * const declarationOnly = isDeclarationName(propertyName);
+ * ```
+ */
+const isDeclarationName = (node) => {
+    const parent = node.parent;
+    return (((ts.isPropertyDeclaration(parent) ||
+        ts.isMethodDeclaration(parent) ||
+        ts.isGetAccessorDeclaration(parent) ||
+        ts.isSetAccessorDeclaration(parent) ||
+        ts.isPropertySignature(parent) ||
+        ts.isMethodSignature(parent) ||
+        ts.isPropertyAssignment(parent) ||
+        ts.isShorthandPropertyAssignment(parent)) &&
+        parent.name === node) ||
+        (ts.isVariableDeclaration(parent) && parent.name === node) ||
+        ((ts.isClassDeclaration(parent) ||
+            ts.isInterfaceDeclaration(parent) ||
+            ts.isTypeAliasDeclaration(parent) ||
+            ts.isFunctionDeclaration(parent)) &&
+            parent.name === node) ||
+        (ts.isParameter(parent) && parent.name === node));
+};
+/**
+ * Checks whether a member has a concrete reference in production TypeScript.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param member Member whose production usage is being checked.
+ * @returns True when production code references the member.
+ * @example
+ * ```typescript
+ * const used = hasProductionUsage(program, state, repoRoot, member);
+ * ```
+ */
+const hasProductionUsage = (program, state, repoRoot, member) => {
+    const checker = program.getTypeChecker();
+    const relatedSymbols = [
+        resolveCanonicalSymbol(member.memberSymbol, checker),
+        ...collectHeritageMemberSymbols(program, checker, member).map((symbol) => resolveCanonicalSymbol(symbol, checker)),
+    ];
+    const variableDeclaration = ts.isVariableDeclaration(member.hostDeclaration)
+        ? member.hostDeclaration
+        : void 0;
+    if (variableDeclaration !== void 0) {
+        const declaredType = checker.getTypeAtLocation(variableDeclaration.name);
+        const declaredMember = checker.getPropertyOfType(declaredType, member.memberName);
+        if (declaredMember !== void 0 &&
+            relatedSymbols.every((symbol) => !isSameSymbol(symbol, declaredMember))) {
+            relatedSymbols.push(resolveCanonicalSymbol(declaredMember, checker));
+        }
+    }
+    const normalizedRoot = path.resolve(repoRoot);
+    for (const sourceFile of program.getSourceFiles()) {
+        const filename = path.resolve(sourceFile.fileName);
+        if (sourceFile.isDeclarationFile ||
+            isTestFile(filename, state, normalizedRoot)) {
+            continue;
+        }
+        const findUsageSymbol = (node) => {
+            if ((ts.isIdentifier(node) || ts.isStringLiteralLike(node)) &&
+                !isDeclarationName(node)) {
+                const candidate = getUsageSymbol(node, checker);
+                if (candidate !== void 0 &&
+                    relatedSymbols.some((symbol) => isSameSymbol(symbol, candidate))) {
+                    return candidate;
+                }
+                if (isStructuralPropertyRead(node, checker, member)) {
+                    return member.memberSymbol;
+                }
+            }
+            return isComputedMemberRead(node, checker, member, relatedSymbols) ||
+                isCallArgumentMember(node, checker, member) ||
+                isObjectContractHandoff(node, checker, member)
+                ? member.memberSymbol
+                : ts.forEachChild(node, findUsageSymbol);
+        };
+        if (findUsageSymbol(sourceFile) !== void 0) {
+            return true;
+        }
+    }
+    return false;
+};
+export { hasProductionUsage };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type { NoUnusedExportsState } from \"../no-unused-exports/types\";\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport { isTestFile } from \"../no-unused-exports/no-unused-exports-options\";\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\nimport { collectHeritageMemberSymbols } from \"./member-contract-utilities\";\nimport {\n  isCallArgumentMember,\n  isObjectContractHandoff,\n} from \"./member-usage-handoff-utilities\";\nimport {\n  isComputedMemberRead,\n  isStructuralPropertyRead,\n} from \"./member-usage-reference-utilities\";\n\n/**\n * Resolves destructured member names or direct reference symbols.\n * @param node Candidate reference node.\n * @param checker TypeScript type checker.\n * @returns Referenced member symbol when available.\n * @example\n * ```typescript\n * const symbol = getUsageSymbol(propertyIdentifier, checker);\n * ```\n */\nconst getUsageSymbol = (\n  node: ts.Node,\n  checker: ts.TypeChecker,\n): ts.Symbol | undefined => {\n  const parent = node.parent;\n\n  if (\n    ts.isIdentifier(node) &&\n    ts.isBindingElement(parent) &&\n    parent.name === node &&\n    parent.propertyName === void 0 &&\n    ts.isObjectBindingPattern(parent.parent)\n  ) {\n    const owner = parent.parent.parent;\n    const sourceType = ts.isVariableDeclaration(owner)\n      ? owner.initializer === void 0\n        ? void 0\n        : checker.getTypeAtLocation(owner.initializer)\n      : ts.isParameter(owner)\n        ? checker.getTypeAtLocation(owner)\n        : void 0;\n\n    return sourceType === void 0\n      ? checker.getSymbolAtLocation(node)\n      : checker.getPropertyOfType(sourceType, node.text);\n  }\n\n  return checker.getSymbolAtLocation(node);\n};\n\n/**\n * Identifies declaration names that are not member references.\n * @param node Candidate reference node.\n * @returns True when the node is only declaring a name.\n * @example\n * ```typescript\n * const declarationOnly = isDeclarationName(propertyName);\n * ```\n */\nconst isDeclarationName = (node: ts.Node): boolean => {\n  const parent = node.parent;\n\n  return (\n    ((ts.isPropertyDeclaration(parent) ||\n      ts.isMethodDeclaration(parent) ||\n      ts.isGetAccessorDeclaration(parent) ||\n      ts.isSetAccessorDeclaration(parent) ||\n      ts.isPropertySignature(parent) ||\n      ts.isMethodSignature(parent) ||\n      ts.isPropertyAssignment(parent) ||\n      ts.isShorthandPropertyAssignment(parent)) &&\n      parent.name === node) ||\n    (ts.isVariableDeclaration(parent) && parent.name === node) ||\n    ((ts.isClassDeclaration(parent) ||\n      ts.isInterfaceDeclaration(parent) ||\n      ts.isTypeAliasDeclaration(parent) ||\n      ts.isFunctionDeclaration(parent)) &&\n      parent.name === node) ||\n    (ts.isParameter(parent) && parent.name === node)\n  );\n};\n\n/**\n * Checks whether a member has a concrete reference in production TypeScript.\n * @param program TypeScript project program.\n * @param state Normalized public API and test patterns.\n * @param repoRoot Root directory used for glob matching.\n * @param member Member whose production usage is being checked.\n * @returns True when production code references the member.\n * @example\n * ```typescript\n * const used = hasProductionUsage(program, state, repoRoot, member);\n * ```\n */\nconst hasProductionUsage = (\n  program: ts.Program,\n  state: NoUnusedExportsState,\n  repoRoot: string,\n  member: PublicMember,\n): boolean => {\n  const checker = program.getTypeChecker();\n  const relatedSymbols = [\n    resolveCanonicalSymbol(member.memberSymbol, checker),\n    ...collectHeritageMemberSymbols(program, checker, member).map((symbol) =>\n      resolveCanonicalSymbol(symbol, checker),\n    ),\n  ];\n  const variableDeclaration = ts.isVariableDeclaration(member.hostDeclaration)\n    ? member.hostDeclaration\n    : void 0;\n\n  if (variableDeclaration !== void 0) {\n    const declaredType = checker.getTypeAtLocation(variableDeclaration.name);\n    const declaredMember = checker.getPropertyOfType(\n      declaredType,\n      member.memberName,\n    );\n\n    if (\n      declaredMember !== void 0 &&\n      relatedSymbols.every((symbol) => !isSameSymbol(symbol, declaredMember))\n    ) {\n      relatedSymbols.push(resolveCanonicalSymbol(declaredMember, checker));\n    }\n  }\n\n  const normalizedRoot = path.resolve(repoRoot);\n\n  for (const sourceFile of program.getSourceFiles()) {\n    const filename = path.resolve(sourceFile.fileName);\n\n    if (\n      sourceFile.isDeclarationFile ||\n      isTestFile(filename, state, normalizedRoot)\n    ) {\n      continue;\n    }\n\n    const findUsageSymbol = (node: ts.Node): ts.Symbol | undefined => {\n      if (\n        (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) &&\n        !isDeclarationName(node)\n      ) {\n        const candidate = getUsageSymbol(node, checker);\n\n        if (\n          candidate !== void 0 &&\n          relatedSymbols.some((symbol) => isSameSymbol(symbol, candidate))\n        ) {\n          return candidate;\n        }\n\n        if (isStructuralPropertyRead(node, checker, member)) {\n          return member.memberSymbol;\n        }\n      }\n\n      return isComputedMemberRead(node, checker, member, relatedSymbols) ||\n        isCallArgumentMember(node, checker, member) ||\n        isObjectContractHandoff(node, checker, member)\n        ? member.memberSymbol\n        : ts.forEachChild(node, findUsageSymbol);\n    };\n\n    if (findUsageSymbol(sourceFile) !== void 0) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nexport { hasProductionUsage };\n"]}

package/dist/domain/architecture/no-unused-public-members/member-utilities.d.ts

@@ -0,0 +1,41 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
+type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
+/**
+ * Collects unused direct public members from a linted source file.
+ * @param sourceFile Source file being linted.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param parserServices TypeScript and ESTree node maps.
+ * @returns Members outside the public API with no production use.
+ * @example
+ * ```typescript
+ * const unused = collectUnusedPublicMembers(sourceFile, program, state, repoRoot, services);
+ * ```
+ */
+declare const collectUnusedPublicMembers: (sourceFile: ts.SourceFile, program: ts.Program, state: NoUnusedExportsState, repoRoot: string, parserServices: ParserServices) => import("./member-declaration-utilities.js").PublicMember[];
+/**
+ * Finds the program source file matching an absolute lint filename.
+ * @param program TypeScript project program.
+ * @param filename Absolute filename to find.
+ * @returns Matching source file when it belongs to the program.
+ * @example
+ * ```typescript
+ * const sourceFile = getProgramSourceFile(program, context.filename);
+ * ```
+ */
+declare const getProgramSourceFile: (program: ts.Program, filename: string) => ts.SourceFile | undefined;
+/**
+ * Returns the absolute project root from the TypeScript program.
+ * @param program TypeScript project program.
+ * @returns Absolute TypeScript project root.
+ * @example
+ * ```typescript
+ * const projectRoot = getProjectRoot(program);
+ * ```
+ */
+declare const getProjectRoot: (program: ts.Program) => string;
+export { collectUnusedPublicMembers, getProgramSourceFile, getProjectRoot };
+//# sourceMappingURL=member-utilities.d.ts.map

package/dist/domain/architecture/no-unused-public-members/member-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AASvE,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAEvE;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,0BAA0B,GAC9B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,gBAAgB,cAAc,4DAU/B,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,EAAE,CAAC,OAAO,EACnB,UAAU,MAAM,KACf,EAAE,CAAC,UAAU,GAAG,SAOd,CAAC;AAEN;;;;;;;;GAQG;AACH,QAAA,MAAM,cAAc,GAAI,SAAS,EAAE,CAAC,OAAO,KAAG,MACD,CAAC;AAE9C,OAAO,EAAE,0BAA0B,EAAE,oBAAoB,EAAE,cAAc,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-public-members/member-utilities.js

@@ -0,0 +1,51 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import path from "node:path";
+import * as ts from "typescript";
+import { collectPublicMembers } from "./member-declaration-utilities.js";
+import { isPublicApiHost, isPublicApiMember, } from "./member-public-api-utilities.js";
+import { hasProductionUsage } from "./member-usage-utilities.js";
+/**
+ * Collects unused direct public members from a linted source file.
+ * @param sourceFile Source file being linted.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param parserServices TypeScript and ESTree node maps.
+ * @returns Members outside the public API with no production use.
+ * @example
+ * ```typescript
+ * const unused = collectUnusedPublicMembers(sourceFile, program, state, repoRoot, services);
+ * ```
+ */
+const collectUnusedPublicMembers = (sourceFile, program, state, repoRoot, parserServices) => {
+    const checker = program.getTypeChecker();
+    return collectPublicMembers(sourceFile, checker, parserServices).filter((member) => !isPublicApiHost(program, state, repoRoot, member.hostSymbol) &&
+        !isPublicApiMember(program, state, repoRoot, member.memberSymbol) &&
+        !hasProductionUsage(program, state, repoRoot, member));
+};
+/**
+ * Finds the program source file matching an absolute lint filename.
+ * @param program TypeScript project program.
+ * @param filename Absolute filename to find.
+ * @returns Matching source file when it belongs to the program.
+ * @example
+ * ```typescript
+ * const sourceFile = getProgramSourceFile(program, context.filename);
+ * ```
+ */
+const getProgramSourceFile = (program, filename) => program
+    .getSourceFiles()
+    .find((sourceFile) => path.resolve(sourceFile.fileName).toLowerCase() ===
+    path.resolve(filename).toLowerCase());
+/**
+ * Returns the absolute project root from the TypeScript program.
+ * @param program TypeScript project program.
+ * @returns Absolute TypeScript project root.
+ * @example
+ * ```typescript
+ * const projectRoot = getProjectRoot(program);
+ * ```
+ */
+const getProjectRoot = (program) => path.resolve(program.getCurrentDirectory());
+export { collectUnusedPublicMembers, getProgramSourceFile, getProjectRoot };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/architecture/no-unused-public-members/rule.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule flagging public members unused by production code. */
+declare const noUnusedPublicMembersRule: Rule.RuleModule;
+export { noUnusedPublicMembersRule };
+//# sourceMappingURL=rule.d.ts.map

package/dist/domain/architecture/no-unused-public-members/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiBnC,qEAAqE;AACrE,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAsFrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/architecture/no-unused-public-members/rule.js

@@ -0,0 +1,78 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { DEFAULT_PUBLIC_API_FILES, DEFAULT_TEST_FILE_PATTERNS, getOptions, isLintableFilename, isTestFile, } from "../no-unused-exports/no-unused-exports-options.js";
+import { collectUnusedPublicMembers, getProgramSourceFile, getProjectRoot, } from "./member-utilities.js";
+/** ESLint rule flagging public members unused by production code. */
+const noUnusedPublicMembersRule = {
+    create(context) {
+        if (!isLintableFilename(context.filename)) {
+            return {};
+        }
+        let parserServices;
+        try {
+            parserServices = ESLintUtils.getParserServices(context);
+        }
+        catch {
+            return {};
+        }
+        const program = parserServices.program;
+        const state = getOptions(context.options);
+        const projectRoot = getProjectRoot(program);
+        if (isTestFile(context.filename, state, projectRoot)) {
+            return {};
+        }
+        return {
+            Program() {
+                const sourceFile = getProgramSourceFile(program, context.filename);
+                if (sourceFile === void 0) {
+                    return;
+                }
+                for (const member of collectUnusedPublicMembers(sourceFile, program, state, projectRoot, parserServices)) {
+                    context.report({
+                        data: { hostName: member.hostName, memberName: member.memberName },
+                        messageId: "unusedPublicMember",
+                        node: member.reportNode,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        defaultOptions: [
+            {
+                publicApiFiles: [...DEFAULT_PUBLIC_API_FILES],
+                testFilePatterns: [...DEFAULT_TEST_FILE_PATTERNS],
+            },
+        ],
+        docs: {
+            description: "Disallow public members that are unused by production code unless their host is part of the public API.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-unused-public-members.md",
+        },
+        messages: {
+            unusedPublicMember: "Member '{{memberName}}' of '{{hostName}}' is never used by production code; remove it or make it private.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    publicApiFiles: {
+                        description: "File globs that define public API export surfaces.",
+                        items: { type: "string" },
+                        minItems: 1,
+                        type: "array",
+                    },
+                    testFilePatterns: {
+                        description: "File globs treated as tests when classifying member consumers.",
+                        items: { type: "string" },
+                        minItems: 1,
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+};
+export { noUnusedPublicMembersRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/core/no-multiple-declarators/rule-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EACV,8BAA8B,EAG9B,4BAA4B,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAejB;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,SAAS,IAAI,CAAC,WAAW,KAAG,gBACA,CAAC;AAEpD;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,YAAY,gBAAgB,KAAG,MACwB,CAAC;AA6I/E;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,cAAc,SAAS,sBAAsB,EAAE,KAC9C,SAAS,4BAA4B,EAAE,GAAG,SAY5C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,MAAM,GACV,MAAM,uBAAuB,EAC7B,cAAc,SAAS,sBAAsB,EAAE,EAC/C,YAAY,MAAM,KACjB,OAiBF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,gBAAgB,GACpB,MAAM,8BAA8B,EACpC,cAAc,SAAS,4BAA4B,EAAE,EACrD,YAAY,gBAAgB,KAC3B,MAQF,CAAC;AAEF,OAAO,EACL,gBAAgB,EAChB,MAAM,EACN,qBAAqB,EACrB,aAAa,EACb,aAAa,GACd,CAAC"}
+{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EACV,8BAA8B,EAG9B,4BAA4B,EAC5B,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAejB;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,SAAS,IAAI,CAAC,WAAW,KAAG,gBACA,CAAC;AAEpD;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,YAAY,gBAAgB,KAAG,MACwB,CAAC;AAyI/E;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,cAAc,SAAS,sBAAsB,EAAE,KAC9C,SAAS,4BAA4B,EAAE,GAAG,SAY5C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,MAAM,GACV,MAAM,uBAAuB,EAC7B,cAAc,SAAS,sBAAsB,EAAE,EAC/C,YAAY,MAAM,KACjB,OAYF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,gBAAgB,GACpB,MAAM,8BAA8B,EACpC,cAAc,SAAS,4BAA4B,EAAE,EACrD,YAAY,gBAAgB,KAC3B,MAQF,CAAC;AAEF,OAAO,EACL,gBAAgB,EAChB,MAAM,EACN,qBAAqB,EACrB,aAAa,EACb,aAAa,GACd,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule-utilities.js

@@ -50,13 +50,11 @@ const getLineSeparator = (sourceText) => sourceText.includes("\r\n") ? "\r\n" :
  */
 const isLoopInitializer = (node) => {
     const { parent } = node;
-    if (parent?.type === "ForStatement") {
-        return parent.init === node;
-    }
-    if (parent !== void 0 && loopParentTypes.has(parent.type)) {
-        return parent.left === node;
-    }
-    return false;
+    return parent?.type === "ForStatement"
+        ? parent.init === node
+        : parent !== void 0 &&
+            loopParentTypes.has(parent.type) &&
+            parent.left === node;
 };
 /**
  * Determines whether a declaration is wrapped in an export statement.
@@ -169,17 +167,13 @@ const getRangedDeclarations = (declarations) => {
  * ```
  */
 const canFix = (node, declarations, sourceText) => {
-    if (!hasFixData(node)) {
-        return false;
-    }
-    if (!hasFixableDeclarationKind(node) ||
-        isTypeScriptAmbientDeclaration(node)) {
-        return false;
-    }
-    if (isLoopInitializer(node) || isWrappedExport(node)) {
-        return false;
-    }
-    return !hasSeparatorComment(declarations, sourceText);
+    const isFixable = hasFixData(node) &&
+        hasFixableDeclarationKind(node) &&
+        !isTypeScriptAmbientDeclaration(node);
+    return (isFixable &&
+        !isLoopInitializer(node) &&
+        !isWrappedExport(node) &&
+        !hasSeparatorComment(declarations, sourceText));
 };
 /**
  * Converts declarators into separate declaration statements.
@@ -201,4 +195,4 @@ const buildReplacement = (node, declarations, sourceCode) => {
         .join(`${lineSeparator}${indent}`);
 };
 export { buildReplacement, canFix, getRangedDeclarations, getSourceCode, getSourceText, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-utilities.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  FixableVariableDeclarationNode,\n  ForInOrOfStatementNode,\n  ForStatementNode,\n  RangedVariableDeclaratorNode,\n  SourceCodeAccess,\n  VariableDeclarationNode,\n  VariableDeclaratorNode,\n} from \"./types\";\n\nimport { hasFixData, hasRange } from \"./types\";\n\n/** Matches comment syntax between declarators. */\nconst commentPattern = /\\/\\/|\\/\\*/u;\n/** Declaration kinds that can be safely split into standalone statements. */\nconst fixableDeclarationKinds = new Set([\"const\", \"let\", \"var\"]);\n/** Loop parent types whose initializers cannot be safely split. */\nconst loopParentTypes = new Set([\n  \"ForAwaitOfStatement\",\n  \"ForInStatement\",\n  \"ForOfStatement\",\n]);\n\n/**\n * Gets the source access wrapper from the ESLint context.\n * @param context Rule execution context.\n * @returns Source access helpers used by the fixer.\n * @example\n * ```typescript\n * const sourceCode = getSourceCode(context);\n * ```\n */\nconst getSourceCode = (context: Rule.RuleContext): SourceCodeAccess =>\n  context.sourceCode as unknown as SourceCodeAccess;\n\n/**\n * Reads the full source text for the active file.\n * @param sourceCode Source access wrapper.\n * @returns Full source text.\n * @example\n * ```typescript\n * const sourceText = getSourceText(sourceCode);\n * ```\n */\nconst getSourceText = (sourceCode: SourceCodeAccess): string =>\n  typeof sourceCode.text === \"string\" ? sourceCode.text : sourceCode.getText();\n\n/**\n * Gets the line separator style used by the current source file.\n * @param sourceText Full source text.\n * @returns File-native line separator sequence.\n * @example\n * ```typescript\n * const lineSeparator = getLineSeparator(\"const a = 1;\\r\\nconst b = 2;\");\n * ```\n */\nconst getLineSeparator = (sourceText: string): string =>\n  sourceText.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n\n/**\n * Determines whether a declaration is used as a loop initializer.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is attached to a loop initializer.\n * @example\n * ```typescript\n * const inLoop = isLoopInitializer(node);\n * ```\n */\nconst isLoopInitializer = (node: VariableDeclarationNode): boolean => {\n  const { parent } = node;\n\n  if (parent?.type === \"ForStatement\") {\n    return (parent as ForStatementNode).init === node;\n  }\n\n  if (parent !== void 0 && loopParentTypes.has(parent.type)) {\n    return (parent as ForInOrOfStatementNode).left === node;\n  }\n\n  return false;\n};\n\n/**\n * Determines whether a declaration is wrapped in an export statement.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is directly exported.\n * @example\n * ```typescript\n * const exported = isWrappedExport(node);\n * ```\n */\nconst isWrappedExport = (node: VariableDeclarationNode): boolean =>\n  node.parent?.type === \"ExportDefaultDeclaration\" ||\n  node.parent?.type === \"ExportNamedDeclaration\";\n\n/**\n * Determines whether a declaration is ambient in TypeScript source.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is marked with `declare`.\n * @example\n * ```typescript\n * const ambient = isTypeScriptAmbientDeclaration(node);\n * ```\n */\nconst isTypeScriptAmbientDeclaration = (\n  node: VariableDeclarationNode,\n): boolean => node.declare === true;\n\n/**\n * Determines whether a declaration kind is safe to rewrite.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration kind supports conservative split fixes.\n * @example\n * ```typescript\n * const safeKind = hasFixableDeclarationKind(node);\n * ```\n */\nconst hasFixableDeclarationKind = (node: VariableDeclarationNode): boolean =>\n  hasFixData(node) && fixableDeclarationKinds.has(node.kind);\n\n/**\n * Gets the indentation for the line containing a declaration.\n * @param sourceText Full source text.\n * @param start Start offset of the declaration.\n * @returns Leading indentation for the declaration line.\n * @example\n * ```typescript\n * const indent = getLineIndent(\"const a = 1;\", 0);\n * ```\n */\nconst getLineIndent = (sourceText: string, start: number): string => {\n  const lineStart = sourceText.lastIndexOf(\"\\n\", start - 1) + 1;\n  const linePrefix = sourceText.slice(lineStart, start);\n  let indentLength = 0;\n\n  while (indentLength < linePrefix.length) {\n    const currentCharacter = linePrefix[indentLength];\n\n    if (currentCharacter !== \"\\t\" && currentCharacter !== \" \") {\n      break;\n    }\n\n    indentLength += 1;\n  }\n\n  return linePrefix.slice(0, indentLength);\n};\n\n/**\n * Detects whether comments appear between declarators.\n * @param declarations Declarators from a single declaration statement.\n * @param sourceText Full source text.\n * @returns Whether comments appear between declarators.\n * @example\n * ```typescript\n * const blocked = hasSeparatorComment(declarations, sourceText);\n * ```\n */\nconst hasSeparatorComment = (\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  for (const [index, declaration] of declarations.entries()) {\n    const nextDeclaration = declarations[index + 1];\n\n    if (nextDeclaration === void 0) {\n      break;\n    }\n\n    if (!hasRange(declaration) || !hasRange(nextDeclaration)) {\n      return true;\n    }\n\n    const separatorText = sourceText.slice(\n      declaration.range[1],\n      nextDeclaration.range[0],\n    );\n\n    if (commentPattern.test(separatorText)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Collects ranged declarators when every declarator exposes a range.\n * @param declarations Declarators from the declaration node.\n * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.\n * @example\n * ```typescript\n * const ranged = getRangedDeclarations(node.declarations ?? []);\n * ```\n */\nconst getRangedDeclarations = (\n  declarations: readonly VariableDeclaratorNode[],\n): readonly RangedVariableDeclaratorNode[] | undefined => {\n  const rangedDeclarations: RangedVariableDeclaratorNode[] = [];\n\n  for (const declaration of declarations) {\n    if (!hasRange(declaration)) {\n      return void 0;\n    }\n\n    rangedDeclarations.push(declaration);\n  }\n\n  return rangedDeclarations;\n};\n\n/**\n * Determines whether a declaration can be safely rewritten.\n * @param node Declaration node to inspect.\n * @param declarations Declarators within the declaration.\n * @param sourceText Full source text.\n * @returns Whether the declaration is safe to autofix.\n * @example\n * ```typescript\n * const fixable = canFix(node, declarations, sourceText);\n * ```\n */\nconst canFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  if (!hasFixData(node)) {\n    return false;\n  }\n\n  if (\n    !hasFixableDeclarationKind(node) ||\n    isTypeScriptAmbientDeclaration(node)\n  ) {\n    return false;\n  }\n\n  if (isLoopInitializer(node) || isWrappedExport(node)) {\n    return false;\n  }\n\n  return !hasSeparatorComment(declarations, sourceText);\n};\n\n/**\n * Converts declarators into separate declaration statements.\n * @param node Fixable declaration node.\n * @param declarations Declarators that should be split.\n * @param sourceCode Source access wrapper.\n * @returns Replacement text for the full declaration.\n * @example\n * ```typescript\n * const replacement = buildReplacement(node, declarations, sourceCode);\n * ```\n */\nconst buildReplacement = (\n  node: FixableVariableDeclarationNode,\n  declarations: readonly RangedVariableDeclaratorNode[],\n  sourceCode: SourceCodeAccess,\n): string => {\n  const sourceText = getSourceText(sourceCode);\n  const indent = getLineIndent(sourceText, node.range[0]);\n  const lineSeparator = getLineSeparator(sourceText);\n\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`${lineSeparator}${indent}`);\n};\n\nexport {\n  buildReplacement,\n  canFix,\n  getRangedDeclarations,\n  getSourceCode,\n  getSourceText,\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-utilities.js","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  FixableVariableDeclarationNode,\n  ForInOrOfStatementNode,\n  ForStatementNode,\n  RangedVariableDeclaratorNode,\n  SourceCodeAccess,\n  VariableDeclarationNode,\n  VariableDeclaratorNode,\n} from \"./types\";\n\nimport { hasFixData, hasRange } from \"./types\";\n\n/** Matches comment syntax between declarators. */\nconst commentPattern = /\\/\\/|\\/\\*/u;\n/** Declaration kinds that can be safely split into standalone statements. */\nconst fixableDeclarationKinds = new Set([\"const\", \"let\", \"var\"]);\n/** Loop parent types whose initializers cannot be safely split. */\nconst loopParentTypes = new Set([\n  \"ForAwaitOfStatement\",\n  \"ForInStatement\",\n  \"ForOfStatement\",\n]);\n\n/**\n * Gets the source access wrapper from the ESLint context.\n * @param context Rule execution context.\n * @returns Source access helpers used by the fixer.\n * @example\n * ```typescript\n * const sourceCode = getSourceCode(context);\n * ```\n */\nconst getSourceCode = (context: Rule.RuleContext): SourceCodeAccess =>\n  context.sourceCode as unknown as SourceCodeAccess;\n\n/**\n * Reads the full source text for the active file.\n * @param sourceCode Source access wrapper.\n * @returns Full source text.\n * @example\n * ```typescript\n * const sourceText = getSourceText(sourceCode);\n * ```\n */\nconst getSourceText = (sourceCode: SourceCodeAccess): string =>\n  typeof sourceCode.text === \"string\" ? sourceCode.text : sourceCode.getText();\n\n/**\n * Gets the line separator style used by the current source file.\n * @param sourceText Full source text.\n * @returns File-native line separator sequence.\n * @example\n * ```typescript\n * const lineSeparator = getLineSeparator(\"const a = 1;\\r\\nconst b = 2;\");\n * ```\n */\nconst getLineSeparator = (sourceText: string): string =>\n  sourceText.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n\n/**\n * Determines whether a declaration is used as a loop initializer.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is attached to a loop initializer.\n * @example\n * ```typescript\n * const inLoop = isLoopInitializer(node);\n * ```\n */\nconst isLoopInitializer = (node: VariableDeclarationNode): boolean => {\n  const { parent } = node;\n\n  return parent?.type === \"ForStatement\"\n    ? (parent as ForStatementNode).init === node\n    : parent !== void 0 &&\n        loopParentTypes.has(parent.type) &&\n        (parent as ForInOrOfStatementNode).left === node;\n};\n\n/**\n * Determines whether a declaration is wrapped in an export statement.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is directly exported.\n * @example\n * ```typescript\n * const exported = isWrappedExport(node);\n * ```\n */\nconst isWrappedExport = (node: VariableDeclarationNode): boolean =>\n  node.parent?.type === \"ExportDefaultDeclaration\" ||\n  node.parent?.type === \"ExportNamedDeclaration\";\n\n/**\n * Determines whether a declaration is ambient in TypeScript source.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration is marked with `declare`.\n * @example\n * ```typescript\n * const ambient = isTypeScriptAmbientDeclaration(node);\n * ```\n */\nconst isTypeScriptAmbientDeclaration = (\n  node: VariableDeclarationNode,\n): boolean => node.declare === true;\n\n/**\n * Determines whether a declaration kind is safe to rewrite.\n * @param node Declaration node to inspect.\n * @returns Whether the declaration kind supports conservative split fixes.\n * @example\n * ```typescript\n * const safeKind = hasFixableDeclarationKind(node);\n * ```\n */\nconst hasFixableDeclarationKind = (node: VariableDeclarationNode): boolean =>\n  hasFixData(node) && fixableDeclarationKinds.has(node.kind);\n\n/**\n * Gets the indentation for the line containing a declaration.\n * @param sourceText Full source text.\n * @param start Start offset of the declaration.\n * @returns Leading indentation for the declaration line.\n * @example\n * ```typescript\n * const indent = getLineIndent(\"const a = 1;\", 0);\n * ```\n */\nconst getLineIndent = (sourceText: string, start: number): string => {\n  const lineStart = sourceText.lastIndexOf(\"\\n\", start - 1) + 1;\n  const linePrefix = sourceText.slice(lineStart, start);\n  let indentLength = 0;\n\n  while (indentLength < linePrefix.length) {\n    const currentCharacter = linePrefix[indentLength];\n\n    if (currentCharacter !== \"\\t\" && currentCharacter !== \" \") {\n      break;\n    }\n\n    indentLength += 1;\n  }\n\n  return linePrefix.slice(0, indentLength);\n};\n\n/**\n * Detects whether comments appear between declarators.\n * @param declarations Declarators from a single declaration statement.\n * @param sourceText Full source text.\n * @returns Whether comments appear between declarators.\n * @example\n * ```typescript\n * const blocked = hasSeparatorComment(declarations, sourceText);\n * ```\n */\nconst hasSeparatorComment = (\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  for (const [index, declaration] of declarations.entries()) {\n    const nextDeclaration = declarations[index + 1];\n\n    if (nextDeclaration === void 0) {\n      break;\n    }\n\n    if (!hasRange(declaration) || !hasRange(nextDeclaration)) {\n      return true;\n    }\n\n    const separatorText = sourceText.slice(\n      declaration.range[1],\n      nextDeclaration.range[0],\n    );\n\n    if (commentPattern.test(separatorText)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * Collects ranged declarators when every declarator exposes a range.\n * @param declarations Declarators from the declaration node.\n * @returns Declarators with confirmed ranges, or `undefined` when any range is missing.\n * @example\n * ```typescript\n * const ranged = getRangedDeclarations(node.declarations ?? []);\n * ```\n */\nconst getRangedDeclarations = (\n  declarations: readonly VariableDeclaratorNode[],\n): readonly RangedVariableDeclaratorNode[] | undefined => {\n  const rangedDeclarations: RangedVariableDeclaratorNode[] = [];\n\n  for (const declaration of declarations) {\n    if (!hasRange(declaration)) {\n      return void 0;\n    }\n\n    rangedDeclarations.push(declaration);\n  }\n\n  return rangedDeclarations;\n};\n\n/**\n * Determines whether a declaration can be safely rewritten.\n * @param node Declaration node to inspect.\n * @param declarations Declarators within the declaration.\n * @param sourceText Full source text.\n * @returns Whether the declaration is safe to autofix.\n * @example\n * ```typescript\n * const fixable = canFix(node, declarations, sourceText);\n * ```\n */\nconst canFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  const isFixable =\n    hasFixData(node) &&\n    hasFixableDeclarationKind(node) &&\n    !isTypeScriptAmbientDeclaration(node);\n\n  return (\n    isFixable &&\n    !isLoopInitializer(node) &&\n    !isWrappedExport(node) &&\n    !hasSeparatorComment(declarations, sourceText)\n  );\n};\n\n/**\n * Converts declarators into separate declaration statements.\n * @param node Fixable declaration node.\n * @param declarations Declarators that should be split.\n * @param sourceCode Source access wrapper.\n * @returns Replacement text for the full declaration.\n * @example\n * ```typescript\n * const replacement = buildReplacement(node, declarations, sourceCode);\n * ```\n */\nconst buildReplacement = (\n  node: FixableVariableDeclarationNode,\n  declarations: readonly RangedVariableDeclaratorNode[],\n  sourceCode: SourceCodeAccess,\n): string => {\n  const sourceText = getSourceText(sourceCode);\n  const indent = getLineIndent(sourceText, node.range[0]);\n  const lineSeparator = getLineSeparator(sourceText);\n\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`${lineSeparator}${indent}`);\n};\n\nexport {\n  buildReplacement,\n  canFix,\n  getRangedDeclarations,\n  getSourceCode,\n  getSourceText,\n};\n"]}

package/dist/domain/core/no-multiple-declarators/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAmFnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAwBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiFnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAwBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule.js

@@ -17,10 +17,9 @@ const createDeclarationFix = (node, declarations, sourceCode) => {
         return void 0;
     }
     const rangedDeclarations = getRangedDeclarations(declarations);
-    if (rangedDeclarations === void 0) {
-        return void 0;
-    }
-    return (fixer) => fixer.replaceTextRange(node.range, buildReplacement(node, rangedDeclarations, sourceCode));
+    return rangedDeclarations === void 0
+        ? void 0
+        : (fixer) => fixer.replaceTextRange(node.range, buildReplacement(node, rangedDeclarations, sourceCode));
 };
 /**
  * Reports declarations that contain more than one declarator.
@@ -71,4 +70,4 @@ const noMultipleDeclaratorsRule = {
     },
 };
 export { noMultipleDeclaratorsRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +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;AA6OnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"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;AAyOnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}