@codeperfect/eslint-plugin 2.11.0 → 3.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

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

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

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

@@ -0,0 +1,16 @@
+import * as ts from "typescript";
+import type { PublicMember } from "./member-declaration-utilities.js";
+/**
+ * Collects member symbols linked by implemented or inherited types.
+ * @param program TypeScript project program.
+ * @param checker TypeScript type checker.
+ * @param targetMember Member whose related contracts are being found.
+ * @returns Related member symbols from contract declarations.
+ * @example
+ * ```typescript
+ * const symbols = collectHeritageMemberSymbols(program, checker, member);
+ * ```
+ */
+declare const collectHeritageMemberSymbols: (program: ts.Program, checker: ts.TypeChecker, targetMember: PublicMember) => ts.Symbol[];
+export { collectHeritageMemberSymbols };
+//# sourceMappingURL=member-contract-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-contract-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-contract-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAyDnE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,4BAA4B,GAChC,SAAS,EAAE,CAAC,OAAO,EACnB,SAAS,EAAE,CAAC,WAAW,EACvB,cAAc,YAAY,KACzB,EAAE,CAAC,MAAM,EA+EX,CAAC;AAEF,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

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

@@ -0,0 +1,102 @@
+import * as ts from "typescript";
+import { isSameSymbol, resolveCanonicalSymbol, } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+import { isSupportedMember } from "./member-host-utilities.js";
+/**
+ * Extracts the static key from a supported member declaration.
+ * @param declaration TypeScript member node to inspect.
+ * @returns Static name when the declaration is supported.
+ * @example
+ * ```typescript
+ * const name = getDeclaredMemberName(memberDeclaration);
+ * ```
+ */
+const getDeclaredMemberName = (declaration) => {
+    if (!isSupportedMember(declaration)) {
+        return void 0;
+    }
+    const name = declaration.name;
+    return name !== void 0 &&
+        (ts.isIdentifier(name) || ts.isStringLiteralLike(name))
+        ? name.text
+        : void 0;
+};
+/**
+ * Gets the symbol for one direct member declaration.
+ * @param checker TypeScript type checker.
+ * @param declaration TypeScript syntax node naming the member.
+ * @param memberName Static member name.
+ * @returns Member symbol when available.
+ * @example
+ * ```typescript
+ * const symbol = getDeclaredMemberSymbol(checker, declaration, "run");
+ * ```
+ */
+const getDeclaredMemberSymbol = (checker, declaration, memberName) => {
+    const name = declaration.name;
+    return name === void 0
+        ? void 0
+        : (checker.getSymbolAtLocation(name) ??
+            checker.getPropertyOfType(checker.getTypeAtLocation(declaration.parent), memberName));
+};
+/**
+ * Collects member symbols linked by implemented or inherited types.
+ * @param program TypeScript project program.
+ * @param checker TypeScript type checker.
+ * @param targetMember Member whose related contracts are being found.
+ * @returns Related member symbols from contract declarations.
+ * @example
+ * ```typescript
+ * const symbols = collectHeritageMemberSymbols(program, checker, member);
+ * ```
+ */
+const collectHeritageMemberSymbols = (program, checker, targetMember) => {
+    const relatedSymbols = [];
+    const targetSymbol = resolveCanonicalSymbol(targetMember.memberSymbol, checker);
+    const addSymbol = (candidate) => {
+        if (candidate !== void 0 &&
+            relatedSymbols.every((symbol) => !isSameSymbol(symbol, candidate))) {
+            relatedSymbols.push(candidate);
+        }
+    };
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node) ||
+            ts.isInterfaceDeclaration(node) ||
+            ts.isClassExpression(node)) {
+            const ownMembers = node.members.filter((member) => getDeclaredMemberName(member) === targetMember.memberName);
+            const matchingHeritageSymbols = [];
+            const heritageClauses = node.heritageClauses ?? [];
+            for (const clause of heritageClauses) {
+                for (const heritageType of clause.types) {
+                    const inheritedMember = checker.getPropertyOfType(checker.getTypeAtLocation(heritageType), targetMember.memberName);
+                    if (inheritedMember !== void 0 &&
+                        (isSameSymbol(resolveCanonicalSymbol(inheritedMember, checker), targetSymbol) ||
+                            node === targetMember.declaration.parent)) {
+                        matchingHeritageSymbols.push(inheritedMember);
+                    }
+                }
+            }
+            if (node === targetMember.declaration.parent) {
+                for (const member of ownMembers) {
+                    addSymbol(getDeclaredMemberSymbol(checker, member, targetMember.memberName));
+                }
+            }
+            if (matchingHeritageSymbols.length > 0) {
+                for (const member of ownMembers) {
+                    addSymbol(getDeclaredMemberSymbol(checker, member, targetMember.memberName));
+                }
+            }
+            for (const symbol of matchingHeritageSymbols) {
+                addSymbol(symbol);
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!sourceFile.isDeclarationFile) {
+            visit(sourceFile);
+        }
+    }
+    return relatedSymbols;
+};
+export { collectHeritageMemberSymbols };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-contract-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-contract-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\";\nimport { isSupportedMember } from \"./member-host-utilities\";\n\n/**\n * Extracts the static key from a supported member declaration.\n * @param declaration TypeScript member node to inspect.\n * @returns Static name when the declaration is supported.\n * @example\n * ```typescript\n * const name = getDeclaredMemberName(memberDeclaration);\n * ```\n */\nconst getDeclaredMemberName = (declaration: ts.Node): string | undefined => {\n  if (!isSupportedMember(declaration)) {\n    return void 0;\n  }\n\n  const name = (declaration as ts.NamedDeclaration).name;\n\n  return name !== void 0 &&\n    (ts.isIdentifier(name) || ts.isStringLiteralLike(name))\n    ? name.text\n    : void 0;\n};\n\n/**\n * Gets the symbol for one direct member declaration.\n * @param checker TypeScript type checker.\n * @param declaration TypeScript syntax node naming the member.\n * @param memberName Static member name.\n * @returns Member symbol when available.\n * @example\n * ```typescript\n * const symbol = getDeclaredMemberSymbol(checker, declaration, \"run\");\n * ```\n */\nconst getDeclaredMemberSymbol = (\n  checker: ts.TypeChecker,\n  declaration: ts.Node,\n  memberName: string,\n): ts.Symbol | undefined => {\n  const name = (declaration as ts.NamedDeclaration).name;\n\n  return name === void 0\n    ? void 0\n    : (checker.getSymbolAtLocation(name) ??\n        checker.getPropertyOfType(\n          checker.getTypeAtLocation(declaration.parent),\n          memberName,\n        ));\n};\n\n/**\n * Collects member symbols linked by implemented or inherited types.\n * @param program TypeScript project program.\n * @param checker TypeScript type checker.\n * @param targetMember Member whose related contracts are being found.\n * @returns Related member symbols from contract declarations.\n * @example\n * ```typescript\n * const symbols = collectHeritageMemberSymbols(program, checker, member);\n * ```\n */\nconst collectHeritageMemberSymbols = (\n  program: ts.Program,\n  checker: ts.TypeChecker,\n  targetMember: PublicMember,\n): ts.Symbol[] => {\n  const relatedSymbols: ts.Symbol[] = [];\n  const targetSymbol = resolveCanonicalSymbol(\n    targetMember.memberSymbol,\n    checker,\n  );\n  const addSymbol = (candidate: ts.Symbol | undefined): void => {\n    if (\n      candidate !== void 0 &&\n      relatedSymbols.every((symbol) => !isSameSymbol(symbol, candidate))\n    ) {\n      relatedSymbols.push(candidate);\n    }\n  };\n\n  const visit = (node: ts.Node): void => {\n    if (\n      ts.isClassDeclaration(node) ||\n      ts.isInterfaceDeclaration(node) ||\n      ts.isClassExpression(node)\n    ) {\n      const ownMembers = node.members.filter(\n        (member) => getDeclaredMemberName(member) === targetMember.memberName,\n      );\n      const matchingHeritageSymbols: ts.Symbol[] = [];\n\n      const heritageClauses = node.heritageClauses ?? [];\n\n      for (const clause of heritageClauses) {\n        for (const heritageType of clause.types) {\n          const inheritedMember = checker.getPropertyOfType(\n            checker.getTypeAtLocation(heritageType),\n            targetMember.memberName,\n          );\n\n          if (\n            inheritedMember !== void 0 &&\n            (isSameSymbol(\n              resolveCanonicalSymbol(inheritedMember, checker),\n              targetSymbol,\n            ) ||\n              node === targetMember.declaration.parent)\n          ) {\n            matchingHeritageSymbols.push(inheritedMember);\n          }\n        }\n      }\n\n      if (node === targetMember.declaration.parent) {\n        for (const member of ownMembers) {\n          addSymbol(\n            getDeclaredMemberSymbol(checker, member, targetMember.memberName),\n          );\n        }\n      }\n\n      if (matchingHeritageSymbols.length > 0) {\n        for (const member of ownMembers) {\n          addSymbol(\n            getDeclaredMemberSymbol(checker, member, targetMember.memberName),\n          );\n        }\n      }\n\n      for (const symbol of matchingHeritageSymbols) {\n        addSymbol(symbol);\n      }\n    }\n\n    ts.forEachChild(node, visit);\n  };\n\n  for (const sourceFile of program.getSourceFiles()) {\n    if (!sourceFile.isDeclarationFile) {\n      visit(sourceFile);\n    }\n  }\n\n  return relatedSymbols;\n};\n\nexport { collectHeritageMemberSymbols };\n"]}

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

