@codeperfect/eslint-plugin 3.1.0 → 3.2.0

package/dist/adapters/angular/angular-template-block-usage-utilities.d.ts

@@ -0,0 +1,4 @@
+import type { AngularTemplateNode, TemplateLocals, TemplateNodeVisitor, TemplateUsageContext } from "./angular-template-usage-context.js";
+declare const blockUsesMember: (node: AngularTemplateNode, locals: TemplateLocals, usage: TemplateUsageContext, visitNodes: TemplateNodeVisitor) => boolean;
+export { blockUsesMember };
+//# sourceMappingURL=angular-template-block-usage-utilities.d.ts.map

package/dist/adapters/angular/angular-template-block-usage-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-template-block-usage-utilities.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-block-usage-utilities.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,kCAAkC,CAAC;AAK1C,QAAA,MAAM,eAAe,GACnB,MAAM,mBAAmB,EACzB,QAAQ,cAAc,EACtB,OAAO,oBAAoB,EAC3B,YAAY,mBAAmB,KAC9B,OAgHF,CAAC;AAEF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/adapters/angular/angular-template-block-usage-utilities.js

@@ -0,0 +1,69 @@
+import * as angular from "@angular/compiler";
+import { expressionUsesMember } from "./angular-template-expression-utilities.js";
+import { withAlias, withNames } from "./angular-template-usage-context.js";
+const blockUsesMember = (node, locals, usage, visitNodes) => {
+    if (node instanceof angular.TmplAstIfBlock) {
+        return node.branches.some((branch) => {
+            const alias = branch.expressionAlias?.name;
+            const aliasValue = branch.expression ?? undefined;
+            const branchLocals = alias === undefined
+                ? locals
+                : aliasValue === undefined
+                    ? withNames(locals, [alias])
+                    : withAlias(locals, alias, aliasValue);
+            return (uses(branch.expression ?? undefined, locals) ||
+                visitNodes(branch.children, branchLocals, usage));
+        });
+    }
+    if (node instanceof angular.TmplAstForLoopBlock) {
+        const loopLocals = withNames(locals, [
+            node.item.name,
+            ...node.contextVariables.map(({ name }) => name),
+        ]);
+        return (uses(node.expression, locals) ||
+            uses(node.trackBy ?? undefined, loopLocals) ||
+            visitNodes(node.children, loopLocals, usage) ||
+            (node.empty !== null && visitNodes(node.empty.children, locals, usage)));
+    }
+    if (node instanceof angular.TmplAstSwitchBlock) {
+        return (uses(node.expression, locals) ||
+            node.groups.some((group) => group.cases.some((branch) => uses(branch.expression ?? undefined, locals)) || visitNodes(group.children, locals, usage)));
+    }
+    if (node instanceof angular.TmplAstDeferredBlock) {
+        const triggers = [
+            ...Object.values(node.triggers),
+            ...Object.values(node.prefetchTriggers),
+            ...Object.values(node.hydrateTriggers),
+        ];
+        return (triggers.some((trigger) => trigger instanceof angular.TmplAstBoundDeferredTrigger &&
+            uses(trigger.value, locals)) ||
+            visitNodes(node.children, locals, usage) ||
+            (node.placeholder !== null &&
+                visitNodes(node.placeholder.children, locals, usage)) ||
+            (node.loading !== null &&
+                visitNodes(node.loading.children, locals, usage)) ||
+            (node.error !== null && visitNodes(node.error.children, locals, usage)));
+    }
+    return ((node instanceof angular.TmplAstBoundaryBlock &&
+        (visitNodes(node.children, locals, usage) ||
+            node.errorBlocks.some((branch) => uses(branch.expression ?? undefined, locals) ||
+                visitNodes(branch.children, withNames(locals, branch.contextVariables.map(({ name }) => name)), usage)))) ||
+        (node instanceof angular.TmplAstContentBlock &&
+            visitNodes(node.children, withNames(locals, node.variables.map(({ name }) => name)), usage)));
+    /**
+     * Checks an Angular expression against the selected component member.
+     * @param expression Template expression to inspect.
+     * @param expressionLocals Template locals in scope for the expression.
+     * @returns Whether the expression reads the member.
+     * @example
+     * ```typescript
+     * const used = uses(templateExpression, locals);
+     * ```
+     */
+    function uses(expression, expressionLocals) {
+        return (expression !== undefined &&
+            expressionUsesMember(expression, expressionLocals, usage));
+    }
+};
+export { blockUsesMember };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-template-block-usage-utilities.js","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-block-usage-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as angular from \"@angular/compiler\";\n\nimport type {\n  AngularTemplateNode,\n  TemplateLocals,\n  TemplateNodeVisitor,\n  TemplateUsageContext,\n} from \"./angular-template-usage-context\";\n\nimport { expressionUsesMember } from \"./angular-template-expression-utilities\";\nimport { withAlias, withNames } from \"./angular-template-usage-context\";\n\nconst blockUsesMember = (\n  node: AngularTemplateNode,\n  locals: TemplateLocals,\n  usage: TemplateUsageContext,\n  visitNodes: TemplateNodeVisitor,\n): boolean => {\n  if (node instanceof angular.TmplAstIfBlock) {\n    return node.branches.some((branch) => {\n      const alias = branch.expressionAlias?.name;\n      const aliasValue = branch.expression ?? undefined;\n      const branchLocals =\n        alias === undefined\n          ? locals\n          : aliasValue === undefined\n            ? withNames(locals, [alias])\n            : withAlias(locals, alias, aliasValue);\n\n      return (\n        uses(branch.expression ?? undefined, locals) ||\n        visitNodes(branch.children, branchLocals, usage)\n      );\n    });\n  }\n\n  if (node instanceof angular.TmplAstForLoopBlock) {\n    const loopLocals = withNames(locals, [\n      node.item.name,\n      ...node.contextVariables.map(({ name }) => name),\n    ]);\n\n    return (\n      uses(node.expression, locals) ||\n      uses(node.trackBy ?? undefined, loopLocals) ||\n      visitNodes(node.children, loopLocals, usage) ||\n      (node.empty !== null && visitNodes(node.empty.children, locals, usage))\n    );\n  }\n\n  if (node instanceof angular.TmplAstSwitchBlock) {\n    return (\n      uses(node.expression, locals) ||\n      node.groups.some(\n        (group) =>\n          group.cases.some((branch) =>\n            uses(branch.expression ?? undefined, locals),\n          ) || visitNodes(group.children, locals, usage),\n      )\n    );\n  }\n\n  if (node instanceof angular.TmplAstDeferredBlock) {\n    const triggers = [\n      ...Object.values(node.triggers),\n      ...Object.values(node.prefetchTriggers),\n      ...Object.values(node.hydrateTriggers),\n    ];\n\n    return (\n      triggers.some(\n        (trigger) =>\n          trigger instanceof angular.TmplAstBoundDeferredTrigger &&\n          uses(trigger.value, locals),\n      ) ||\n      visitNodes(node.children, locals, usage) ||\n      (node.placeholder !== null &&\n        visitNodes(node.placeholder.children, locals, usage)) ||\n      (node.loading !== null &&\n        visitNodes(node.loading.children, locals, usage)) ||\n      (node.error !== null && visitNodes(node.error.children, locals, usage))\n    );\n  }\n\n  return (\n    (node instanceof angular.TmplAstBoundaryBlock &&\n      (visitNodes(node.children, locals, usage) ||\n        node.errorBlocks.some(\n          (branch) =>\n            uses(branch.expression ?? undefined, locals) ||\n            visitNodes(\n              branch.children,\n              withNames(\n                locals,\n                branch.contextVariables.map(({ name }) => name),\n              ),\n              usage,\n            ),\n        ))) ||\n    (node instanceof angular.TmplAstContentBlock &&\n      visitNodes(\n        node.children,\n        withNames(\n          locals,\n          node.variables.map(({ name }) => name),\n        ),\n        usage,\n      ))\n  );\n\n  /**\n   * Checks an Angular expression against the selected component member.\n   * @param expression Template expression to inspect.\n   * @param expressionLocals Template locals in scope for the expression.\n   * @returns Whether the expression reads the member.\n   * @example\n   * ```typescript\n   * const used = uses(templateExpression, locals);\n   * ```\n   */\n  function uses(\n    expression: angular.AST | undefined,\n    expressionLocals: TemplateLocals,\n  ): boolean {\n    return (\n      expression !== undefined &&\n      expressionUsesMember(expression, expressionLocals, usage)\n    );\n  }\n};\n\nexport { blockUsesMember };\n"]}

