lint-suite 1.4.0 → 1.6.0

package/eslint.js

@@ -79,10 +79,604 @@ var angularTemplate = defineConfig([
 import globals from "globals";
 import { configs as configs2, processInlineTemplates } from "angular-eslint";
 import { defineConfig as defineConfig2 } from "eslint/config";
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
+import { ESLintUtils, TSESTree as TSESTree4 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
+import { TSESTree as TSESTree2 } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
+import { readFileSync, statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import {
+  Lexer,
+  ParseLocation,
+  ParseSourceFile,
+  ParseSourceSpan,
+  Parser,
+  R3TargetBinder,
+  parseTemplate
+} from "@angular/compiler";
+import { TSESTree } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/angular-expression-reads.util.ts
+import {
+  CombinedRecursiveAstVisitor,
+  ImplicitReceiver,
+  KeyedRead,
+  PropertyRead,
+  SafeKeyedRead,
+  SafePropertyRead,
+  ThisReceiver
+} from "@angular/compiler";
+var ReadCollector = class extends CombinedRecursiveAstVisitor {
+  constructor(boundTarget, action) {
+    super();
+    this.boundTarget = boundTarget;
+    this.action = action;
+  }
+  boundTarget;
+  action;
+  reads = /* @__PURE__ */ new Set();
+  record(node) {
+    if (node.receiver instanceof ThisReceiver) {
+      this.reads.add(node.name);
+      return;
+    }
+    if (node.receiver instanceof ImplicitReceiver && (!this.action || node.name !== "$event") && !this.boundTarget?.getExpressionTarget(node)) {
+      this.reads.add(node.name);
+    }
+  }
+  visitBinary(node, context) {
+    if (node.operation !== "=") {
+      return super.visitBinary(node, context);
+    }
+    if (node.left instanceof PropertyRead || node.left instanceof SafePropertyRead || node.left instanceof KeyedRead || node.left instanceof SafeKeyedRead) {
+      this.visit(node.left.receiver);
+    }
+    if (node.left instanceof KeyedRead || node.left instanceof SafeKeyedRead) {
+      this.visit(node.left.key);
+    }
+    this.visit(node.right);
+    return void 0;
+  }
+  visitPropertyRead(node, context) {
+    this.record(node);
+    return super.visitPropertyRead(node, context);
+  }
+  visitSafePropertyRead(node, context) {
+    this.record(node);
+    return super.visitSafePropertyRead(node, context);
+  }
+};
+var collectAngularExpressionReads = (nodes, boundTarget, action) => {
+  const collector = new ReadCollector(boundTarget, action);
+  for (const node of nodes) {
+    collector.visit(node);
+  }
+  return collector.reads;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
+var externalTemplates = /* @__PURE__ */ new Map();
+var parser = new Parser(new Lexer());
+var templateBinder = new R3TargetBinder(null);
+var text = (node) => {
+  if (node?.type === TSESTree.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return node?.type === TSESTree.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? node.quasis[0].value.cooked : null;
+};
+var templateReads = (template, filename) => {
+  try {
+    const result = parseTemplate(template, filename);
+    if (result.errors?.length) {
+      return null;
+    }
+    return collectAngularExpressionReads(
+      result.nodes,
+      templateBinder.bind({ template: result.nodes }),
+      false
+    );
+  } catch {
+    return null;
+  }
+};
+var externalTemplateReads = (filename) => {
+  try {
+    const stats = statSync(filename, { bigint: true });
+    const version = `${stats.mtimeNs}:${stats.size}`;
+    const cached = externalTemplates.get(filename);
+    if (cached?.version === version) {
+      return cached.reads;
+    }
+    const reads = templateReads(readFileSync(filename, "utf8"), filename);
+    externalTemplates.set(filename, { reads, version });
+    return reads;
+  } catch {
+    return null;
+  }
+};
+var expressionReads = (expression, filename, action) => {
+  try {
+    const file = new ParseSourceFile(expression, filename);
+    const start = new ParseLocation(file, 0, 0, 0);
+    const span = new ParseSourceSpan(start, start.moveBy(expression.length));
+    const result = action ? parser.parseAction(expression, span, 0) : parser.parseBinding(expression, span, 0);
+    if (result.errors.length > 0) {
+      return null;
+    }
+    return collectAngularExpressionReads([result], void 0, action);
+  } catch {
+    return null;
+  }
+};
+var addReads = (target, source) => {
+  if (!source) {
+    return false;
+  }
+  for (const name of source) {
+    target.add(name);
+  }
+  return true;
+};
+var key = (property) => {
+  if (property.type !== TSESTree.AST_NODE_TYPES.Property || property.computed) {
+    return null;
+  }
+  return property.key.type === TSESTree.AST_NODE_TYPES.Identifier ? property.key.name : text(property.key);
+};
+var metadataValue = (metadata, name) => {
+  for (const property of metadata.properties) {
+    if (property.type === TSESTree.AST_NODE_TYPES.Property && key(property) === name) {
+      return property.value;
+    }
+  }
+  return void 0;
+};
+var hostPropertyReads = (property, reads, filename) => {
+  const name = key(property);
+  const expression = text(property.value);
+  if (name === null || expression === null) {
+    return false;
+  }
+  if (name.startsWith("[")) {
+    return addReads(reads, expressionReads(expression, filename, false));
+  }
+  if (name.startsWith("(")) {
+    return addReads(reads, expressionReads(expression, filename, true));
+  }
+  return true;
+};
+var hostReads = (host, reads, filename) => {
+  if (!host) {
+    return true;
+  }
+  if (host.type !== TSESTree.AST_NODE_TYPES.ObjectExpression || host.properties.some((property) => key(property) === null)) {
+    return false;
+  }
+  for (const property of host.properties) {
+    if (property.type !== TSESTree.AST_NODE_TYPES.Property || !hostPropertyReads(property, reads, filename)) {
+      return false;
+    }
+  }
+  return true;
+};
+var inlineTemplateReads = (template, reads, filename) => {
+  if (!template) {
+    return true;
+  }
+  const source = text(template);
+  return source !== null && addReads(reads, templateReads(source, filename));
+};
+var externalTemplatePropertyReads = (templateUrl, reads, filename) => {
+  if (!templateUrl) {
+    return true;
+  }
+  const url = text(templateUrl);
+  return url !== null && addReads(reads, externalTemplateReads(resolve(dirname(filename), url)));
+};
+var componentTemplateReads = (metadata, reads, filename) => {
+  const template = metadataValue(metadata, "template");
+  const templateUrl = metadataValue(metadata, "templateUrl");
+  return inlineTemplateReads(template, reads, filename) && externalTemplatePropertyReads(templateUrl, reads, filename);
+};
+var metadataReads = (metadata, component, filename, remainingNames) => {
+  if (metadata.properties.some((property) => key(property) === null)) {
+    return null;
+  }
+  const reads = /* @__PURE__ */ new Set();
+  if (!hostReads(metadataValue(metadata, "host"), reads, filename)) {
+    return null;
+  }
+  if (component && remainingNames.every((name) => reads.has(name)) || !component || componentTemplateReads(metadata, reads, filename)) {
+    return reads;
+  }
+  return null;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
+var managedApis = {
+  input: true,
+  model: true,
+  output: true
+};
+var angularName = (node, imports) => {
+  if (node.type === TSESTree2.AST_NODE_TYPES.Identifier) {
+    return imports.get(node.name);
+  }
+  if (node.type !== TSESTree2.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== TSESTree2.AST_NODE_TYPES.Identifier) {
+    return null;
+  }
+  if (node.object.type === TSESTree2.AST_NODE_TYPES.Identifier && imports.get(node.object.name) === null) {
+    return node.property.name;
+  }
+  return angularName(node.object, imports);
+};
+var angularClass = (node, imports) => {
+  for (const decorator of node.decorators) {
+    if (decorator.expression.type !== TSESTree2.AST_NODE_TYPES.CallExpression) {
+      continue;
+    }
+    const kind = angularName(decorator.expression.callee, imports);
+    const metadata = decorator.expression.arguments[0];
+    if ((kind === "Component" || kind === "Directive") && metadata?.type === TSESTree2.AST_NODE_TYPES.ObjectExpression) {
+      return {
+        component: kind === "Component",
+        metadata
+      };
+    }
+  }
+  return null;
+};
+var isInstanceField = (node) => node.type === TSESTree2.AST_NODE_TYPES.PropertyDefinition && node.key.type === TSESTree2.AST_NODE_TYPES.Identifier;
+var lifecycleHooks = {
+  ngOnChanges: true,
+  ngOnInit: true,
+  ngDoCheck: true,
+  ngAfterContentInit: true,
+  ngAfterContentChecked: true,
+  ngAfterViewInit: true,
+  ngAfterViewChecked: true,
+  ngOnDestroy: true
+};
+var isInstanceMethod = (node) => node.type === TSESTree2.AST_NODE_TYPES.MethodDefinition && node.key.type === TSESTree2.AST_NODE_TYPES.Identifier;
+var isExcludedField = (node, component) => node.static || node.declare || node.override || node.decorators.length > 0 || !component && node.accessibility !== "private";
+var isManagedField = (node, imports) => {
+  if (node.value?.type !== TSESTree2.AST_NODE_TYPES.CallExpression) {
+    return false;
+  }
+  const name = angularName(node.value.callee, imports);
+  return typeof name === "string" && managedApis[name] === true;
+};
+var field = (node, imports, component) => {
+  if (isInstanceField(node) && !isExcludedField(node, component) && !isManagedField(node, imports)) {
+    return { messageId: "unusedField", name: node.key.name, node };
+  }
+  return null;
+};
+var isExcludedMethod = (node, component) => node.static || node.override || node.decorators.length > 0 || node.computed || node.kind !== "method" || node.value.body === null || lifecycleHooks[node.key.name] === true || !component && node.accessibility !== "private";
+var method = (node, component) => {
+  if (isInstanceMethod(node) && !isExcludedMethod(node, component)) {
+    return { messageId: "unusedMethod", name: node.key.name, node };
+  }
+  return null;
+};
+var addAngularImport = (node, imports) => {
+  if (node.source.value !== "@angular/core" || node.importKind === "type") {
+    return;
+  }
+  for (const specifier of node.specifiers) {
+    if (specifier.type === TSESTree2.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+      imports.set(specifier.local.name, null);
+    } else if (specifier.type === TSESTree2.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
+      const importedName = specifier.imported.type === TSESTree2.AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
+      imports.set(specifier.local.name, importedName);
+    }
+  }
+};
+var reportUnusedMembers = (context, imports, classes, dynamicClasses) => {
+  for (const entry of classes) {
+    const ngClass = angularClass(entry.node, imports);
+    if (!ngClass || dynamicClasses.has(entry)) {
+      continue;
+    }
+    const members = [];
+    for (const node of entry.node.body.body) {
+      const candidate = field(node, imports, ngClass.component) ?? method(node, ngClass.component);
+      if (candidate) {
+        members.push(candidate);
+      }
+    }
+    if (members.length === 0) {
+      continue;
+    }
+    const unreadMembers = members.filter(
+      (candidate) => !entry.reads.has(candidate.name)
+    );
+    if (unreadMembers.length === 0) {
+      continue;
+    }
+    const reads = metadataReads(
+      ngClass.metadata,
+      ngClass.component,
+      context.filename,
+      unreadMembers.map((candidate) => candidate.name)
+    );
+    if (!reads) {
+      continue;
+    }
+    for (const candidate of unreadMembers) {
+      if (!reads.has(candidate.name)) {
+        context.report({
+          data: { name: candidate.name },
+          messageId: candidate.messageId,
+          node: candidate.node.key
+        });
+      }
+    }
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/typescript-field-reads.util.ts
+import { TSESTree as TSESTree3 } from "@typescript-eslint/utils";
+var isTypeScriptExpressionWrapper = (node) => {
+  switch (node.type) {
+    case TSESTree3.AST_NODE_TYPES.TSAsExpression:
+    case TSESTree3.AST_NODE_TYPES.TSInstantiationExpression:
+    case TSESTree3.AST_NODE_TYPES.TSNonNullExpression:
+    case TSESTree3.AST_NODE_TYPES.TSSatisfiesExpression:
+    case TSESTree3.AST_NODE_TYPES.TSTypeAssertion:
+      return true;
+    default:
+      return false;
+  }
+};
+var unwrapTypeScriptExpression = (node) => {
+  let current = node;
+  while (current && isTypeScriptExpressionWrapper(current)) {
+    current = current.expression;
+  }
+  return current;
+};
+var isThisExpression = (node) => unwrapTypeScriptExpression(node)?.type === TSESTree3.AST_NODE_TYPES.ThisExpression;
+var isPatternTarget = (parent, child) => {
+  switch (parent?.type) {
+    case TSESTree3.AST_NODE_TYPES.ArrayPattern:
+      return parent.elements.some((element) => element === child);
+    case TSESTree3.AST_NODE_TYPES.AssignmentPattern:
+      return parent.left === child;
+    case TSESTree3.AST_NODE_TYPES.ObjectPattern:
+      return parent.properties.some((property) => property === child);
+    case TSESTree3.AST_NODE_TYPES.Property:
+      return parent.value === child && parent.parent.type === TSESTree3.AST_NODE_TYPES.ObjectPattern;
+    case TSESTree3.AST_NODE_TYPES.RestElement:
+      return parent.argument === child;
+    default:
+      return false;
+  }
+};
+var isSimpleAssignmentTarget = (parent, current) => parent?.type === TSESTree3.AST_NODE_TYPES.AssignmentExpression && parent.left === current && parent.operator === "=";
+var isLoopTarget = (parent, current) => (parent?.type === TSESTree3.AST_NODE_TYPES.ForInStatement || parent?.type === TSESTree3.AST_NODE_TYPES.ForOfStatement) && parent.left === current;
+var isDirectWrite = (node) => {
+  let current = node;
+  let parent = node.parent;
+  while (parent && isTypeScriptExpressionWrapper(parent) && parent.expression === current) {
+    current = parent;
+    parent = parent.parent;
+  }
+  return isSimpleAssignmentTarget(parent, current) || parent?.type === TSESTree3.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
+};
+var isDestructuringOrLoopTarget = (node) => {
+  let current = node;
+  let parent = node.parent;
+  let patternTarget = false;
+  while (parent) {
+    const wrapper = isTypeScriptExpressionWrapper(parent) && parent.expression === current;
+    const pattern = isPatternTarget(parent, current);
+    if (!wrapper && !pattern) {
+      break;
+    }
+    if (pattern) {
+      patternTarget = true;
+    }
+    current = parent;
+    parent = parent.parent;
+  }
+  return patternTarget && isSimpleAssignmentTarget(parent, current) || isLoopTarget(parent, current);
+};
+var isWriteOnly = (node) => isDirectWrite(node) || isDestructuringOrLoopTarget(node);
+var destructuringParts = (node) => {
+  if (node.type === TSESTree3.AST_NODE_TYPES.VariableDeclarator) {
+    return { pattern: node.id, source: node.init };
+  }
+  if (node.operator === "=") {
+    return { pattern: node.left, source: node.right };
+  }
+  return null;
+};
+var propertyName = (property) => {
+  if (property.type !== TSESTree3.AST_NODE_TYPES.Property || property.computed) {
+    return null;
+  }
+  if (property.key.type === TSESTree3.AST_NODE_TYPES.Identifier) {
+    return property.key.name;
+  }
+  return property.key.type === TSESTree3.AST_NODE_TYPES.Literal && typeof property.key.value === "string" ? property.key.value : null;
+};
+var destructuredThisReads = (node) => {
+  const parts = destructuringParts(node);
+  if (!parts || parts.pattern.type !== TSESTree3.AST_NODE_TYPES.ObjectPattern || !isThisExpression(parts.source)) {
+    return void 0;
+  }
+  const reads = [];
+  for (const property of parts.pattern.properties) {
+    const name = propertyName(property);
+    if (name === null) {
+      return null;
+    }
+    reads.push(name);
+  }
+  return reads;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
+var createRule = ESLintUtils.RuleCreator(
+  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
+);
+var enterClass = (node, classes, stack, thisStack) => {
+  const entry = {
+    node,
+    reads: /* @__PURE__ */ new Set()
+  };
+  classes.push(entry);
+  stack.push(entry);
+  thisStack.push(true);
+};
+var componentThis = (node, thisStack) => node.type === TSESTree4.AST_NODE_TYPES.ArrowFunctionExpression ? thisStack.at(-1) ?? false : node.parent.type === TSESTree4.AST_NODE_TYPES.MethodDefinition && !node.parent.static;
+var trackMemberRead = (node, stack, thisStack, dynamicClasses) => {
+  const current = stack.at(-1);
+  if (!current || !thisStack.at(-1)) {
+    return;
+  }
+  const receiverIsThis = isThisExpression(node.object);
+  if (node.computed && receiverIsThis) {
+    dynamicClasses.add(current);
+  }
+  if (receiverIsThis && !node.computed && node.property.type === TSESTree4.AST_NODE_TYPES.Identifier && !isWriteOnly(node)) {
+    current.reads.add(node.property.name);
+  }
+};
+var trackDestructuringRead = (node, stack, thisStack, dynamicClasses) => {
+  const current = stack.at(-1);
+  if (!current || !thisStack.at(-1)) {
+    return;
+  }
+  const reads = destructuredThisReads(node);
+  if (reads === void 0) {
+    return;
+  }
+  if (reads === null) {
+    dynamicClasses.add(current);
+    return;
+  }
+  for (const name of reads) {
+    current.reads.add(name);
+  }
+};
+var lexicalThisVisitor = (thisStack) => ({
+  FunctionDeclaration(node) {
+    thisStack.push(componentThis(node, thisStack));
+  },
+  FunctionExpression(node) {
+    thisStack.push(componentThis(node, thisStack));
+  },
+  ArrowFunctionExpression(node) {
+    thisStack.push(componentThis(node, thisStack));
+  },
+  "FunctionDeclaration:exit"() {
+    thisStack.pop();
+  },
+  "FunctionExpression:exit"() {
+    thisStack.pop();
+  },
+  "ArrowFunctionExpression:exit"() {
+    thisStack.pop();
+  },
+  StaticBlock() {
+    thisStack.push(false);
+  },
+  "StaticBlock:exit"() {
+    thisStack.pop();
+  },
+  PropertyDefinition(node) {
+    if (node.static) {
+      thisStack.push(false);
+    }
+  },
+  "PropertyDefinition:exit"(node) {
+    if (node.static) {
+      thisStack.pop();
+    }
+  }
+});
+var visitor = (context, imports, classes, stack, dynamicClasses) => {
+  const thisStack = [];
+  return {
+    ClassDeclaration(node) {
+      enterClass(node, classes, stack, thisStack);
+    },
+    ClassExpression(node) {
+      enterClass(node, classes, stack, thisStack);
+    },
+    "ClassDeclaration:exit"() {
+      stack.pop();
+      thisStack.pop();
+    },
+    "ClassExpression:exit"() {
+      stack.pop();
+      thisStack.pop();
+    },
+    ...lexicalThisVisitor(thisStack),
+    AssignmentExpression(node) {
+      trackDestructuringRead(node, stack, thisStack, dynamicClasses);
+    },
+    MemberExpression(node) {
+      trackMemberRead(node, stack, thisStack, dynamicClasses);
+    },
+    VariableDeclarator(node) {
+      trackDestructuringRead(node, stack, thisStack, dynamicClasses);
+    },
+    "Program:exit"() {
+      reportUnusedMembers(context, imports, classes, dynamicClasses);
+    }
+  };
+};
+var no_unused_angular_instance_fields_default = createRule({
+  name: "no-unused-instance-fields",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unread instance fields and methods in Angular components and directives"
+    },
+    messages: {
+      unusedField: "Angular instance field '{{name}}' is never read.",
+      unusedMethod: "Angular instance method '{{name}}' is never read."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const imports = /* @__PURE__ */ new Map();
+    for (const node of context.sourceCode.ast.body) {
+      if (node.type === TSESTree4.AST_NODE_TYPES.ImportDeclaration) {
+        addAngularImport(node, imports);
+      }
+    }
+    if (imports.size === 0) {
+      return {};
+    }
+    const classes = [];
+    const stack = [];
+    const dynamicClasses = /* @__PURE__ */ new Set();
+    return visitor(context, imports, classes, stack, dynamicClasses);
+  }
+});
+
+// packages/lint-suite/src/lib/angular.ts
+var lintSuiteAngularPlugin = {
+  rules: {
+    "no-unused-instance-fields": no_unused_angular_instance_fields_default
+  }
+};
 var angular = defineConfig2([
   {
     files: ["**/*.ts"],
     extends: [...configs2.tsRecommended],
+    plugins: {
+      "lint-suite-angular": lintSuiteAngularPlugin
+    },
     languageOptions: {
       globals: {
         ...globals.browser,
@@ -92,7 +686,9 @@ var angular = defineConfig2([
     },
     processor: processInlineTemplates,
     rules: {
+      "lint-suite-angular/no-unused-instance-fields": "error",
       "@angular-eslint/prefer-on-push-component-change-detection": "error",
+      // v22: flags only explicit opt-out of OnPush (omission now means OnPush)
       "@angular-eslint/prefer-signals": "error",
       "@angular-eslint/use-injectable-provided-in": "error",
       "@angular-eslint/prefer-signal-model": "error",
@@ -110,8 +706,6 @@ var angular = defineConfig2([
       // Consistent lifecycle method ordering
       "@angular-eslint/computed-must-return": "error",
       // Catch silent computed() bugs missing a return
-      "@angular-eslint/no-conflicting-lifecycle": "error",
-      // Block incompatible hook combinations (OnChanges + DoCheck)
       "@angular-eslint/no-duplicates-in-metadata-arrays": "error",
       // Catch duplicate imports/providers in @Component/@NgModule
       "@angular-eslint/no-lifecycle-call": "error",
@@ -477,8 +1071,8 @@ import importPluginX2 from "eslint-plugin-import-x";
 import { defineConfig as defineConfig9 } from "eslint/config";
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility.ts
-import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
-var createRule = ESLintUtils.RuleCreator(
+import { ESLintUtils as ESLintUtils2, TSESTree as TSESTree5 } from "@typescript-eslint/utils";
+var createRule2 = ESLintUtils2.RuleCreator(
   () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
 );
 var defaultOptions = {
@@ -489,10 +1083,10 @@ var getNodeName = (node) => {
     return "<unknown>";
   }
   if ("key" in node && node.key) {
-    if (node.key.type === TSESTree.AST_NODE_TYPES.Identifier) {
+    if (node.key.type === TSESTree5.AST_NODE_TYPES.Identifier) {
       return node.key.name;
     }
-    if (node.key.type === TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
+    if (node.key.type === TSESTree5.AST_NODE_TYPES.PrivateIdentifier) {
       return `#${node.key.name}`;
     }
     return "<computed/complex key>";
@@ -500,13 +1094,13 @@ var getNodeName = (node) => {
   if ("kind" in node && node.kind === "constructor") {
     return "constructor";
   }
-  if (node.type === TSESTree.AST_NODE_TYPES.TSParameterProperty) {
+  if (node.type === TSESTree5.AST_NODE_TYPES.TSParameterProperty) {
     const param = node.parameter;
-    if (param.type === TSESTree.AST_NODE_TYPES.Identifier) {
+    if (param.type === TSESTree5.AST_NODE_TYPES.Identifier) {
       return param.name;
     }
-    if (param.type === TSESTree.AST_NODE_TYPES.AssignmentPattern) {
-      if (param.left.type === TSESTree.AST_NODE_TYPES.Identifier) {
+    if (param.type === TSESTree5.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.left.type === TSESTree5.AST_NODE_TYPES.Identifier) {
         return param.left.name;
       }
       return "<destructured parameter>";
@@ -515,7 +1109,7 @@ var getNodeName = (node) => {
   }
   return "<unknown>";
 };
-var explicit_accessibility_default = createRule({
+var explicit_accessibility_default = createRule2({
   name: "explicit-accessibility",
   meta: {
     type: "suggestion",
@@ -550,13 +1144,13 @@ var explicit_accessibility_default = createRule({
       }
       let reportNode = node;
       const name = getNodeName(node);
-      if (node.type === TSESTree.AST_NODE_TYPES.MethodDefinition || node.type === TSESTree.AST_NODE_TYPES.PropertyDefinition) {
+      if (node.type === TSESTree5.AST_NODE_TYPES.MethodDefinition || node.type === TSESTree5.AST_NODE_TYPES.PropertyDefinition) {
         reportNode = node.key;
       } else {
         const param = node.parameter;
-        if (param.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        if (param.type === TSESTree5.AST_NODE_TYPES.Identifier) {
           reportNode = param;
-        } else if (param.type === TSESTree.AST_NODE_TYPES.AssignmentPattern && param.left.type === TSESTree.AST_NODE_TYPES.Identifier) {
+        } else if (param.type === TSESTree5.AST_NODE_TYPES.AssignmentPattern && param.left.type === TSESTree5.AST_NODE_TYPES.Identifier) {
           reportNode = param.left;
         }
       }
@@ -573,7 +1167,7 @@ var explicit_accessibility_default = createRule({
           } else {
             tokenToInsertBefore = sourceCode.getFirstToken(node);
           }
-          if (node.type === TSESTree.AST_NODE_TYPES.TSParameterProperty && node.readonly) {
+          if (node.type === TSESTree5.AST_NODE_TYPES.TSParameterProperty && node.readonly) {
             const firstToken = sourceCode.getFirstToken(node);
             if (firstToken?.value === "readonly") {
               tokenToInsertBefore = firstToken;
@@ -878,7 +1472,7 @@ var typescript = defineConfig9([
     ],
     rules: {
       "@typescript-eslint/no-empty-function": "off",
-      "@typescript-eslint/no-unbound-method": "off",
+      "@typescript-eslint/unbound-method": "off",
       "@typescript-eslint/consistent-type-assertions": "off"
     }
   },
@@ -1000,53 +1594,53 @@ var boundaries = defineConfig12([
         "error",
         {
           default: "disallow",
-          message: "${dependency.type} is not allowed to be imported in ${file.type}",
-          rules: [
+          message: "{{to.element.types}} is not allowed to be imported in {{from.element.types}}",
+          policies: [
             {
-              from: { type: "feature" },
+              from: { element: { type: "feature" } },
               allow: [
-                { to: { type: "feature" } },
-                { to: { type: "ui" } },
-                { to: { type: "domain-logic" } },
-                { to: { type: "utils" } },
-                { to: { type: "common" } }
+                { to: { element: { type: "feature" } } },
+                { to: { element: { type: "ui" } } },
+                { to: { element: { type: "domain-logic" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
               ]
             },
             {
-              from: { type: "domain-logic" },
+              from: { element: { type: "domain-logic" } },
               allow: [
-                { to: { type: "domain-logic" } },
-                { to: { type: "data-access" } },
-                { to: { type: "utils" } },
-                { to: { type: "common" } }
+                { to: { element: { type: "domain-logic" } } },
+                { to: { element: { type: "data-access" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
               ]
             },
             {
-              from: { type: "data-access" },
+              from: { element: { type: "data-access" } },
               allow: [
-                { to: { type: "data-access" } },
-                { to: { type: "utils" } },
-                { to: { type: "common" } }
+                { to: { element: { type: "data-access" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
               ]
             },
             {
-              from: { type: "ui" },
+              from: { element: { type: "ui" } },
               allow: [
-                { to: { type: "ui" } },
-                { to: { type: "utils" } },
-                { to: { type: "common" } }
+                { to: { element: { type: "ui" } } },
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
               ]
             },
             {
-              from: { type: "utils" },
+              from: { element: { type: "utils" } },
               allow: [
-                { to: { type: "utils" } },
-                { to: { type: "common" } }
+                { to: { element: { type: "utils" } } },
+                { to: { element: { type: "common" } } }
               ]
             },
             {
-              from: { type: "common" },
-              allow: [{ to: { type: "common" } }]
+              from: { element: { type: "common" } },
+              allow: [{ to: { element: { type: "common" } } }]
             }
           ]
         }