@codeperfect/eslint-plugin 3.0.0 → 3.2.0

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

@@ -0,0 +1,126 @@
+import * as ts from "typescript";
+import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+/**
+ * Checks whether an expression carries the member's declaration.
+ * @param expression Value being copied or serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be present.
+ * @param visitedExpressions Expressions already inspected across local return paths.
+ * @returns True when the expression carries this member rather than an unrelated matching shape.
+ * @example
+ * ```typescript
+ * const matches = carriesMember(expression, checker, member);
+ * ```
+ */
+const carriesMember = (expression, checker, member, visitedExpressions = new Set()) => {
+    if (visitedExpressions.has(expression)) {
+        return false;
+    }
+    visitedExpressions.add(expression);
+    const expressionSymbol = ts.isShorthandPropertyAssignment(expression.parent)
+        ? checker.getShorthandAssignmentValueSymbol(expression.parent)
+        : checker.getSymbolAtLocation(expression);
+    if (ts.isVariableDeclaration(member.hostDeclaration) &&
+        member.hostSymbol !== void 0 &&
+        expressionSymbol !== void 0 &&
+        isSameSymbol(resolveCanonicalSymbol(expressionSymbol, checker), resolveCanonicalSymbol(member.hostSymbol, checker))) {
+        return true;
+    }
+    const property = checker.getPropertyOfType(checker.getNonNullableType(checker.getTypeAtLocation(expression)), member.memberName);
+    const declaredProperty = checker.getPropertyOfType(checker.getTypeAtLocation(member.hostDeclaration), member.memberName);
+    if (property !== void 0 &&
+        (isSameSymbol(property, member.memberSymbol) ||
+            (declaredProperty !== void 0 && isSameSymbol(property, declaredProperty)))) {
+        return true;
+    }
+    if (!ts.isCallExpression(expression)) {
+        return false;
+    }
+    const declaration = checker
+        .getResolvedSignature(expression)
+        ?.getDeclaration();
+    const body = declaration !== void 0 && "body" in declaration ? declaration.body : void 0;
+    if (body === void 0) {
+        return false;
+    }
+    if (!ts.isBlock(body)) {
+        return carriesMember(body, checker, member, visitedExpressions);
+    }
+    const findReturnedMember = (node) => {
+        if (ts.isFunctionLike(node)) {
+            return false;
+        }
+        return ts.isReturnStatement(node)
+            ? node.expression !== void 0 &&
+                carriesMember(node.expression, checker, member, visitedExpressions)
+            : ts.forEachChild(node, findReturnedMember) === true;
+    };
+    return findReturnedMember(body);
+};
+/**
+ * Checks serialized property types without following method signatures.
+ * @param type Type whose enumerable data may be serialized.
+ * @param checker TypeScript type checker.
+ * @param member Member whose declaration must be reachable.
+ * @param visitedTypes Types already searched.
+ * @param depth Remaining nested data depth.
+ * @returns Whether the serialized data contains the member declaration.
+ * @example
+ * ```typescript
+ * const used = containsSerializedMember(type, checker, member, new Set(), 5);
+ * ```
+ */
+const containsSerializedMember = (type, checker, member, visitedTypes, depth) => {
+    if (depth < 0 || visitedTypes.has(type)) {
+        return false;
+    }
+    visitedTypes.add(type);
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((part) => containsSerializedMember(part, checker, member, visitedTypes, depth));
+    }
+    if ((type.flags & ts.TypeFlags.Object) === 0) {
+        return false;
+    }
+    const property = checker.getPropertyOfType(type, member.memberName);
+    if (property !== void 0 && isSameSymbol(property, member.memberSymbol)) {
+        return true;
+    }
+    const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+    return elementType === void 0
+        ? checker
+            .getPropertiesOfType(type)
+            .some((nestedProperty) => (nestedProperty.flags & ts.SymbolFlags.Method) === 0 &&
+            containsSerializedMember(checker.getTypeOfSymbolAtLocation(nestedProperty, member.declaration), checker, member, visitedTypes, depth - 1))
+        : containsSerializedMember(elementType, checker, member, visitedTypes, depth - 1);
+};
+/**
+ * Checks whether an expression contains a value carrying the member.
+ * @param expression Value expression to inspect.
+ * @param checker TypeScript type checker.
+ * @param member Member whose value is being searched for.
+ * @returns True when the expression contains the member or its host value.
+ * @example
+ * ```typescript
+ * const carries = expressionCarriesMemberValue(value, checker, member);
+ * ```
+ */
+const expressionCarriesMemberValue = (expression, checker, member) => {
+    if (carriesMember(expression, checker, member) ||
+        containsSerializedMember(checker.getTypeAtLocation(expression), checker, member, new Set(), 5)) {
+        return true;
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        return expression.properties.some((property) => {
+            return ts.isSpreadAssignment(property)
+                ? expressionCarriesMemberValue(property.expression, checker, member)
+                : (ts.isPropertyAssignment(property) &&
+                    expressionCarriesMemberValue(property.initializer, checker, member)) ||
+                    (ts.isShorthandPropertyAssignment(property) &&
+                        expressionCarriesMemberValue(property.name, checker, member));
+        });
+    }
+    return (ts.isArrayLiteralExpression(expression) &&
+        expression.elements.some((element) => expressionCarriesMemberValue(element, checker, member)));
+};
+export { carriesMember, containsSerializedMember, expressionCarriesMemberValue, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-usage-value-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-usage-value-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\nimport type { PublicMember } from \"./member-declaration-utilities\";\n\nimport {\n  isSameSymbol,\n  resolveCanonicalSymbol,\n} from \"../no-unused-exports/no-unused-exports-symbol-utilities\";\n\n/**\n * Checks whether an expression carries the member's declaration.\n * @param expression Value being copied or serialized.\n * @param checker TypeScript type checker.\n * @param member Member whose declaration must be present.\n * @param visitedExpressions Expressions already inspected across local return paths.\n * @returns True when the expression carries this member rather than an unrelated matching shape.\n * @example\n * ```typescript\n * const matches = carriesMember(expression, checker, member);\n * ```\n */\nconst carriesMember = (\n  expression: ts.Expression,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  visitedExpressions: Set<ts.Expression> = new Set(),\n): boolean => {\n  if (visitedExpressions.has(expression)) {\n    return false;\n  }\n  visitedExpressions.add(expression);\n\n  const expressionSymbol = ts.isShorthandPropertyAssignment(expression.parent)\n    ? checker.getShorthandAssignmentValueSymbol(expression.parent)\n    : checker.getSymbolAtLocation(expression);\n  if (\n    ts.isVariableDeclaration(member.hostDeclaration) &&\n    member.hostSymbol !== void 0 &&\n    expressionSymbol !== void 0 &&\n    isSameSymbol(\n      resolveCanonicalSymbol(expressionSymbol, checker),\n      resolveCanonicalSymbol(member.hostSymbol, checker),\n    )\n  ) {\n    return true;\n  }\n\n  const property = checker.getPropertyOfType(\n    checker.getNonNullableType(checker.getTypeAtLocation(expression)),\n    member.memberName,\n  );\n  const declaredProperty = checker.getPropertyOfType(\n    checker.getTypeAtLocation(member.hostDeclaration),\n    member.memberName,\n  );\n\n  if (\n    property !== void 0 &&\n    (isSameSymbol(property, member.memberSymbol) ||\n      (declaredProperty !== void 0 && isSameSymbol(property, declaredProperty)))\n  ) {\n    return true;\n  }\n\n  if (!ts.isCallExpression(expression)) {\n    return false;\n  }\n\n  const declaration = checker\n    .getResolvedSignature(expression)\n    ?.getDeclaration();\n  const body =\n    declaration !== void 0 && \"body\" in declaration ? declaration.body : void 0;\n  if (body === void 0) {\n    return false;\n  }\n  if (!ts.isBlock(body)) {\n    return carriesMember(body, checker, member, visitedExpressions);\n  }\n\n  const findReturnedMember = (node: ts.Node): boolean => {\n    if (ts.isFunctionLike(node)) {\n      return false;\n    }\n    return ts.isReturnStatement(node)\n      ? node.expression !== void 0 &&\n          carriesMember(node.expression, checker, member, visitedExpressions)\n      : ts.forEachChild(node, findReturnedMember) === true;\n  };\n\n  return findReturnedMember(body);\n};\n\n/**\n * Checks serialized property types without following method signatures.\n * @param type Type whose enumerable data may be serialized.\n * @param checker TypeScript type checker.\n * @param member Member whose declaration must be reachable.\n * @param visitedTypes Types already searched.\n * @param depth Remaining nested data depth.\n * @returns Whether the serialized data contains the member declaration.\n * @example\n * ```typescript\n * const used = containsSerializedMember(type, checker, member, new Set(), 5);\n * ```\n */\nconst containsSerializedMember = (\n  type: ts.Type,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n  visitedTypes: Set<ts.Type>,\n  depth: number,\n): boolean => {\n  if (depth < 0 || visitedTypes.has(type)) {\n    return false;\n  }\n  visitedTypes.add(type);\n\n  if (type.isUnionOrIntersection()) {\n    return type.types.some((part) =>\n      containsSerializedMember(part, checker, member, visitedTypes, depth),\n    );\n  }\n\n  if ((type.flags & ts.TypeFlags.Object) === 0) {\n    return false;\n  }\n\n  const property = checker.getPropertyOfType(type, member.memberName);\n  if (property !== void 0 && isSameSymbol(property, member.memberSymbol)) {\n    return true;\n  }\n\n  const elementType = checker.getIndexTypeOfType(type, ts.IndexKind.Number);\n  return elementType === void 0\n    ? checker\n        .getPropertiesOfType(type)\n        .some(\n          (nestedProperty) =>\n            (nestedProperty.flags & ts.SymbolFlags.Method) === 0 &&\n            containsSerializedMember(\n              checker.getTypeOfSymbolAtLocation(\n                nestedProperty,\n                member.declaration,\n              ),\n              checker,\n              member,\n              visitedTypes,\n              depth - 1,\n            ),\n        )\n    : containsSerializedMember(\n        elementType,\n        checker,\n        member,\n        visitedTypes,\n        depth - 1,\n      );\n};\n\n/**\n * Checks whether an expression contains a value carrying the member.\n * @param expression Value expression to inspect.\n * @param checker TypeScript type checker.\n * @param member Member whose value is being searched for.\n * @returns True when the expression contains the member or its host value.\n * @example\n * ```typescript\n * const carries = expressionCarriesMemberValue(value, checker, member);\n * ```\n */\nconst expressionCarriesMemberValue = (\n  expression: ts.Expression,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  if (\n    carriesMember(expression, checker, member) ||\n    containsSerializedMember(\n      checker.getTypeAtLocation(expression),\n      checker,\n      member,\n      new Set(),\n      5,\n    )\n  ) {\n    return true;\n  }\n\n  if (ts.isObjectLiteralExpression(expression)) {\n    return expression.properties.some((property) => {\n      return ts.isSpreadAssignment(property)\n        ? expressionCarriesMemberValue(property.expression, checker, member)\n        : (ts.isPropertyAssignment(property) &&\n            expressionCarriesMemberValue(\n              property.initializer,\n              checker,\n              member,\n            )) ||\n            (ts.isShorthandPropertyAssignment(property) &&\n              expressionCarriesMemberValue(property.name, checker, member));\n    });\n  }\n\n  return (\n    ts.isArrayLiteralExpression(expression) &&\n    expression.elements.some((element) =>\n      expressionCarriesMemberValue(element, checker, member),\n    )\n  );\n};\n\nexport {\n  carriesMember,\n  containsSerializedMember,\n  expressionCarriesMemberValue,\n};\n"]}

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