package/dist/adapters/angular/angular-template-expression-utilities.d.ts

@@ -0,0 +1,5 @@
+import * as angular from "@angular/compiler";
+import type { TemplateLocals, TemplateUsageContext } from "./angular-template-usage-context.js";
+declare const expressionUsesMember: (expression: angular.AST, locals: TemplateLocals, usage: TemplateUsageContext) => boolean;
+export { expressionUsesMember };
+//# sourceMappingURL=angular-template-expression-utilities.d.ts.map

package/dist/adapters/angular/angular-template-expression-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-template-expression-utilities.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-expression-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAG7C,OAAO,KAAK,EACV,cAAc,EAEd,oBAAoB,EACrB,MAAM,kCAAkC,CAAC;AAI1C,QAAA,MAAM,oBAAoB,GACxB,YAAY,OAAO,CAAC,GAAG,EACvB,QAAQ,cAAc,EACtB,OAAO,oBAAoB,KAC1B,OA2BF,CAAC;AAqJF,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/adapters/angular/angular-template-expression-utilities.js

@@ -0,0 +1,121 @@
+import * as angular from "@angular/compiler";
+import * as ts from "typescript";
+import { isSameSymbol } from "../../domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities.js";
+const expressionUsesMember = (expression, locals, usage) => {
+    class MemberReadVisitor extends angular.RecursiveAstVisitor {
+        found = false;
+        visitPropertyRead(ast) {
+            this.record(ast);
+            super.visitPropertyRead(ast, undefined);
+        }
+        visitSafePropertyRead(ast) {
+            this.record(ast);
+            super.visitSafePropertyRead(ast, undefined);
+        }
+        record(ast) {
+            if (ast.name === usage.member.memberName &&
+                resolveTemplatePath(getMemberPath(ast), locals, usage)) {
+                this.found = true;
+            }
+        }
+    }
+    const visitor = new MemberReadVisitor();
+    expression.visit(visitor);
+    return visitor.found;
+};
+const getMemberPath = (expression) => {
+    if (expression instanceof angular.ASTWithSource) {
+        const sourceAst = expression.ast;
+        return sourceAst instanceof angular.AST
+            ? getMemberPath(sourceAst)
+            : undefined;
+    }
+    if (expression instanceof angular.ImplicitReceiver) {
+        return { root: "implicit", segments: [] };
+    }
+    if (expression instanceof angular.ThisReceiver) {
+        return { root: "component", segments: [] };
+    }
+    if (expression instanceof angular.PropertyRead ||
+        expression instanceof angular.SafePropertyRead) {
+        const parentPath = getMemberPath(expression.receiver);
+        return parentPath === undefined
+            ? undefined
+            : {
+                ...parentPath,
+                segments: [...parentPath.segments, { name: expression.name }],
+            };
+    }
+    if (expression instanceof angular.Call ||
+        expression instanceof angular.SafeCall) {
+        if (expression.args.length > 0) {
+            return undefined;
+        }
+        const calleePath = getMemberPath(expression.receiver);
+        return calleePath === undefined
+            ? undefined
+            : { ...calleePath, segments: [...calleePath.segments, { call: true }] };
+    }
+    if (expression instanceof angular.ParenthesizedExpression) {
+        return getMemberPath(expression.expression);
+    }
+    return expression instanceof angular.NonNullAssert
+        ? getMemberPath(expression.expression)
+        : undefined;
+};
+const resolveTemplatePath = (templatePath, locals, usage) => {
+    const resolvedPath = expandTemplateLocals(templatePath, locals);
+    if (resolvedPath === undefined || resolvedPath.segments.length === 0) {
+        return false;
+    }
+    const { segments } = resolvedPath;
+    const [firstSegment] = segments;
+    if (firstSegment === undefined || !("name" in firstSegment)) {
+        return false;
+    }
+    let currentType = usage.checker.getDeclaredTypeOfSymbol(usage.componentSymbol);
+    for (const [index, segment] of segments.entries()) {
+        if ("call" in segment) {
+            const [signature] = usage.checker.getSignaturesOfType(currentType, ts.SignatureKind.Call);
+            if (signature === undefined) {
+                return false;
+            }
+            currentType = usage.checker.getReturnTypeOfSignature(signature);
+            continue;
+        }
+        const property = usage.checker.getPropertyOfType(usage.checker.getNonNullableType(currentType), segment.name);
+        if (property === undefined) {
+            return false;
+        }
+        if (index === segments.length - 1) {
+            return isSameSymbol(property, usage.member.memberSymbol);
+        }
+        currentType = usage.checker.getTypeOfSymbolAtLocation(property, usage.component);
+    }
+    return false;
+};
+const expandTemplateLocals = (templatePath, locals, visitedLocals = new Set()) => {
+    if (templatePath?.root !== "implicit") {
+        return templatePath;
+    }
+    const [firstSegment] = templatePath.segments;
+    if (firstSegment === undefined ||
+        !("name" in firstSegment) ||
+        !locals.has(firstSegment.name)) {
+        return templatePath;
+    }
+    const localName = firstSegment.name;
+    const localValue = locals.get(localName);
+    if (localValue === undefined || visitedLocals.has(localName)) {
+        return undefined;
+    }
+    const localPath = getMemberPath(localValue);
+    return expandTemplateLocals(localPath === undefined
+        ? undefined
+        : {
+            ...localPath,
+            segments: [...localPath.segments, ...templatePath.segments.slice(1)],
+        }, locals, new Set([...visitedLocals, localName]));
+};
+export { expressionUsesMember };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-template-expression-utilities.js","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-expression-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import * as angular from \"@angular/compiler\";\nimport * as ts from \"typescript\";\n\nimport type {\n  TemplateLocals,\n  TemplateMemberPath,\n  TemplateUsageContext,\n} from \"./angular-template-usage-context\";\n\nimport { isSameSymbol } from \"../../domain/architecture/no-unused-exports/no-unused-exports-symbol-utilities\";\n\nconst expressionUsesMember = (\n  expression: angular.AST,\n  locals: TemplateLocals,\n  usage: TemplateUsageContext,\n): boolean => {\n  class MemberReadVisitor extends angular.RecursiveAstVisitor {\n    found = false;\n\n    override visitPropertyRead(ast: angular.PropertyRead): void {\n      this.record(ast);\n      super.visitPropertyRead(ast, undefined);\n    }\n\n    override visitSafePropertyRead(ast: angular.SafePropertyRead): void {\n      this.record(ast);\n      super.visitSafePropertyRead(ast, undefined);\n    }\n\n    private record(ast: angular.PropertyRead | angular.SafePropertyRead): void {\n      if (\n        ast.name === usage.member.memberName &&\n        resolveTemplatePath(getMemberPath(ast), locals, usage)\n      ) {\n        this.found = true;\n      }\n    }\n  }\n\n  const visitor = new MemberReadVisitor();\n  expression.visit(visitor);\n  return visitor.found;\n};\n\nconst getMemberPath = (\n  expression: angular.AST,\n): TemplateMemberPath | undefined => {\n  if (expression instanceof angular.ASTWithSource) {\n    const sourceAst: unknown = expression.ast;\n    return sourceAst instanceof angular.AST\n      ? getMemberPath(sourceAst)\n      : undefined;\n  }\n\n  if (expression instanceof angular.ImplicitReceiver) {\n    return { root: \"implicit\", segments: [] };\n  }\n\n  if (expression instanceof angular.ThisReceiver) {\n    return { root: \"component\", segments: [] };\n  }\n\n  if (\n    expression instanceof angular.PropertyRead ||\n    expression instanceof angular.SafePropertyRead\n  ) {\n    const parentPath = getMemberPath(expression.receiver);\n    return parentPath === undefined\n      ? undefined\n      : {\n          ...parentPath,\n          segments: [...parentPath.segments, { name: expression.name }],\n        };\n  }\n\n  if (\n    expression instanceof angular.Call ||\n    expression instanceof angular.SafeCall\n  ) {\n    if (expression.args.length > 0) {\n      return undefined;\n    }\n\n    const calleePath = getMemberPath(expression.receiver);\n    return calleePath === undefined\n      ? undefined\n      : { ...calleePath, segments: [...calleePath.segments, { call: true }] };\n  }\n\n  if (expression instanceof angular.ParenthesizedExpression) {\n    return getMemberPath(expression.expression);\n  }\n\n  return expression instanceof angular.NonNullAssert\n    ? getMemberPath(expression.expression)\n    : undefined;\n};\n\nconst resolveTemplatePath = (\n  templatePath: TemplateMemberPath | undefined,\n  locals: TemplateLocals,\n  usage: TemplateUsageContext,\n): boolean => {\n  const resolvedPath = expandTemplateLocals(templatePath, locals);\n  if (resolvedPath === undefined || resolvedPath.segments.length === 0) {\n    return false;\n  }\n\n  const { segments } = resolvedPath;\n  const [firstSegment] = segments;\n\n  if (firstSegment === undefined || !(\"name\" in firstSegment)) {\n    return false;\n  }\n\n  let currentType = usage.checker.getDeclaredTypeOfSymbol(\n    usage.componentSymbol,\n  );\n\n  for (const [index, segment] of segments.entries()) {\n    if (\"call\" in segment) {\n      const [signature] = usage.checker.getSignaturesOfType(\n        currentType,\n        ts.SignatureKind.Call,\n      );\n      if (signature === undefined) {\n        return false;\n      }\n\n      currentType = usage.checker.getReturnTypeOfSignature(signature);\n      continue;\n    }\n\n    const property = usage.checker.getPropertyOfType(\n      usage.checker.getNonNullableType(currentType),\n      segment.name,\n    );\n    if (property === undefined) {\n      return false;\n    }\n\n    if (index === segments.length - 1) {\n      return isSameSymbol(property, usage.member.memberSymbol);\n    }\n\n    currentType = usage.checker.getTypeOfSymbolAtLocation(\n      property,\n      usage.component,\n    );\n  }\n\n  return false;\n};\n\nconst expandTemplateLocals = (\n  templatePath: TemplateMemberPath | undefined,\n  locals: TemplateLocals,\n  visitedLocals: ReadonlySet<string> = new Set(),\n): TemplateMemberPath | undefined => {\n  if (templatePath?.root !== \"implicit\") {\n    return templatePath;\n  }\n\n  const [firstSegment] = templatePath.segments;\n  if (\n    firstSegment === undefined ||\n    !(\"name\" in firstSegment) ||\n    !locals.has(firstSegment.name)\n  ) {\n    return templatePath;\n  }\n\n  const localName = firstSegment.name;\n  const localValue = locals.get(localName);\n  if (localValue === undefined || visitedLocals.has(localName)) {\n    return undefined;\n  }\n\n  const localPath = getMemberPath(localValue);\n  return expandTemplateLocals(\n    localPath === undefined\n      ? undefined\n      : {\n          ...localPath,\n          segments: [...localPath.segments, ...templatePath.segments.slice(1)],\n        },\n    locals,\n    new Set([...visitedLocals, localName]),\n  );\n};\n\nexport { expressionUsesMember };\n"]}