@@ -0,0 +1,34 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+/** One public member and its owning declaration. */
+export interface PublicMember {
+    /** Member declaration in the TypeScript source tree. */
+    declaration: ts.Node;
+    /** Host declaration used to resolve declared member types. */
+    hostDeclaration: ts.Node;
+    /** Display name of the host. */
+    hostName: string;
+    /** Symbol of the host declaration, when available. */
+    hostSymbol: ts.Symbol | undefined;
+    /** Name used for contract matching and diagnostics. */
+    memberName: string;
+    /** TypeScript symbol for the member declaration. */
+    memberSymbol: ts.Symbol;
+    /** ESTree node used for the diagnostic location. */
+    reportNode: ReturnType<ParserServices["tsNodeToESTreeNodeMap"]["get"]>;
+}
+type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
+/**
+ * Collects direct public members from one source file.
+ * @param sourceFile Source file being analyzed.
+ * @param checker TypeScript type checker.
+ * @param parserServices TypeScript and ESTree node maps.
+ * @returns Public member declarations with resolved symbols.
+ * @example
+ * ```typescript
+ * const members = collectPublicMembers(sourceFile, checker, parserServices);
+ * ```
+ */
+declare const collectPublicMembers: (sourceFile: ts.SourceFile, checker: ts.TypeChecker, parserServices: ParserServices) => PublicMember[];
+export { collectPublicMembers };
+//# sourceMappingURL=member-declaration-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-declaration-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-declaration-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAWjC,oDAAoD;AACpD,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,WAAW,EAAE,EAAE,CAAC,IAAI,CAAC;IAErB,8DAA8D;IAC9D,eAAe,EAAE,EAAE,CAAC,IAAI,CAAC;IAEzB,gCAAgC;IAChC,QAAQ,EAAE,MAAM,CAAC;IAEjB,sDAAsD;IACtD,UAAU,EAAE,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC;IAElC,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IAEnB,oDAAoD;IACpD,YAAY,EAAE,EAAE,CAAC,MAAM,CAAC;IAExB,oDAAoD;IACpD,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC,uBAAuB,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;CACxE;AAED,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;AAEvE;;;;;;;;;;GAUG;AACH,QAAA,MAAM,oBAAoB,GACxB,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,WAAW,EACvB,gBAAgB,cAAc,KAC7B,YAAY,EA2Dd,CAAC;AAEF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -0,0 +1,55 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+import { isSameSymbol } from "../no-unused-exports/no-unused-exports-symbol-utilities.js";
+import { collectMemberHosts, getMemberSymbol, getStaticMemberName, isPublicClassMember, isSupportedMember, } from "./member-host-utilities.js";
+/**
+ * Collects direct public members from one source file.
+ * @param sourceFile Source file being analyzed.
+ * @param checker TypeScript type checker.
+ * @param parserServices TypeScript and ESTree node maps.
+ * @returns Public member declarations with resolved symbols.
+ * @example
+ * ```typescript
+ * const members = collectPublicMembers(sourceFile, checker, parserServices);
+ * ```
+ */
+const collectPublicMembers = (sourceFile, checker, parserServices) => {
+    const members = [];
+    for (const host of collectMemberHosts(sourceFile, checker)) {
+        const hostType = checker.getTypeAtLocation(host.node);
+        const isClassHost = ts.isClassDeclaration(host.node);
+        for (const declaration of host.members) {
+            if (!isSupportedMember(declaration) ||
+                (isClassHost && !isPublicClassMember(declaration))) {
+                continue;
+            }
+            const nameNode = declaration.name;
+            const memberName = getStaticMemberName(nameNode);
+            if (memberName === "constructor" ||
+                nameNode === void 0 ||
+                memberName === void 0 ||
+                !parserServices.tsNodeToESTreeNodeMap.has(nameNode)) {
+                continue;
+            }
+            const memberSymbol = getMemberSymbol(checker, declaration, memberName, hostType);
+            if (memberSymbol === void 0 ||
+                members.some((existing) => existing.hostSymbol === host.symbol &&
+                    existing.hostName === host.name &&
+                    isSameSymbol(existing.memberSymbol, memberSymbol))) {
+                continue;
+            }
+            members.push({
+                declaration,
+                hostDeclaration: host.node,
+                hostName: host.name,
+                hostSymbol: host.symbol,
+                memberName,
+                memberSymbol,
+                reportNode: parserServices.tsNodeToESTreeNodeMap.get(nameNode),
+            });
+        }
+    }
+    return members;
+};
+export { collectPublicMembers };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,68 @@
+import * as ts from "typescript";
+/** One supported host and its direct member declarations. */
+interface MemberHost {
+    /** Members declared directly by this host. */
+    members: readonly ts.Node[];
+    /** Display name of the host. */
+    name: string;
+    /** Host declaration node. */
+    node: ts.Node;
+    /** Host symbol, when available. */
+    symbol: ts.Symbol | undefined;
+}
+/**
+ * Gets a static member name, excluding dynamic and private keys.
+ * @param name Candidate declaration name.
+ * @returns Static name or undefined when the key is dynamic or private.
+ * @example
+ * ```typescript
+ * const name = getStaticMemberName(ts.factory.createIdentifier("run"));
+ * ```
+ */
+declare const getStaticMemberName: (name: ts.Node | undefined) => string | undefined;
+/**
+ * Resolves a direct object-literal property symbol before its contextual type.
+ * @param checker TypeScript type checker.
+ * @param member Member declaration.
+ * @param memberName Static member name.
+ * @param hostType Type of the containing host.
+ * @returns Member symbol when TypeScript can resolve it.
+ * @example
+ * ```typescript
+ * const symbol = getMemberSymbol(checker, property, "value", hostType);
+ * ```
+ */
+declare const getMemberSymbol: (checker: ts.TypeChecker, member: ts.Node, memberName: string, hostType: ts.Type) => ts.Symbol | undefined;
+/**
+ * Checks whether a class member is public or has implicit public visibility.
+ * @param member Class member declaration.
+ * @returns True when the member is not private or protected.
+ * @example
+ * ```typescript
+ * const visible = isPublicClassMember(classMethod);
+ * ```
+ */
+declare const isPublicClassMember: (member: ts.Node) => boolean;
+/**
+ * Checks whether a node is a supported direct property or method.
+ * @param member Candidate TypeScript member.
+ * @returns True when this rule analyzes the member kind.
+ * @example
+ * ```typescript
+ * const supported = isSupportedMember(typeMember);
+ * ```
+ */
+declare const isSupportedMember: (member: ts.Node) => boolean;
+/**
+ * Collects direct class, interface, type-alias, and const-object hosts.
+ * @param sourceFile Source file to inspect.
+ * @param checker TypeScript type checker.
+ * @returns Supported hosts declared by the source file.
+ * @example
+ * ```typescript
+ * const hosts = collectMemberHosts(sourceFile, checker);
+ * ```
+ */
+declare const collectMemberHosts: (sourceFile: ts.SourceFile, checker: ts.TypeChecker) => MemberHost[];
+export { collectMemberHosts, getMemberSymbol, getStaticMemberName, isPublicClassMember, isSupportedMember, };
+//# sourceMappingURL=member-host-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-host-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-host-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,6DAA6D;AAC7D,UAAU,UAAU;IAClB,8CAA8C;IAC9C,OAAO,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC;IAE5B,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IAEb,6BAA6B;IAC7B,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IAEd,mCAAmC;IACnC,MAAM,EAAE,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,MAAM,EAAE,CAAC,IAAI,GAAG,SAAS,KAAG,MAAM,GAAG,SAcjE,CAAC;AA0BF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,SAAS,EAAE,CAAC,WAAW,EACvB,QAAQ,EAAE,CAAC,IAAI,EACf,YAAY,MAAM,EAClB,UAAU,EAAE,CAAC,IAAI,KAChB,EAAE,CAAC,MAAM,GAAG,SAwBd,CAAC;AA+BF;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,QAAQ,EAAE,CAAC,IAAI,KAAG,OAoB9C,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,iBAAiB,GAAI,QAAQ,EAAE,CAAC,IAAI,KAAG,OAQH,CAAC;AAE3C;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,YAAY,EAAE,CAAC,UAAU,EACzB,SAAS,EAAE,CAAC,WAAW,KACtB,UAAU,EAsDZ,CAAC;AAEF,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,GAClB,CAAC"}

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