@@ -0,0 +1,43 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
+import type { MemberUsageAdapter } from "./member-usage-utilities.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.
+ * @param usageAdapters Adapters that recognize usage outside TypeScript source.
+ * @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, usageAdapters?: readonly MemberUsageAdapter[]) => 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;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AASnE,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,0BAA0B,GAC9B,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,gBAAgB,cAAc,EAC9B,gBAAe,SAAS,kBAAkB,EAAO,4DAUlD,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,52 @@
+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.
+ * @param usageAdapters Adapters that recognize usage outside TypeScript source.
+ * @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, usageAdapters = []) => {
+    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, usageAdapters));
+};
+/**
+ * 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVtYmVyLXV0aWxpdGllcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vYXJjaGl0ZWN0dXJlL25vLXVudXNlZC1wdWJsaWMtbWVtYmVycy9tZW1iZXItdXRpbGl0aWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxPQUFPLElBQUksTUFBTSxXQUFXLENBQUM7QUFDN0IsT0FBTyxLQUFLLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFLakMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDdEUsT0FBTyxFQUNMLGVBQWUsRUFDZixpQkFBaUIsR0FDbEIsTUFBTSwrQkFBK0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUk5RDs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSwwQkFBMEIsR0FBRyxDQUNqQyxVQUF5QixFQUN6QixPQUFtQixFQUNuQixLQUEyQixFQUMzQixRQUFnQixFQUNoQixjQUE4QixFQUM5QixnQkFBK0MsRUFBRSxFQUNqRCxFQUFFO0lBQ0YsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDO0lBRXpDLE9BQU8sb0JBQW9CLENBQUMsVUFBVSxFQUFFLE9BQU8sRUFBRSxjQUFjLENBQUMsQ0FBQyxNQUFNLENBQ3JFLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FDVCxDQUFDLGVBQWUsQ0FBQyxPQUFPLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLENBQUMsVUFBVSxDQUFDO1FBQzdELENBQUMsaUJBQWlCLENBQUMsT0FBTyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxDQUFDLFlBQVksQ0FBQztRQUNqRSxDQUFDLGtCQUFrQixDQUFDLE9BQU8sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxhQUFhLENBQUMsQ0FDdkUsQ0FBQztBQUNKLENBQUMsQ0FBQztBQUVGOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sb0JBQW9CLEdBQUcsQ0FDM0IsT0FBbUIsRUFDbkIsUUFBZ0IsRUFDVyxFQUFFLENBQzdCLE9BQU87S0FDSixjQUFjLEVBQUU7S0FDaEIsSUFBSSxDQUNILENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FDYixJQUFJLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLEVBQUU7SUFDL0MsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FDdkMsQ0FBQztBQUVOOzs7Ozs7OztHQVFHO0FBQ0gsTUFBTSxjQUFjLEdBQUcsQ0FBQyxPQUFtQixFQUFVLEVBQUUsQ0FDckQsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsbUJBQW1CLEVBQUUsQ0FBQyxDQUFDO0FBRTlDLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxvQkFBb0IsRUFBRSxjQUFjLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVTTGludFV0aWxzIH0gZnJvbSBcIkB0eXBlc2NyaXB0LWVzbGludC91dGlsc1wiO1xuaW1wb3J0IHBhdGggZnJvbSBcIm5vZGU6cGF0aFwiO1xuaW1wb3J0ICogYXMgdHMgZnJvbSBcInR5cGVzY3JpcHRcIjtcblxuaW1wb3J0IHR5cGUgeyBOb1VudXNlZEV4cG9ydHNTdGF0ZSB9IGZyb20gXCIuLi9uby11bnVzZWQtZXhwb3J0cy90eXBlc1wiO1xuaW1wb3J0IHR5cGUgeyBNZW1iZXJVc2FnZUFkYXB0ZXIgfSBmcm9tIFwiLi9tZW1iZXItdXNhZ2UtdXRpbGl0aWVzXCI7XG5cbmltcG9ydCB7IGNvbGxlY3RQdWJsaWNNZW1iZXJzIH0gZnJvbSBcIi4vbWVtYmVyLWRlY2xhcmF0aW9uLXV0aWxpdGllc1wiO1xuaW1wb3J0IHtcbiAgaXNQdWJsaWNBcGlIb3N0LFxuICBpc1B1YmxpY0FwaU1lbWJlcixcbn0gZnJvbSBcIi4vbWVtYmVyLXB1YmxpYy1hcGktdXRpbGl0aWVzXCI7XG5pbXBvcnQgeyBoYXNQcm9kdWN0aW9uVXNhZ2UgfSBmcm9tIFwiLi9tZW1iZXItdXNhZ2UtdXRpbGl0aWVzXCI7XG5cbnR5cGUgUGFyc2VyU2VydmljZXMgPSBSZXR1cm5UeXBlPHR5cGVvZiBFU0xpbnRVdGlscy5nZXRQYXJzZXJTZXJ2aWNlcz47XG5cbi8qKlxuICogQ29sbGVjdHMgdW51c2VkIGRpcmVjdCBwdWJsaWMgbWVtYmVycyBmcm9tIGEgbGludGVkIHNvdXJjZSBmaWxlLlxuICogQHBhcmFtIHNvdXJjZUZpbGUgU291cmNlIGZpbGUgYmVpbmcgbGludGVkLlxuICogQHBhcmFtIHByb2dyYW0gVHlwZVNjcmlwdCBwcm9qZWN0IHByb2dyYW0uXG4gKiBAcGFyYW0gc3RhdGUgTm9ybWFsaXplZCBwdWJsaWMgQVBJIGFuZCB0ZXN0IHBhdHRlcm5zLlxuICogQHBhcmFtIHJlcG9Sb290IFJvb3QgZGlyZWN0b3J5IHVzZWQgZm9yIGdsb2IgbWF0Y2hpbmcuXG4gKiBAcGFyYW0gcGFyc2VyU2VydmljZXMgVHlwZVNjcmlwdCBhbmQgRVNUcmVlIG5vZGUgbWFwcy5cbiAqIEBwYXJhbSB1c2FnZUFkYXB0ZXJzIEFkYXB0ZXJzIHRoYXQgcmVjb2duaXplIHVzYWdlIG91dHNpZGUgVHlwZVNjcmlwdCBzb3VyY2UuXG4gKiBAcmV0dXJucyBNZW1iZXJzIG91dHNpZGUgdGhlIHB1YmxpYyBBUEkgd2l0aCBubyBwcm9kdWN0aW9uIHVzZS5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCB1bnVzZWQgPSBjb2xsZWN0VW51c2VkUHVibGljTWVtYmVycyhzb3VyY2VGaWxlLCBwcm9ncmFtLCBzdGF0ZSwgcmVwb1Jvb3QsIHNlcnZpY2VzKTtcbiAqIGBgYFxuICovXG5jb25zdCBjb2xsZWN0VW51c2VkUHVibGljTWVtYmVycyA9IChcbiAgc291cmNlRmlsZTogdHMuU291cmNlRmlsZSxcbiAgcHJvZ3JhbTogdHMuUHJvZ3JhbSxcbiAgc3RhdGU6IE5vVW51c2VkRXhwb3J0c1N0YXRlLFxuICByZXBvUm9vdDogc3RyaW5nLFxuICBwYXJzZXJTZXJ2aWNlczogUGFyc2VyU2VydmljZXMsXG4gIHVzYWdlQWRhcHRlcnM6IHJlYWRvbmx5IE1lbWJlclVzYWdlQWRhcHRlcltdID0gW10sXG4pID0+IHtcbiAgY29uc3QgY2hlY2tlciA9IHByb2dyYW0uZ2V0VHlwZUNoZWNrZXIoKTtcblxuICByZXR1cm4gY29sbGVjdFB1YmxpY01lbWJlcnMoc291cmNlRmlsZSwgY2hlY2tlciwgcGFyc2VyU2VydmljZXMpLmZpbHRlcihcbiAgICAobWVtYmVyKSA9PlxuICAgICAgIWlzUHVibGljQXBpSG9zdChwcm9ncmFtLCBzdGF0ZSwgcmVwb1Jvb3QsIG1lbWJlci5ob3N0U3ltYm9sKSAmJlxuICAgICAgIWlzUHVibGljQXBpTWVtYmVyKHByb2dyYW0sIHN0YXRlLCByZXBvUm9vdCwgbWVtYmVyLm1lbWJlclN5bWJvbCkgJiZcbiAgICAgICFoYXNQcm9kdWN0aW9uVXNhZ2UocHJvZ3JhbSwgc3RhdGUsIHJlcG9Sb290LCBtZW1iZXIsIHVzYWdlQWRhcHRlcnMpLFxuICApO1xufTtcblxuLyoqXG4gKiBGaW5kcyB0aGUgcHJvZ3JhbSBzb3VyY2UgZmlsZSBtYXRjaGluZyBhbiBhYnNvbHV0ZSBsaW50IGZpbGVuYW1lLlxuICogQHBhcmFtIHByb2dyYW0gVHlwZVNjcmlwdCBwcm9qZWN0IHByb2dyYW0uXG4gKiBAcGFyYW0gZmlsZW5hbWUgQWJzb2x1dGUgZmlsZW5hbWUgdG8gZmluZC5cbiAqIEByZXR1cm5zIE1hdGNoaW5nIHNvdXJjZSBmaWxlIHdoZW4gaXQgYmVsb25ncyB0byB0aGUgcHJvZ3JhbS5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBzb3VyY2VGaWxlID0gZ2V0UHJvZ3JhbVNvdXJjZUZpbGUocHJvZ3JhbSwgY29udGV4dC5maWxlbmFtZSk7XG4gKiBgYGBcbiAqL1xuY29uc3QgZ2V0UHJvZ3JhbVNvdXJjZUZpbGUgPSAoXG4gIHByb2dyYW06IHRzLlByb2dyYW0sXG4gIGZpbGVuYW1lOiBzdHJpbmcsXG4pOiB0cy5Tb3VyY2VGaWxlIHwgdW5kZWZpbmVkID0+XG4gIHByb2dyYW1cbiAgICAuZ2V0U291cmNlRmlsZXMoKVxuICAgIC5maW5kKFxuICAgICAgKHNvdXJjZUZpbGUpID0+XG4gICAgICAgIHBhdGgucmVzb2x2ZShzb3VyY2VGaWxlLmZpbGVOYW1lKS50b0xvd2VyQ2FzZSgpID09PVxuICAgICAgICBwYXRoLnJlc29sdmUoZmlsZW5hbWUpLnRvTG93ZXJDYXNlKCksXG4gICAgKTtcblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBhYnNvbHV0ZSBwcm9qZWN0IHJvb3QgZnJvbSB0aGUgVHlwZVNjcmlwdCBwcm9ncmFtLlxuICogQHBhcmFtIHByb2dyYW0gVHlwZVNjcmlwdCBwcm9qZWN0IHByb2dyYW0uXG4gKiBAcmV0dXJucyBBYnNvbHV0ZSBUeXBlU2NyaXB0IHByb2plY3Qgcm9vdC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBwcm9qZWN0Um9vdCA9IGdldFByb2plY3RSb290KHByb2dyYW0pO1xuICogYGBgXG4gKi9cbmNvbnN0IGdldFByb2plY3RSb290ID0gKHByb2dyYW06IHRzLlByb2dyYW0pOiBzdHJpbmcgPT5cbiAgcGF0aC5yZXNvbHZlKHByb2dyYW0uZ2V0Q3VycmVudERpcmVjdG9yeSgpKTtcblxuZXhwb3J0IHsgY29sbGVjdFVudXNlZFB1YmxpY01lbWJlcnMsIGdldFByb2dyYW1Tb3VyY2VGaWxlLCBnZXRQcm9qZWN0Um9vdCB9O1xuIl19

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

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+import type { MemberUsageAdapter } from "./member-usage-utilities.js";
+/**
+ * Creates the rule listener with optional framework-specific member usage adapters.
+ * @param usageAdapters Adapters that recognize uses outside TypeScript source.
+ * @returns ESLint's create listener for the rule.
+ * @example
+ * ```typescript
+ * const create = createNoUnusedPublicMembersListener();
+ * ```
+ */
+declare const createNoUnusedPublicMembersListener: (usageAdapters?: readonly MemberUsageAdapter[]) => ((context: Rule.RuleContext) => Rule.RuleListener);
+/** ESLint rule flagging public members unused by production code. */
+declare const noUnusedPublicMembersRule: Rule.RuleModule;
+export { createNoUnusedPublicMembersListener, 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;AAInC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAenE;;;;;;;;GAQG;AACH,QAAA,MAAM,mCAAmC,GAErC,gBAAe,SAAS,kBAAkB,EAAO,KAChD,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,KAAK,IAAI,CAAC,YAAY,CA8CnD,CAAC;AAEJ,qEAAqE;AACrE,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UA0CrC,CAAC;AAEF,OAAO,EAAE,mCAAmC,EAAE,yBAAyB,EAAE,CAAC"}

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

@@ -0,0 +1,88 @@
+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";
+/**
+ * Creates the rule listener with optional framework-specific member usage adapters.
+ * @param usageAdapters Adapters that recognize uses outside TypeScript source.
+ * @returns ESLint's create listener for the rule.
+ * @example
+ * ```typescript
+ * const create = createNoUnusedPublicMembersListener();
+ * ```
+ */
+const createNoUnusedPublicMembersListener = (usageAdapters = []) => (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, usageAdapters)) {
+                context.report({
+                    data: { hostName: member.hostName, memberName: member.memberName },
+                    messageId: "unusedPublicMember",
+                    node: member.reportNode,
+                });
+            }
+        },
+    };
+};
+/** ESLint rule flagging public members unused by production code. */
+const noUnusedPublicMembersRule = {
+    create: createNoUnusedPublicMembersListener(),
+    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 { createNoUnusedPublicMembersListener, noUnusedPublicMembersRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/comment-utilities.js

@@ -87,9 +87,9 @@ const getJsdocComment = (sourceCode, node) => {
 const getCommentText = (sourceCode, comment) => {
     const start = comment.range?.[0];
     const end = comment.range?.[1];
-    return typeof start !== "number" || typeof end !== "number"
-        ? ""
-        : sourceCode.text.slice(start, end);
+    return typeof start === "number" && typeof end === "number"
+        ? sourceCode.text.slice(start, end)
+        : "";
 };
 export { getCommentText, getJsdocComment };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/parameter-tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAmG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAavB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAgG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAavB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/parameter-tags.js

@@ -70,7 +70,7 @@ const getMemberName = (normalized) => {
     }
     const basename = normalized.slice(0, dotIndex);
     const memberPath = normalized.slice(dotIndex + 1).trim();
-    return memberPath.length > 0 ? { basename, memberPath } : void 0;
+    return memberPath.length > 0 ? { basename } : void 0;
 };
 /**
  * Parses a `@param` tag line into a member tag when applicable.
@@ -93,4 +93,4 @@ const parseParameterTagLine = (line) => {
         : { basename: member.basename, fullName: normalized, line };
 };
 export { parseParameterTagLine };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/parameter-utilities.js

@@ -48,9 +48,9 @@ const getParameterIdentifier = (node) => {
     }
     const identifier = resolved;
     const { name } = identifier;
-    return typeof name !== "string" || identifier.type !== "Identifier"
-        ? void 0
-        : { ...identifier, name };
+    return typeof name === "string" && identifier.type === "Identifier"
+        ? { ...identifier, name }
+        : void 0;
 };
 /**
  * Gets parameter info for the given node.
@@ -117,4 +117,4 @@ const getParameterTypeLookup = (node) => {
  */
 const isNamedTypeReference = (typeAnnotation) => typeAnnotation?.type === "TSTypeReference";
 export { getParameterTypeLookup, isNamedTypeReference };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"AAuDA;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAAG,CAC5B,IAAoB,EACY,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,cAAc,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,CAAC,IAAa,EAAW,EAAE;IACtD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,SAAS,GAAG,IAA0B,CAAC;IAE7C,IAAI,SAAS,CAAC,QAAQ,KAAK,KAAK,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED,IAAI,SAAS,CAAC,SAAS,KAAK,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC,SAAS,CAAC;IAC7B,CAAC;IAED,OAAO,SAAS,CAAC,IAAI,KAAK,mBAAmB,IAAI,SAAS,CAAC,IAAI,KAAK,KAAK,CAAC;QACxE,CAAC,CAAC,SAAS,CAAC,IAAI;QAChB,CAAC,CAAC,IAAI,CAAC;AACX,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,sBAAsB,GAAG,CAC7B,IAAa,EACoB,EAAE;IACnC,MAAM,QAAQ,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAE5C,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACtD,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,UAAU,GAAG,QAA0B,CAAC;IAC9C,MAAM,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC;IAE5B,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,UAAU,CAAC,IAAI,KAAK,YAAY;QACjE,CAAC,CAAC,KAAK,CAAC;QACR,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,IAAI,EAAE,CAAC;AAC9B,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAG,CAAC,IAAa,EAA6B,EAAE;IACpE,MAAM,UAAU,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAEhD,IAAI,UAAU,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,cAAc,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAEzD,OAAO,cAAc,KAAK,KAAK,CAAC;QAC9B,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE;QAC3B,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC;AAChD,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,aAAa,GAAG,CAAC,IAAa,EAAa,EAAE;IACjD,IAAI,IAAI,KAAK,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC9C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,SAAS,GAAG,IAAwB,CAAC;IAE3C,OAAO,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AACjE,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,sBAAsB,GAAG,CAC7B,IAAe,EACkB,EAAE;IACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAA8B,CAAC;IAErD,KAAK,MAAM,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,MAAM,IAAI,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;QAEzC,IAAI,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC,cAAc,KAAK,KAAK,CAAC,EAAE,CAAC;YACtD,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,CAC3B,cAA8C,EACrC,EAAE,CAAC,cAAc,EAAE,IAAI,KAAK,iBAAiB,CAAC;AAEzD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { TypeAnnotationNode } from \"./types\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n}\n\n/** Type definition for rule data. */\ninterface IdentifierNode {\n  /** Name helper value. */\n  name?: string;\n\n  /** Type helper value. */\n  type?: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface NamedIdentifierNode extends IdentifierNode {\n  /** Name field value. */\n  name: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left helper value. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n\n  /** Type helper value. */\n  type?: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterInfo {\n  /** Name field value. */\n  name: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: TypeAnnotationNode;\n}\n\n/**\n * Gets a type annotation node from an identifier.\n * @param node Identifier node to inspect.\n * @returns The type annotation node when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(identifier);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: IdentifierNode,\n): TypeAnnotationNode | undefined => node.typeAnnotation?.typeAnnotation;\n\n/**\n * Defines resolveParameterNode.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * resolveParameterNode();\n * ```\n */\nconst resolveParameterNode = (node: unknown): unknown => {\n  if (node === null || typeof node !== \"object\") {\n    return node;\n  }\n\n  const container = node as ParameterContainer;\n\n  if (container.argument !== void 0) {\n    return container.argument;\n  }\n\n  if (container.parameter !== void 0) {\n    return container.parameter;\n  }\n\n  return container.type === \"AssignmentPattern\" && container.left !== void 0\n    ? container.left\n    : node;\n};\n\n/**\n * Gets the parameter identifier for a parameter node.\n * @param node Parameter node to inspect.\n * @returns The identifier node when present.\n * @example\n * ```typescript\n * const identifier = getParameterIdentifier(node);\n * ```\n */\nconst getParameterIdentifier = (\n  node: unknown,\n): NamedIdentifierNode | undefined => {\n  const resolved = resolveParameterNode(node);\n\n  if (resolved === null || typeof resolved !== \"object\") {\n    return void 0;\n  }\n\n  const identifier = resolved as IdentifierNode;\n  const { name } = identifier;\n\n  return typeof name !== \"string\" || identifier.type !== \"Identifier\"\n    ? void 0\n    : { ...identifier, name };\n};\n\n/**\n * Gets parameter info for the given node.\n * @param node Parameter node to inspect.\n * @returns Parameter info when available.\n * @example\n * ```typescript\n * const info = getParameterInfo(node);\n * ```\n */\nconst getParameterInfo = (node: unknown): ParameterInfo | undefined => {\n  const identifier = getParameterIdentifier(node);\n\n  if (identifier === void 0) {\n    return void 0;\n  }\n\n  const typeAnnotation = getTypeAnnotationNode(identifier);\n\n  return typeAnnotation === void 0\n    ? { name: identifier.name }\n    : { name: identifier.name, typeAnnotation };\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Builds a lookup of parameter names to type annotations.\n * @param node Function-like node.\n * @returns Lookup of parameter names to annotations.\n * @example\n * ```typescript\n * const lookup = getParameterTypeLookup(node);\n * ```\n */\nconst getParameterTypeLookup = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> => {\n  const lookup = new Map<string, TypeAnnotationNode>();\n\n  for (const parameter of getParameters(node)) {\n    const info = getParameterInfo(parameter);\n\n    if (info !== void 0 && info.typeAnnotation !== void 0) {\n      lookup.set(info.name, info.typeAnnotation);\n    }\n  }\n\n  return lookup;\n};\n\n/**\n * Checks whether a type annotation is a named type reference.\n * @param typeAnnotation Type annotation to inspect.\n * @returns True when the annotation is a named reference.\n * @example\n * ```typescript\n * const ok = isNamedTypeReference(annotation);\n * ```\n */\nconst isNamedTypeReference = (\n  typeAnnotation: TypeAnnotationNode | undefined,\n): boolean => typeAnnotation?.type === \"TSTypeReference\";\n\nexport { getParameterTypeLookup, isNamedTypeReference };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { TypeAnnotationNode } from \"./types\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n}\n\n/** Type definition for rule data. */\ninterface IdentifierNode {\n  /** Name helper value. */\n  name?: string;\n\n  /** Type helper value. */\n  type?: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface NamedIdentifierNode extends IdentifierNode {\n  /** Name field value. */\n  name: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left helper value. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n\n  /** Type helper value. */\n  type?: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterInfo {\n  /** Name field value. */\n  name: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: TypeAnnotationNode;\n}\n\n/**\n * Gets a type annotation node from an identifier.\n * @param node Identifier node to inspect.\n * @returns The type annotation node when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(identifier);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: IdentifierNode,\n): TypeAnnotationNode | undefined => node.typeAnnotation?.typeAnnotation;\n\n/**\n * Defines resolveParameterNode.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * resolveParameterNode();\n * ```\n */\nconst resolveParameterNode = (node: unknown): unknown => {\n  if (node === null || typeof node !== \"object\") {\n    return node;\n  }\n\n  const container = node as ParameterContainer;\n\n  if (container.argument !== void 0) {\n    return container.argument;\n  }\n\n  if (container.parameter !== void 0) {\n    return container.parameter;\n  }\n\n  return container.type === \"AssignmentPattern\" && container.left !== void 0\n    ? container.left\n    : node;\n};\n\n/**\n * Gets the parameter identifier for a parameter node.\n * @param node Parameter node to inspect.\n * @returns The identifier node when present.\n * @example\n * ```typescript\n * const identifier = getParameterIdentifier(node);\n * ```\n */\nconst getParameterIdentifier = (\n  node: unknown,\n): NamedIdentifierNode | undefined => {\n  const resolved = resolveParameterNode(node);\n\n  if (resolved === null || typeof resolved !== \"object\") {\n    return void 0;\n  }\n\n  const identifier = resolved as IdentifierNode;\n  const { name } = identifier;\n\n  return typeof name === \"string\" && identifier.type === \"Identifier\"\n    ? { ...identifier, name }\n    : void 0;\n};\n\n/**\n * Gets parameter info for the given node.\n * @param node Parameter node to inspect.\n * @returns Parameter info when available.\n * @example\n * ```typescript\n * const info = getParameterInfo(node);\n * ```\n */\nconst getParameterInfo = (node: unknown): ParameterInfo | undefined => {\n  const identifier = getParameterIdentifier(node);\n\n  if (identifier === void 0) {\n    return void 0;\n  }\n\n  const typeAnnotation = getTypeAnnotationNode(identifier);\n\n  return typeAnnotation === void 0\n    ? { name: identifier.name }\n    : { name: identifier.name, typeAnnotation };\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Builds a lookup of parameter names to type annotations.\n * @param node Function-like node.\n * @returns Lookup of parameter names to annotations.\n * @example\n * ```typescript\n * const lookup = getParameterTypeLookup(node);\n * ```\n */\nconst getParameterTypeLookup = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> => {\n  const lookup = new Map<string, TypeAnnotationNode>();\n\n  for (const parameter of getParameters(node)) {\n    const info = getParameterInfo(parameter);\n\n    if (info !== void 0 && info.typeAnnotation !== void 0) {\n      lookup.set(info.name, info.typeAnnotation);\n    }\n  }\n\n  return lookup;\n};\n\n/**\n * Checks whether a type annotation is a named type reference.\n * @param typeAnnotation Type annotation to inspect.\n * @returns True when the annotation is a named reference.\n * @example\n * ```typescript\n * const ok = isNamedTypeReference(annotation);\n * ```\n */\nconst isNamedTypeReference = (\n  typeAnnotation: TypeAnnotationNode | undefined,\n): boolean => typeAnnotation?.type === \"TSTypeReference\";\n\nexport { getParameterTypeLookup, isNamedTypeReference };\n"]}

package/dist/domain/docs/no-interface-member-docs/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA+PnC,+EAA+E;AAC/E,QAAA,MAAM,kCAAkC,EAAE,IAAI,CAAC,UAqC9C,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgPnC,+EAA+E;AAC/E,QAAA,MAAM,kCAAkC,EAAE,IAAI,CAAC,UAqC9C,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}