package/dist/adapters/angular/angular-template-node-usage-utilities.d.ts

@@ -0,0 +1,4 @@
+import type { AngularTemplateNode, TemplateLocals, TemplateUsageContext } from "./angular-template-usage-context.js";
+declare const templateNodesUseMember: (nodes: AngularTemplateNode[], inheritedLocals: TemplateLocals, usage: TemplateUsageContext) => boolean;
+export { templateNodesUseMember };
+//# sourceMappingURL=angular-template-node-usage-utilities.d.ts.map

package/dist/adapters/angular/angular-template-node-usage-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-template-node-usage-utilities.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-node-usage-utilities.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACrB,MAAM,kCAAkC,CAAC;AAM1C,QAAA,MAAM,sBAAsB,GAC1B,OAAO,mBAAmB,EAAE,EAC5B,iBAAiB,cAAc,EAC/B,OAAO,oBAAoB,KAC1B,OAgBF,CAAC;AAmEF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/adapters/angular/angular-template-node-usage-utilities.js

@@ -0,0 +1,47 @@
+import * as angular from "@angular/compiler";
+import { blockUsesMember } from "./angular-template-block-usage-utilities.js";
+import { expressionUsesMember } from "./angular-template-expression-utilities.js";
+import { withNames } from "./angular-template-usage-context.js";
+const templateNodesUseMember = (nodes, inheritedLocals, usage) => {
+    const locals = new Map(inheritedLocals);
+    for (const node of nodes) {
+        if (node instanceof angular.TmplAstLetDeclaration) {
+            if (expressionUsesMember(node.value, locals, usage)) {
+                return true;
+            }
+            locals.set(node.name, node.value);
+        }
+        else if (nodeUsesMember(node, locals, usage)) {
+            return true;
+        }
+    }
+    return false;
+};
+const nodeUsesMember = (node, locals, usage) => {
+    if (node instanceof angular.TmplAstBoundText) {
+        return expressionUsesMember(node.value, locals, usage);
+    }
+    if (node instanceof angular.TmplAstElement) {
+        return (inputsUseMember(node.inputs, locals, usage) ||
+            eventsUseMember(node.outputs, locals, usage) ||
+            templateNodesUseMember(node.children, withNames(locals, node.references.map(({ name }) => name)), usage));
+    }
+    if (node instanceof angular.TmplAstTemplate) {
+        const templateLocals = withNames(locals, [...node.variables, ...node.references].map(({ name }) => name));
+        return (inputsUseMember(node.inputs, locals, usage) ||
+            eventsUseMember(node.outputs, locals, usage) ||
+            node.templateAttrs.some((attribute) => attribute instanceof angular.TmplAstBoundAttribute &&
+                expressionUsesMember(attribute.value, locals, usage)) ||
+            templateNodesUseMember(node.children, templateLocals, usage));
+    }
+    return node instanceof angular.TmplAstContent
+        ? templateNodesUseMember(node.children, locals, usage)
+        : blockUsesMember(node, locals, usage, templateNodesUseMember);
+};
+const inputsUseMember = (inputs, locals, usage) => inputs.some((input) => expressionUsesMember(input.value, locals, usage));
+const eventsUseMember = (events, locals, usage) => {
+    const eventLocals = withNames(locals, ["$event"]);
+    return events.some((event) => expressionUsesMember(event.handler, eventLocals, usage));
+};
+export { templateNodesUseMember };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/angular/angular-template-usage-context.d.ts