@@ -0,0 +1,195 @@
+import * as ts from "typescript";
+/**
+ * Gets a static member name, excluding dynamic and private keys.
+ * @param name Candidate declaration name.
+ * @returns Static name or undefined when the key is dynamic or private.
+ * @example
+ * ```typescript
+ * const name = getStaticMemberName(ts.factory.createIdentifier("run"));
+ * ```
+ */
+const getStaticMemberName = (name) => {
+    if (name === void 0 ||
+        ts.isPrivateIdentifier(name) ||
+        ts.isComputedPropertyName(name)) {
+        return void 0;
+    }
+    return ts.isIdentifier(name) ||
+        ts.isStringLiteralLike(name) ||
+        ts.isNumericLiteral(name)
+        ? name.text
+        : void 0;
+};
+/**
+ * Gets the local name used to identify a supported host.
+ * @param node Host declaration.
+ * @returns Host name or an anonymous marker.
+ * @example
+ * ```typescript
+ * const name = getHostName(classDeclaration);
+ * ```
+ */
+const getHostName = (node) => {
+    if ((ts.isClassDeclaration(node) ||
+        ts.isInterfaceDeclaration(node) ||
+        ts.isTypeAliasDeclaration(node)) &&
+        node.name !== void 0) {
+        return node.name.text;
+    }
+    return ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)
+        ? node.name.text
+        : "<anonymous>";
+};
+/**
+ * Resolves a direct object-literal property symbol before its contextual type.
+ * @param checker TypeScript type checker.
+ * @param member Member declaration.
+ * @param memberName Static member name.
+ * @param hostType Type of the containing host.
+ * @returns Member symbol when TypeScript can resolve it.
+ * @example
+ * ```typescript
+ * const symbol = getMemberSymbol(checker, property, "value", hostType);
+ * ```
+ */
+const getMemberSymbol = (checker, member, memberName, hostType) => {
+    const nameNode = member.name;
+    const isObjectMember = ts.isPropertyAssignment(member) ||
+        ts.isShorthandPropertyAssignment(member) ||
+        ts.isMethodDeclaration(member) ||
+        ts.isGetAccessorDeclaration(member) ||
+        ts.isSetAccessorDeclaration(member);
+    if (isObjectMember && ts.isObjectLiteralExpression(member.parent)) {
+        const objectMember = checker.getPropertyOfType(checker.getTypeAtLocation(member.parent), memberName);
+        if (objectMember !== void 0) {
+            return objectMember;
+        }
+    }
+    const directSymbol = nameNode === void 0 ? void 0 : checker.getSymbolAtLocation(nameNode);
+    return directSymbol ?? checker.getPropertyOfType(hostType, memberName);
+};
+/**
+ * Unwraps supported expressions to find a direct object-literal initializer.
+ * @param expression Variable initializer.
+ * @returns Direct object literal or undefined.
+ * @example
+ * ```typescript
+ * const object = getObjectLiteral(variable.initializer);
+ * ```
+ */
+const getObjectLiteral = (expression) => {
+    if (expression === void 0) {
+        return void 0;
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        return expression;
+    }
+    return ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isTypeAssertionExpression(expression) ||
+        ts.isParenthesizedExpression(expression) ||
+        ts.isNonNullExpression(expression)
+        ? getObjectLiteral(expression.expression)
+        : void 0;
+};
+/**
+ * Checks whether a class member is public or has implicit public visibility.
+ * @param member Class member declaration.
+ * @returns True when the member is not private or protected.
+ * @example
+ * ```typescript
+ * const visible = isPublicClassMember(classMethod);
+ * ```
+ */
+const isPublicClassMember = (member) => {
+    const supportsVisibility = ts.isPropertyDeclaration(member) ||
+        ts.isMethodDeclaration(member) ||
+        ts.isGetAccessorDeclaration(member) ||
+        ts.isSetAccessorDeclaration(member);
+    if (!supportsVisibility) {
+        return false;
+    }
+    const modifiers = ts.canHaveModifiers(member)
+        ? (ts.getModifiers(member) ?? [])
+        : [];
+    return modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.PrivateKeyword &&
+        modifier.kind !== ts.SyntaxKind.ProtectedKeyword);
+};
+/**
+ * Checks whether a node is a supported direct property or method.
+ * @param member Candidate TypeScript member.
+ * @returns True when this rule analyzes the member kind.
+ * @example
+ * ```typescript
+ * const supported = isSupportedMember(typeMember);
+ * ```
+ */
+const isSupportedMember = (member) => ts.isPropertyDeclaration(member) ||
+    ts.isMethodDeclaration(member) ||
+    ts.isGetAccessorDeclaration(member) ||
+    ts.isSetAccessorDeclaration(member) ||
+    ts.isPropertySignature(member) ||
+    ts.isMethodSignature(member) ||
+    ts.isPropertyAssignment(member) ||
+    ts.isShorthandPropertyAssignment(member);
+/**
+ * Collects direct class, interface, type-alias, and const-object hosts.
+ * @param sourceFile Source file to inspect.
+ * @param checker TypeScript type checker.
+ * @returns Supported hosts declared by the source file.
+ * @example
+ * ```typescript
+ * const hosts = collectMemberHosts(sourceFile, checker);
+ * ```
+ */
+const collectMemberHosts = (sourceFile, checker) => {
+    const hosts = [];
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node)) {
+            hosts.push({
+                members: node.members,
+                name: getHostName(node),
+                node,
+                symbol: node.name === void 0
+                    ? void 0
+                    : checker.getSymbolAtLocation(node.name),
+            });
+        }
+        else if (ts.isInterfaceDeclaration(node)) {
+            hosts.push({
+                members: node.members,
+                name: getHostName(node),
+                node,
+                symbol: checker.getSymbolAtLocation(node.name),
+            });
+        }
+        else if (ts.isTypeAliasDeclaration(node) &&
+            ts.isTypeLiteralNode(node.type)) {
+            hosts.push({
+                members: node.type.members,
+                name: getHostName(node),
+                node,
+                symbol: checker.getSymbolAtLocation(node.name),
+            });
+        }
+        else if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            ts.isVariableDeclarationList(node.parent) &&
+            (node.parent.flags & ts.NodeFlags.Const) !== 0) {
+            const objectLiteral = getObjectLiteral(node.initializer);
+            if (objectLiteral !== void 0) {
+                hosts.push({
+                    members: objectLiteral.properties,
+                    name: getHostName(node),
+                    node,
+                    symbol: checker.getSymbolAtLocation(node.name),
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return hosts;
+};
+export { collectMemberHosts, getMemberSymbol, getStaticMemberName, isPublicClassMember, isSupportedMember, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-host-utilities.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-host-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ts from \"typescript\";\n\n/** One supported host and its direct member declarations. */\ninterface MemberHost {\n  /** Members declared directly by this host. */\n  members: readonly ts.Node[];\n\n  /** Display name of the host. */\n  name: string;\n\n  /** Host declaration node. */\n  node: ts.Node;\n\n  /** Host symbol, when available. */\n  symbol: ts.Symbol | undefined;\n}\n\n/**\n * Gets a static member name, excluding dynamic and private keys.\n * @param name Candidate declaration name.\n * @returns Static name or undefined when the key is dynamic or private.\n * @example\n * ```typescript\n * const name = getStaticMemberName(ts.factory.createIdentifier(\"run\"));\n * ```\n */\nconst getStaticMemberName = (name: ts.Node | undefined): string | undefined => {\n  if (\n    name === void 0 ||\n    ts.isPrivateIdentifier(name) ||\n    ts.isComputedPropertyName(name)\n  ) {\n    return void 0;\n  }\n\n  return ts.isIdentifier(name) ||\n    ts.isStringLiteralLike(name) ||\n    ts.isNumericLiteral(name)\n    ? name.text\n    : void 0;\n};\n\n/**\n * Gets the local name used to identify a supported host.\n * @param node Host declaration.\n * @returns Host name or an anonymous marker.\n * @example\n * ```typescript\n * const name = getHostName(classDeclaration);\n * ```\n */\nconst getHostName = (node: ts.Node): string => {\n  if (\n    (ts.isClassDeclaration(node) ||\n      ts.isInterfaceDeclaration(node) ||\n      ts.isTypeAliasDeclaration(node)) &&\n    node.name !== void 0\n  ) {\n    return node.name.text;\n  }\n\n  return ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)\n    ? node.name.text\n    : \"<anonymous>\";\n};\n\n/**\n * Resolves a direct object-literal property symbol before its contextual type.\n * @param checker TypeScript type checker.\n * @param member Member declaration.\n * @param memberName Static member name.\n * @param hostType Type of the containing host.\n * @returns Member symbol when TypeScript can resolve it.\n * @example\n * ```typescript\n * const symbol = getMemberSymbol(checker, property, \"value\", hostType);\n * ```\n */\nconst getMemberSymbol = (\n  checker: ts.TypeChecker,\n  member: ts.Node,\n  memberName: string,\n  hostType: ts.Type,\n): ts.Symbol | undefined => {\n  const nameNode = (member as ts.NamedDeclaration).name;\n  const isObjectMember =\n    ts.isPropertyAssignment(member) ||\n    ts.isShorthandPropertyAssignment(member) ||\n    ts.isMethodDeclaration(member) ||\n    ts.isGetAccessorDeclaration(member) ||\n    ts.isSetAccessorDeclaration(member);\n\n  if (isObjectMember && ts.isObjectLiteralExpression(member.parent)) {\n    const objectMember = checker.getPropertyOfType(\n      checker.getTypeAtLocation(member.parent),\n      memberName,\n    );\n\n    if (objectMember !== void 0) {\n      return objectMember;\n    }\n  }\n\n  const directSymbol =\n    nameNode === void 0 ? void 0 : checker.getSymbolAtLocation(nameNode);\n\n  return directSymbol ?? checker.getPropertyOfType(hostType, memberName);\n};\n\n/**\n * Unwraps supported expressions to find a direct object-literal initializer.\n * @param expression Variable initializer.\n * @returns Direct object literal or undefined.\n * @example\n * ```typescript\n * const object = getObjectLiteral(variable.initializer);\n * ```\n */\nconst getObjectLiteral = (\n  expression: ts.Expression | undefined,\n): ts.ObjectLiteralExpression | undefined => {\n  if (expression === void 0) {\n    return void 0;\n  }\n\n  if (ts.isObjectLiteralExpression(expression)) {\n    return expression;\n  }\n\n  return ts.isAsExpression(expression) ||\n    ts.isSatisfiesExpression(expression) ||\n    ts.isTypeAssertionExpression(expression) ||\n    ts.isParenthesizedExpression(expression) ||\n    ts.isNonNullExpression(expression)\n    ? getObjectLiteral(expression.expression)\n    : void 0;\n};\n\n/**\n * Checks whether a class member is public or has implicit public visibility.\n * @param member Class member declaration.\n * @returns True when the member is not private or protected.\n * @example\n * ```typescript\n * const visible = isPublicClassMember(classMethod);\n * ```\n */\nconst isPublicClassMember = (member: ts.Node): boolean => {\n  const supportsVisibility =\n    ts.isPropertyDeclaration(member) ||\n    ts.isMethodDeclaration(member) ||\n    ts.isGetAccessorDeclaration(member) ||\n    ts.isSetAccessorDeclaration(member);\n\n  if (!supportsVisibility) {\n    return false;\n  }\n\n  const modifiers = ts.canHaveModifiers(member)\n    ? (ts.getModifiers(member) ?? [])\n    : [];\n\n  return modifiers.every(\n    (modifier) =>\n      modifier.kind !== ts.SyntaxKind.PrivateKeyword &&\n      modifier.kind !== ts.SyntaxKind.ProtectedKeyword,\n  );\n};\n\n/**\n * Checks whether a node is a supported direct property or method.\n * @param member Candidate TypeScript member.\n * @returns True when this rule analyzes the member kind.\n * @example\n * ```typescript\n * const supported = isSupportedMember(typeMember);\n * ```\n */\nconst isSupportedMember = (member: ts.Node): boolean =>\n  ts.isPropertyDeclaration(member) ||\n  ts.isMethodDeclaration(member) ||\n  ts.isGetAccessorDeclaration(member) ||\n  ts.isSetAccessorDeclaration(member) ||\n  ts.isPropertySignature(member) ||\n  ts.isMethodSignature(member) ||\n  ts.isPropertyAssignment(member) ||\n  ts.isShorthandPropertyAssignment(member);\n\n/**\n * Collects direct class, interface, type-alias, and const-object hosts.\n * @param sourceFile Source file to inspect.\n * @param checker TypeScript type checker.\n * @returns Supported hosts declared by the source file.\n * @example\n * ```typescript\n * const hosts = collectMemberHosts(sourceFile, checker);\n * ```\n */\nconst collectMemberHosts = (\n  sourceFile: ts.SourceFile,\n  checker: ts.TypeChecker,\n): MemberHost[] => {\n  const hosts: MemberHost[] = [];\n  const visit = (node: ts.Node): void => {\n    if (ts.isClassDeclaration(node)) {\n      hosts.push({\n        members: node.members,\n        name: getHostName(node),\n        node,\n        symbol:\n          node.name === void 0\n            ? void 0\n            : checker.getSymbolAtLocation(node.name),\n      });\n    } else if (ts.isInterfaceDeclaration(node)) {\n      hosts.push({\n        members: node.members,\n        name: getHostName(node),\n        node,\n        symbol: checker.getSymbolAtLocation(node.name),\n      });\n    } else if (\n      ts.isTypeAliasDeclaration(node) &&\n      ts.isTypeLiteralNode(node.type)\n    ) {\n      hosts.push({\n        members: node.type.members,\n        name: getHostName(node),\n        node,\n        symbol: checker.getSymbolAtLocation(node.name),\n      });\n    } else if (\n      ts.isVariableDeclaration(node) &&\n      ts.isIdentifier(node.name) &&\n      ts.isVariableDeclarationList(node.parent) &&\n      (node.parent.flags & ts.NodeFlags.Const) !== 0\n    ) {\n      const objectLiteral = getObjectLiteral(node.initializer);\n\n      if (objectLiteral !== void 0) {\n        hosts.push({\n          members: objectLiteral.properties,\n          name: getHostName(node),\n          node,\n          symbol: checker.getSymbolAtLocation(node.name),\n        });\n      }\n    }\n\n    ts.forEachChild(node, visit);\n  };\n\n  visit(sourceFile);\n\n  return hosts;\n};\n\nexport {\n  collectMemberHosts,\n  getMemberSymbol,\n  getStaticMemberName,\n  isPublicClassMember,\n  isSupportedMember,\n};\n"]}

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

@@ -0,0 +1,30 @@
+import * as ts from "typescript";
+import type { NoUnusedExportsState } from "../no-unused-exports/types.js";
+/**
+ * Checks whether a member is reachable from a configured public API export.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param memberSymbol Member symbol being checked.
+ * @returns True when an API export exposes the member.
+ * @example
+ * ```typescript
+ * const exposed = isPublicApiMember(program, state, repoRoot, memberSymbol);
+ * ```
+ */
+declare const isPublicApiMember: (program: ts.Program, state: NoUnusedExportsState, repoRoot: string, memberSymbol: ts.Symbol) => boolean;
+/**
+ * Checks whether a host is exported from a configured public API file.
+ * @param program TypeScript project program.
+ * @param state Normalized public API and test patterns.
+ * @param repoRoot Root directory used for glob matching.
+ * @param hostSymbol Host declaration symbol.
+ * @returns True when the host is exposed by a non-test API file.
+ * @example
+ * ```typescript
+ * const isPublic = isPublicApiHost(program, state, repoRoot, hostSymbol);
+ * ```
+ */
+declare const isPublicApiHost: (program: ts.Program, state: NoUnusedExportsState, repoRoot: string, hostSymbol: ts.Symbol | undefined) => boolean;
+export { isPublicApiHost, isPublicApiMember };
+//# sourceMappingURL=member-public-api-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-public-api-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/architecture/no-unused-public-members/member-public-api-utilities.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AA2DvE;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,iBAAiB,GACrB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,cAAc,EAAE,CAAC,MAAM,KACtB,OA6CF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,eAAe,GACnB,SAAS,EAAE,CAAC,OAAO,EACnB,OAAO,oBAAoB,EAC3B,UAAU,MAAM,EAChB,YAAY,EAAE,CAAC,MAAM,GAAG,SAAS,KAChC,OAsBF,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,CAAC"}