@@ -0,0 +1,26 @@
+import * as angular from "@angular/compiler";
+import * as ts from "typescript";
+import type { PublicMember } from "../../domain/architecture/no-unused-public-members/member-declaration-utilities.js";
+type AngularTemplateNode = ReturnType<typeof angular.parseTemplate>["nodes"][number];
+type MemberPathSegment = {
+    call: true;
+} | {
+    name: string;
+};
+type TemplateLocals = ReadonlyMap<string, angular.AST | undefined>;
+interface TemplateMemberPath {
+    root: "component" | "implicit";
+    segments: MemberPathSegment[];
+}
+type TemplateNodeVisitor = (nodes: AngularTemplateNode[], locals: TemplateLocals, usage: TemplateUsageContext) => boolean;
+interface TemplateUsageContext {
+    checker: ts.TypeChecker;
+    component: ts.ClassDeclaration;
+    componentSymbol: ts.Symbol;
+    member: PublicMember;
+}
+declare const withNames: (locals: TemplateLocals, names: readonly string[]) => TemplateLocals;
+declare const withAlias: (locals: TemplateLocals, name: string, value: angular.AST) => TemplateLocals;
+export type { AngularTemplateNode, TemplateLocals, TemplateMemberPath, TemplateNodeVisitor, TemplateUsageContext, };
+export { withAlias, withNames };
+//# sourceMappingURL=angular-template-usage-context.d.ts.map

package/dist/adapters/angular/angular-template-usage-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-template-usage-context.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/angular-template-usage-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,mBAAmB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iFAAiF,CAAC;AAEpH,KAAK,mBAAmB,GAAG,UAAU,CACnC,OAAO,OAAO,CAAC,aAAa,CAC7B,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnB,KAAK,iBAAiB,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,KAAK,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,CAAC;AAEnE,UAAU,kBAAkB;IAC1B,IAAI,EAAE,WAAW,GAAG,UAAU,CAAC;IAC/B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC/B;AAED,KAAK,mBAAmB,GAAG,CACzB,KAAK,EAAE,mBAAmB,EAAE,EAC5B,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,oBAAoB,KACxB,OAAO,CAAC;AAEb,UAAU,oBAAoB;IAC5B,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC;IAC/B,eAAe,EAAE,EAAE,CAAC,MAAM,CAAC;IAC3B,MAAM,EAAE,YAAY,CAAC;CACtB;AAED,QAAA,MAAM,SAAS,GACb,QAAQ,cAAc,EACtB,OAAO,SAAS,MAAM,EAAE,KACvB,cAMF,CAAC;AAEF,QAAA,MAAM,SAAS,GACb,QAAQ,cAAc,EACtB,MAAM,MAAM,EACZ,OAAO,OAAO,CAAC,GAAG,KACjB,cAAqD,CAAC;AAEzD,YAAY,EACV,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,CAAC;AACF,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,CAAC"}

package/dist/adapters/angular/angular-template-usage-context.js

@@ -0,0 +1,12 @@
+import * as angular from "@angular/compiler";
+import * as ts from "typescript";
+const withNames = (locals, names) => {
+    const extended = new Map(locals);
+    for (const name of names) {
+        extended.set(name, undefined);
+    }
+    return extended;
+};
+const withAlias = (locals, name, value) => new Map([...locals, [name, value]]);
+export { withAlias, withNames };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/adapters/angular/index.d.ts

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

package/dist/adapters/angular/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC"}

package/dist/adapters/angular/index.js

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

package/dist/adapters/angular/no-unused-public-members-template-adapter.d.ts

@@ -0,0 +1,15 @@
+import type { MemberUsageAdapter } from "../../domain/architecture/no-unused-public-members/member-usage-utilities.js";
+/**
+ * Resolves public-member usage in statically declared Angular templates.
+ * @param sourceFile TypeScript source file being inspected.
+ * @param checker TypeScript checker for the project.
+ * @param member Public member whose template usage is being checked.
+ * @returns Whether an Angular template references the member.
+ * @example
+ * ```typescript
+ * const used = angularTemplateUsageAdapter(sourceFile, checker, member);
+ * ```
+ */
+declare const angularTemplateUsageAdapter: MemberUsageAdapter;
+export { angularTemplateUsageAdapter };
+//# sourceMappingURL=no-unused-public-members-template-adapter.d.ts.map

package/dist/adapters/angular/no-unused-public-members-template-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unused-public-members-template-adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/no-unused-public-members-template-adapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2EAA2E,CAAC;AAsBpH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,2BAA2B,EAAE,kBAqB/B,CAAC;AA8IL,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/adapters/angular/no-unused-public-members-template-adapter.js

@@ -0,0 +1,126 @@
+import * as angular from "@angular/compiler";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import * as ts from "typescript";
+import { templateNodesUseMember } from "./angular-template-node-usage-utilities.js";
+const componentTemplateCache = new WeakMap();
+const parsedTemplateCache = new WeakMap();
+/**
+ * Resolves public-member usage in statically declared Angular templates.
+ * @param sourceFile TypeScript source file being inspected.
+ * @param checker TypeScript checker for the project.
+ * @param member Public member whose template usage is being checked.
+ * @returns Whether an Angular template references the member.
+ * @example
+ * ```typescript
+ * const used = angularTemplateUsageAdapter(sourceFile, checker, member);
+ * ```
+ */
+const angularTemplateUsageAdapter = (sourceFile, checker, member) => sourceFile.statements.some((statement) => {
+    if (!ts.isClassDeclaration(statement)) {
+        return false;
+    }
+    const template = getComponentTemplate(statement, sourceFile, checker);
+    const componentSymbol = statement.name === undefined
+        ? undefined
+        : checker.getSymbolAtLocation(statement.name);
+    return (template !== undefined &&
+        componentSymbol !== undefined &&
+        templateUsesMember(template, statement, componentSymbol, checker, member));
+});
+const getComponentTemplate = (declaration, sourceFile, checker) => {
+    if (componentTemplateCache.has(declaration)) {
+        return componentTemplateCache.get(declaration);
+    }
+    const decorators = ts.canHaveDecorators(declaration)
+        ? (ts.getDecorators(declaration) ?? [])
+        : [];
+    for (const decorator of decorators) {
+        if (!ts.isCallExpression(decorator.expression) ||
+            !ts.isIdentifier(decorator.expression.expression) ||
+            !isAngularComponentImport(decorator.expression.expression, checker)) {
+            continue;
+        }
+        const [metadata] = decorator.expression.arguments;
+        if (metadata === undefined || !ts.isObjectLiteralExpression(metadata)) {
+            continue;
+        }
+        for (const property of metadata.properties) {
+            if (!ts.isPropertyAssignment(property) ||
+                (!ts.isIdentifier(property.name) &&
+                    !ts.isStringLiteralLike(property.name))) {
+                continue;
+            }
+            if (property.name.text === "template" &&
+                ts.isStringLiteralLike(property.initializer)) {
+                const template = {
+                    content: property.initializer.text,
+                    filePath: sourceFile.fileName,
+                };
+                componentTemplateCache.set(declaration, template);
+                return template;
+            }
+            if (property.name.text === "templateUrl" &&
+                ts.isStringLiteralLike(property.initializer)) {
+                const filePath = path.resolve(path.dirname(sourceFile.fileName), property.initializer.text);
+                const template = readTemplateFile(filePath);
+                componentTemplateCache.set(declaration, template);
+                return template;
+            }
+        }
+    }
+    componentTemplateCache.set(declaration, undefined);
+    return undefined;
+};
+const isAngularComponentImport = (identifier, checker) => checker.getSymbolAtLocation(identifier)?.declarations?.some((declaration) => {
+    if (!ts.isImportSpecifier(declaration)) {
+        return false;
+    }
+    const importClause = declaration.parent.parent;
+    if (!ts.isImportClause(importClause)) {
+        return false;
+    }
+    const importDeclaration = importClause.parent;
+    return (ts.isImportDeclaration(importDeclaration) &&
+        ts.isStringLiteral(importDeclaration.moduleSpecifier) &&
+        importDeclaration.moduleSpecifier.text === "@angular/core" &&
+        (declaration.propertyName?.text ?? declaration.name.text) === "Component");
+}) ?? false;
+const readTemplateFile = (filePath) => {
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        return { content: readFileSync(filePath, "utf8"), filePath };
+    }
+    catch {
+        return undefined;
+    }
+};
+const templateUsesMember = (template, component, componentSymbol, checker, member) => {
+    const nodes = getParsedTemplateNodes(template, component);
+    if (nodes === undefined) {
+        return false;
+    }
+    const usage = {
+        checker,
+        component,
+        componentSymbol,
+        member,
+    };
+    return templateNodesUseMember(nodes, new Map(), usage);
+};
+const getParsedTemplateNodes = (template, component) => {
+    if (parsedTemplateCache.has(component)) {
+        return parsedTemplateCache.get(component);
+    }
+    const parsed = angular.parseTemplate(template.content, template.filePath, {
+        enableBlockSyntax: true,
+        enableLetSyntax: true,
+    });
+    const nodes = parsed.errors === null ? parsed.nodes : undefined;
+    parsedTemplateCache.set(component, nodes);
+    return nodes;
+};
+export { angularTemplateUsageAdapter };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-unused-public-members-template-adapter.js","sourceRoot":"","sources":["../../../src/adapters/angular/no-unused-public-members-template-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import * as angular from \"@angular/compiler\";\nimport { existsSync, readFileSync } from \"node:fs\";\nimport path from \"node:path\";\nimport * as ts from \"typescript\";\n\nimport type { PublicMember } from \"../../domain/architecture/no-unused-public-members/member-declaration-utilities\";\nimport type { MemberUsageAdapter } from \"../../domain/architecture/no-unused-public-members/member-usage-utilities\";\nimport type {\n  AngularTemplateNode,\n  TemplateUsageContext,\n} from \"./angular-template-usage-context\";\n\nimport { templateNodesUseMember } from \"./angular-template-node-usage-utilities\";\n\ninterface ComponentTemplate {\n  content: string;\n  filePath: string;\n}\n\nconst componentTemplateCache = new WeakMap<\n  ts.ClassDeclaration,\n  ComponentTemplate | undefined\n>();\nconst parsedTemplateCache = new WeakMap<\n  ts.ClassDeclaration,\n  AngularTemplateNode[] | undefined\n>();\n\n/**\n * Resolves public-member usage in statically declared Angular templates.\n * @param sourceFile TypeScript source file being inspected.\n * @param checker TypeScript checker for the project.\n * @param member Public member whose template usage is being checked.\n * @returns Whether an Angular template references the member.\n * @example\n * ```typescript\n * const used = angularTemplateUsageAdapter(sourceFile, checker, member);\n * ```\n */\nconst angularTemplateUsageAdapter: MemberUsageAdapter = (\n  sourceFile,\n  checker,\n  member,\n) =>\n  sourceFile.statements.some((statement) => {\n    if (!ts.isClassDeclaration(statement)) {\n      return false;\n    }\n\n    const template = getComponentTemplate(statement, sourceFile, checker);\n    const componentSymbol =\n      statement.name === undefined\n        ? undefined\n        : checker.getSymbolAtLocation(statement.name);\n\n    return (\n      template !== undefined &&\n      componentSymbol !== undefined &&\n      templateUsesMember(template, statement, componentSymbol, checker, member)\n    );\n  });\n\nconst getComponentTemplate = (\n  declaration: ts.ClassDeclaration,\n  sourceFile: ts.SourceFile,\n  checker: ts.TypeChecker,\n): ComponentTemplate | undefined => {\n  if (componentTemplateCache.has(declaration)) {\n    return componentTemplateCache.get(declaration);\n  }\n\n  const decorators = ts.canHaveDecorators(declaration)\n    ? (ts.getDecorators(declaration) ?? [])\n    : [];\n\n  for (const decorator of decorators) {\n    if (\n      !ts.isCallExpression(decorator.expression) ||\n      !ts.isIdentifier(decorator.expression.expression) ||\n      !isAngularComponentImport(decorator.expression.expression, checker)\n    ) {\n      continue;\n    }\n\n    const [metadata] = decorator.expression.arguments;\n    if (metadata === undefined || !ts.isObjectLiteralExpression(metadata)) {\n      continue;\n    }\n\n    for (const property of metadata.properties) {\n      if (\n        !ts.isPropertyAssignment(property) ||\n        (!ts.isIdentifier(property.name) &&\n          !ts.isStringLiteralLike(property.name))\n      ) {\n        continue;\n      }\n\n      if (\n        property.name.text === \"template\" &&\n        ts.isStringLiteralLike(property.initializer)\n      ) {\n        const template = {\n          content: property.initializer.text,\n          filePath: sourceFile.fileName,\n        };\n        componentTemplateCache.set(declaration, template);\n        return template;\n      }\n\n      if (\n        property.name.text === \"templateUrl\" &&\n        ts.isStringLiteralLike(property.initializer)\n      ) {\n        const filePath = path.resolve(\n          path.dirname(sourceFile.fileName),\n          property.initializer.text,\n        );\n        const template = readTemplateFile(filePath);\n        componentTemplateCache.set(declaration, template);\n        return template;\n      }\n    }\n  }\n\n  componentTemplateCache.set(declaration, undefined);\n  return undefined;\n};\n\nconst isAngularComponentImport = (\n  identifier: ts.Identifier,\n  checker: ts.TypeChecker,\n): boolean =>\n  checker.getSymbolAtLocation(identifier)?.declarations?.some((declaration) => {\n    if (!ts.isImportSpecifier(declaration)) {\n      return false;\n    }\n\n    const importClause = declaration.parent.parent;\n    if (!ts.isImportClause(importClause)) {\n      return false;\n    }\n\n    const importDeclaration = importClause.parent;\n    return (\n      ts.isImportDeclaration(importDeclaration) &&\n      ts.isStringLiteral(importDeclaration.moduleSpecifier) &&\n      importDeclaration.moduleSpecifier.text === \"@angular/core\" &&\n      (declaration.propertyName?.text ?? declaration.name.text) === \"Component\"\n    );\n  }) ?? false;\n\nconst readTemplateFile = (filePath: string): ComponentTemplate | undefined => {\n  if (!existsSync(filePath)) {\n    return undefined;\n  }\n\n  try {\n    return { content: readFileSync(filePath, \"utf8\"), filePath };\n  } catch {\n    return undefined;\n  }\n};\n\nconst templateUsesMember = (\n  template: ComponentTemplate,\n  component: ts.ClassDeclaration,\n  componentSymbol: ts.Symbol,\n  checker: ts.TypeChecker,\n  member: PublicMember,\n): boolean => {\n  const nodes = getParsedTemplateNodes(template, component);\n  if (nodes === undefined) {\n    return false;\n  }\n\n  const usage: TemplateUsageContext = {\n    checker,\n    component,\n    componentSymbol,\n    member,\n  };\n  return templateNodesUseMember(nodes, new Map(), usage);\n};\n\nconst getParsedTemplateNodes = (\n  template: ComponentTemplate,\n  component: ts.ClassDeclaration,\n): AngularTemplateNode[] | undefined => {\n  if (parsedTemplateCache.has(component)) {\n    return parsedTemplateCache.get(component);\n  }\n\n  const parsed = angular.parseTemplate(template.content, template.filePath, {\n    enableBlockSyntax: true,\n    enableLetSyntax: true,\n  });\n  const nodes = parsed.errors === null ? parsed.nodes : undefined;\n  parsedTemplateCache.set(component, nodes);\n  return nodes;\n};\n\nexport { angularTemplateUsageAdapter };\n"]}

package/dist/adapters/angular/plugin.d.ts

@@ -0,0 +1,12 @@
+import type { Rule } from "eslint";
+/** Plugin namespace used by Angular-specific ESLint configuration. */
+declare const codeperfectAngularPlugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        "no-unused-public-members": Rule.RuleModule;
+    };
+};
+export { codeperfectAngularPlugin };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/adapters/angular/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/adapters/angular/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,IAAI,EAAE,MAAM,QAAQ,CAAC;AAc3C,sEAAsE;AACtE,QAAA,MAAM,wBAAwB;;;;;;;CAG2B,CAAC;AAE1D,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/adapters/angular/plugin.js

@@ -0,0 +1,14 @@
+import { createNoUnusedPublicMembersListener, noUnusedPublicMembersRule, } from "../../domain/architecture/no-unused-public-members/rule.js";
+import { angularTemplateUsageAdapter } from "./no-unused-public-members-template-adapter.js";
+/** Rule variant that includes the opt-in Angular template usage adapter. */
+const angularNoUnusedPublicMembersRule = {
+    ...noUnusedPublicMembersRule,
+    create: createNoUnusedPublicMembersListener([angularTemplateUsageAdapter]),
+};
+/** Plugin namespace used by Angular-specific ESLint configuration. */
+const codeperfectAngularPlugin = {
+    meta: { name: "@codeperfect/eslint-plugin/angular" },
+    rules: { "no-unused-public-members": angularNoUnusedPublicMembersRule },
+};
+export { codeperfectAngularPlugin };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FkYXB0ZXJzL2FuZ3VsYXIvcGx1Z2luLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFDTCxtQ0FBbUMsRUFDbkMseUJBQXlCLEdBQzFCLE1BQU0seURBQXlELENBQUM7QUFDakUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFFMUYsNEVBQTRFO0FBQzVFLE1BQU0sZ0NBQWdDLEdBQW9CO0lBQ3hELEdBQUcseUJBQXlCO0lBQzVCLE1BQU0sRUFBRSxtQ0FBbUMsQ0FBQyxDQUFDLDJCQUEyQixDQUFDLENBQUM7Q0FDM0UsQ0FBQztBQUVGLHNFQUFzRTtBQUN0RSxNQUFNLHdCQUF3QixHQUFHO0lBQy9CLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxvQ0FBb0MsRUFBRTtJQUNwRCxLQUFLLEVBQUUsRUFBRSwwQkFBMEIsRUFBRSxnQ0FBZ0MsRUFBRTtDQUNoQixDQUFDO0FBRTFELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBMaW50ZXIsIFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbmltcG9ydCB7XG4gIGNyZWF0ZU5vVW51c2VkUHVibGljTWVtYmVyc0xpc3RlbmVyLFxuICBub1VudXNlZFB1YmxpY01lbWJlcnNSdWxlLFxufSBmcm9tIFwiLi4vLi4vZG9tYWluL2FyY2hpdGVjdHVyZS9uby11bnVzZWQtcHVibGljLW1lbWJlcnMvcnVsZVwiO1xuaW1wb3J0IHsgYW5ndWxhclRlbXBsYXRlVXNhZ2VBZGFwdGVyIH0gZnJvbSBcIi4vbm8tdW51c2VkLXB1YmxpYy1tZW1iZXJzLXRlbXBsYXRlLWFkYXB0ZXJcIjtcblxuLyoqIFJ1bGUgdmFyaWFudCB0aGF0IGluY2x1ZGVzIHRoZSBvcHQtaW4gQW5ndWxhciB0ZW1wbGF0ZSB1c2FnZSBhZGFwdGVyLiAqL1xuY29uc3QgYW5ndWxhck5vVW51c2VkUHVibGljTWVtYmVyc1J1bGU6IFJ1bGUuUnVsZU1vZHVsZSA9IHtcbiAgLi4ubm9VbnVzZWRQdWJsaWNNZW1iZXJzUnVsZSxcbiAgY3JlYXRlOiBjcmVhdGVOb1VudXNlZFB1YmxpY01lbWJlcnNMaXN0ZW5lcihbYW5ndWxhclRlbXBsYXRlVXNhZ2VBZGFwdGVyXSksXG59O1xuXG4vKiogUGx1Z2luIG5hbWVzcGFjZSB1c2VkIGJ5IEFuZ3VsYXItc3BlY2lmaWMgRVNMaW50IGNvbmZpZ3VyYXRpb24uICovXG5jb25zdCBjb2RlcGVyZmVjdEFuZ3VsYXJQbHVnaW4gPSB7XG4gIG1ldGE6IHsgbmFtZTogXCJAY29kZXBlcmZlY3QvZXNsaW50LXBsdWdpbi9hbmd1bGFyXCIgfSxcbiAgcnVsZXM6IHsgXCJuby11bnVzZWQtcHVibGljLW1lbWJlcnNcIjogYW5ndWxhck5vVW51c2VkUHVibGljTWVtYmVyc1J1bGUgfSxcbn0gc2F0aXNmaWVzIE5vbk51bGxhYmxlPExpbnRlci5Db25maWdbXCJwbHVnaW5zXCJdPltzdHJpbmddO1xuXG5leHBvcnQgeyBjb2RlcGVyZmVjdEFuZ3VsYXJQbHVnaW4gfTtcbiJdfQ==

package/dist/adapters/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,2 @@
+export { codeperfectAngularPlugin } from "./angular/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYWRhcHRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgY29kZXBlcmZlY3RBbmd1bGFyUGx1Z2luIH0gZnJvbSBcIi4vYW5ndWxhclwiO1xuIl19