lint-suite 1.6.0 → 1.6.1

package/eslint.cjs

@@ -128,19 +128,19 @@ var import_globals = __toESM(require("globals"), 1);
 var import_angular_eslint2 = require("angular-eslint");
 var import_config2 = require("eslint/config");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
 var import_utils4 = require("@typescript-eslint/utils");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-class-fields.ts
 var import_utils2 = require("@typescript-eslint/utils");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
 var import_compiler2 = require("@angular/compiler");
 var import_utils = require("@typescript-eslint/utils");
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/angular-expression-reads.util.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
 var import_compiler = require("@angular/compiler");
 var ReadCollector = class extends import_compiler.CombinedRecursiveAstVisitor {
   constructor(boundTarget, action) {
@@ -190,7 +190,7 @@ var collectAngularExpressionReads = (nodes, boundTarget, action) => {
   return collector.reads;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-metadata-reads.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
 var externalTemplates = /* @__PURE__ */ new Map();
 var parser = new import_compiler2.Parser(new import_compiler2.Lexer());
 var templateBinder = new import_compiler2.R3TargetBinder(null);
@@ -328,11 +328,15 @@ var metadataReads = (metadata, component, filename, remainingNames) => {
   return null;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/angular-class-fields.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-class-fields.ts
 var managedApis = {
   input: true,
   model: true,
-  output: true
+  output: true,
+  viewChild: true,
+  viewChildren: true,
+  contentChild: true,
+  contentChildren: true
 };
 var angularName = (node, imports) => {
   if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
@@ -346,6 +350,28 @@ var angularName = (node, imports) => {
   }
   return angularName(node.object, imports);
 };
+var calleeRoot = (node) => {
+  if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+    return node;
+  }
+  if (node.type !== import_utils2.TSESTree.AST_NODE_TYPES.MemberExpression || node.object.type === import_utils2.TSESTree.AST_NODE_TYPES.Super) {
+    return void 0;
+  }
+  return calleeRoot(node.object);
+};
+var isImportBinding = (node, sourceCode) => {
+  const root = calleeRoot(node);
+  if (!root) {
+    return false;
+  }
+  for (let scope = sourceCode.getScope(root); scope; scope = scope.upper) {
+    const variable = scope.set.get(root.name);
+    if (variable) {
+      return variable.defs[0]?.type === "ImportBinding";
+    }
+  }
+  return false;
+};
 var angularClass = (node, imports) => {
   for (const decorator of node.decorators) {
     if (decorator.expression.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) {
@@ -373,24 +399,72 @@ var lifecycleHooks = {
   ngAfterViewChecked: true,
   ngOnDestroy: true
 };
+var formsInterfaceMethods = {
+  AsyncValidator: ["validate", "registerOnValidatorChange"],
+  ControlValueAccessor: [
+    "writeValue",
+    "registerOnChange",
+    "registerOnTouched",
+    "setDisabledState"
+  ],
+  Validator: ["validate", "registerOnValidatorChange"]
+};
+var implementedFormsMethods = (node) => {
+  const methods = /* @__PURE__ */ new Set();
+  for (const heritage of node.implements) {
+    if (heritage.expression.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+      continue;
+    }
+    for (const name of formsInterfaceMethods[heritage.expression.name] ?? []) {
+      methods.add(name);
+    }
+  }
+  return methods;
+};
 var isInstanceMethod = (node) => node.type === import_utils2.TSESTree.AST_NODE_TYPES.MethodDefinition && node.key.type === import_utils2.TSESTree.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) => {
+var isAngularComponentRefField = (node, sourceCode) => {
+  const type = node.typeAnnotation?.typeAnnotation;
+  if (type?.type !== import_utils2.TSESTree.AST_NODE_TYPES.TSTypeReference || type.typeName.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+    return false;
+  }
+  const reference = sourceCode.getScope(type.typeName).references.find(({ identifier }) => identifier === type.typeName);
+  const variable = reference?.resolved;
+  const definition = variable?.defs[0];
+  return definition?.type === "ImportBinding" && definition.node.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier && definition.parent?.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration && definition.parent.source.value === "@angular/core" && (definition.node.imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier && definition.node.imported.name === "ComponentRef" || definition.node.imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && definition.node.imported.value === "ComponentRef");
+};
+var isExcludedField = (node, localPrivateOnly, sourceCode) => node.static || node.declare || node.override || node.decorators.length > 0 || isAngularComponentRefField(node, sourceCode) || localPrivateOnly && node.accessibility !== "private";
+var hasAutomaticEffectCleanup = (node) => {
+  const options = node.arguments[1];
+  if (options === void 0) {
+    return true;
+  }
+  if (options.type !== import_utils2.TSESTree.AST_NODE_TYPES.ObjectExpression) {
+    return false;
+  }
+  return options.properties.every((property) => {
+    if (property.type !== import_utils2.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+      return false;
+    }
+    const manualCleanup = property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup" || property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
+    return !manualCleanup || property.value.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.value.value === false;
+  });
+};
+var isManagedField = (node, imports, allowEffectFields, sourceCode) => {
   if (node.value?.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const name = angularName(node.value.callee, imports);
-  return typeof name === "string" && managedApis[name] === true;
+  return typeof name === "string" && managedApis[name] === true || allowEffectFields && name === "effect" && isImportBinding(node.value.callee, sourceCode) && hasAutomaticEffectCleanup(node.value);
 };
-var field = (node, imports, component) => {
-  if (isInstanceField(node) && !isExcludedField(node, component) && !isManagedField(node, imports)) {
+var field = (node, imports, localPrivateOnly, allowEffectFields, sourceCode) => {
+  if (isInstanceField(node) && !isExcludedField(node, localPrivateOnly, sourceCode) && !isManagedField(node, imports, allowEffectFields, sourceCode)) {
     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)) {
+var isExcludedMethod = (node, localPrivateOnly, implementedMethods) => node.static || node.override || node.decorators.length > 0 || node.computed || node.kind !== "method" || node.value.body === null || lifecycleHooks[node.key.name] === true || implementedMethods.has(node.key.name) || localPrivateOnly && node.accessibility !== "private";
+var method = (node, localPrivateOnly, implementedMethods) => {
+  if (isInstanceMethod(node) && !isExcludedMethod(node, localPrivateOnly, implementedMethods)) {
     return { messageId: "unusedMethod", name: node.key.name, node };
   }
   return null;
@@ -408,15 +482,24 @@ var addAngularImport = (node, imports) => {
     }
   }
 };
-var reportUnusedMembers = (context, imports, classes, dynamicClasses) => {
+var reportUnusedMembers = (context, imports, classes, dynamicClasses, allowEffectFields, projectMemberUsed) => {
+  const projectAnalysis = projectMemberUsed !== void 0;
   for (const entry of classes) {
     const ngClass = angularClass(entry.node, imports);
     if (!ngClass || dynamicClasses.has(entry)) {
       continue;
     }
+    const localPrivateOnly = !projectAnalysis && (!ngClass.component || entry.node.abstract === true);
+    const implementedMethods = implementedFormsMethods(entry.node);
     const members = [];
     for (const node of entry.node.body.body) {
-      const candidate = field(node, imports, ngClass.component) ?? method(node, ngClass.component);
+      const candidate = field(
+        node,
+        imports,
+        localPrivateOnly,
+        allowEffectFields,
+        context.sourceCode
+      ) ?? method(node, localPrivateOnly, implementedMethods);
       if (candidate) {
         members.push(candidate);
       }
@@ -440,18 +523,800 @@ var reportUnusedMembers = (context, imports, classes, dynamicClasses) => {
       continue;
     }
     for (const candidate of unreadMembers) {
-      if (!reads.has(candidate.name)) {
-        context.report({
-          data: { name: candidate.name },
-          messageId: candidate.messageId,
-          node: candidate.node.key
-        });
+      if (reads.has(candidate.name) || projectMemberUsed?.(candidate.node) === true) {
+        continue;
+      }
+      context.report({
+        data: { name: candidate.name },
+        messageId: candidate.messageId,
+        node: candidate.node.key
+      });
+    }
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
+var compilerCli = __toESM(require("@angular/compiler-cli"), 1);
+var import_typescript4 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/spec-file.ts
+var isSpecFile = (fileName) => /\.spec\.[cm]?[tj]sx?$/u.test(fileName);
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
+var import_node_fs2 = require("node:fs");
+var import_compiler3 = require("@angular/compiler");
+var import_typescript3 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/type-property-symbols.ts
+var import_typescript = require("typescript");
+var symbolsForName = (checker, type, name) => {
+  const symbol = checker.getPropertyOfType(checker.getApparentType(type), name);
+  if (symbol) {
+    return [symbol];
+  }
+  if (!type.isUnionOrIntersection()) {
+    return [];
+  }
+  const symbols = /* @__PURE__ */ new Set();
+  for (const member of type.types) {
+    for (const memberSymbol of symbolsForName(checker, member, name)) {
+      symbols.add(memberSymbol);
+    }
+  }
+  return [...symbols];
+};
+var stringIndexTypes = (checker, type) => {
+  const indexedType = checker.getIndexTypeOfType(
+    checker.getApparentType(type),
+    import_typescript.IndexKind.String
+  );
+  if (indexedType) {
+    return [indexedType];
+  }
+  if (!type.isUnionOrIntersection()) {
+    return [];
+  }
+  const indexedTypes = /* @__PURE__ */ new Set();
+  for (const member of type.types) {
+    for (const memberIndexedType of stringIndexTypes(checker, member)) {
+      indexedTypes.add(memberIndexedType);
+    }
+  }
+  return [...indexedTypes];
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-discovery.ts
+var import_typescript2 = require("typescript");
+var importedFromAngularCore = (declaration) => {
+  let current = declaration;
+  while (current.parent) {
+    current = current.parent;
+    if ((0, import_typescript2.isImportDeclaration)(current)) {
+      return (0, import_typescript2.isStringLiteralLike)(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
+    }
+  }
+  return false;
+};
+var isAngularComponentDecorator = (expression, checker) => {
+  const unresolved = checker.getSymbolAtLocation(expression);
+  if (!unresolved) {
+    return false;
+  }
+  const symbol = (unresolved.flags & import_typescript2.SymbolFlags.Alias) === 0 ? unresolved : checker.getAliasedSymbol(unresolved);
+  return symbol.getName() === "Component" && ((unresolved.declarations ?? []).some(importedFromAngularCore) || (symbol.declarations ?? []).some(
+    (declaration) => declaration.getSourceFile().fileName.replaceAll("\\", "/").includes("/node_modules/@angular/core/")
+  ));
+};
+var componentMetadata = (declaration, checker) => {
+  if (!(0, import_typescript2.canHaveDecorators)(declaration)) {
+    return void 0;
+  }
+  for (const decorator of (0, import_typescript2.getDecorators)(declaration) ?? []) {
+    if (!(0, import_typescript2.isCallExpression)(decorator.expression) || !isAngularComponentDecorator(decorator.expression.expression, checker)) {
+      continue;
+    }
+    const metadata = decorator.expression.arguments[0];
+    return metadata && (0, import_typescript2.isObjectLiteralExpression)(metadata) ? metadata : null;
+  }
+  return void 0;
+};
+var inlineTemplate = (declaration, checker) => {
+  const metadata = componentMetadata(declaration, checker);
+  if (!metadata) {
+    return null;
+  }
+  for (const property of metadata.properties) {
+    if ((0, import_typescript2.isPropertyAssignment)(property) && ((0, import_typescript2.isIdentifier)(property.name) || (0, import_typescript2.isStringLiteralLike)(property.name) || (0, import_typescript2.isNumericLiteral)(property.name)) && property.name.text === "template") {
+      return (0, import_typescript2.isStringLiteralLike)(property.initializer) ? property.initializer.text : null;
+    }
+  }
+  return null;
+};
+var projectComponents = (program, checker) => {
+  const declarations = [];
+  let valid = true;
+  const visit = (node) => {
+    if ((0, import_typescript2.isClassLike)(node)) {
+      const metadata = componentMetadata(node, checker);
+      if (metadata === null) {
+        valid = false;
+      } else if (metadata) {
+        declarations.push(node);
+      }
+    }
+    (0, import_typescript2.forEachChild)(node, visit);
+  };
+  for (const sourceFile of program.getSourceFiles()) {
+    if (!sourceFile.isDeclarationFile && !program.isSourceFileFromExternalLibrary(sourceFile) && !isSpecFile(sourceFile.fileName)) {
+      visit(sourceFile);
+    }
+  }
+  return valid ? declarations : null;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
+var propertyIdentifierKind = 0;
+var referenceIdentifierKind = 5;
+var RootCollector = class extends import_compiler3.CombinedRecursiveAstVisitor {
+  roots = [];
+  visitPropertyRead(node, context) {
+    if (node.receiver instanceof import_compiler3.ImplicitReceiver || node.receiver instanceof import_compiler3.ThisReceiver) {
+      this.roots.push(node);
+    }
+    return super.visitPropertyRead(node, context);
+  }
+};
+var readChain = (node) => {
+  const names = [];
+  let current = node;
+  let called = false;
+  while (true) {
+    names.unshift({ called, name: current.name });
+    if (current.receiver instanceof import_compiler3.PropertyRead || current.receiver instanceof import_compiler3.SafePropertyRead) {
+      current = current.receiver;
+      called = false;
+      continue;
+    }
+    if (current.receiver instanceof import_compiler3.Call) {
+      if (!(current.receiver.receiver instanceof import_compiler3.PropertyRead) && !(current.receiver.receiver instanceof import_compiler3.SafePropertyRead)) {
+        return null;
+      }
+      current = current.receiver.receiver;
+      called = true;
+      continue;
+    }
+    return (current.receiver instanceof import_compiler3.ImplicitReceiver || current.receiver instanceof import_compiler3.ThisReceiver) && current instanceof import_compiler3.PropertyRead ? { names, root: current } : null;
+  }
+};
+var ReadCollector2 = class extends import_compiler3.CombinedRecursiveAstVisitor {
+  reads = [];
+  record(node) {
+    const chain = readChain(node);
+    if (chain) {
+      this.reads.push(chain);
+    }
+  }
+  visitBinary(node, context) {
+    if (node.operation !== "=") {
+      return super.visitBinary(node, context);
+    }
+    if (node.left instanceof import_compiler3.PropertyRead || node.left instanceof import_compiler3.SafePropertyRead || node.left instanceof import_compiler3.KeyedRead || node.left instanceof import_compiler3.SafeKeyedRead) {
+      this.visit(node.left.receiver);
+    }
+    if (node.left instanceof import_compiler3.KeyedRead || node.left instanceof import_compiler3.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 templateText = (declaration, component, checker) => {
+  if (component.template.fileUrl === component.fileUrl) {
+    return inlineTemplate(declaration, checker);
+  }
+  return (0, import_node_fs2.readFileSync)(component.template.fileUrl, "utf8");
+};
+var isPropertyIdentifier = (identifier) => identifier.kind === propertyIdentifierKind;
+var addResolvedPath = (declaration, names, checker, addDeclaration, allowMissingRoot) => {
+  let types = [checker.getTypeAtLocation(declaration)];
+  for (const [index, segment] of names.entries()) {
+    const symbols = new Set(
+      types.flatMap((type) => symbolsForName(checker, type, segment.name))
+    );
+    if (symbols.size === 0) {
+      const indexedTypes = types.flatMap(
+        (type) => stringIndexTypes(checker, type)
+      );
+      if (indexedTypes.length > 0) {
+        types = indexedTypes;
+        continue;
+      }
+      if (types.some(
+        (type) => (type.flags & (import_typescript3.TypeFlags.Any | import_typescript3.TypeFlags.Unknown)) !== 0
+      )) {
+        return true;
+      }
+      return index === 0 && allowMissingRoot;
+    }
+    for (const symbol of symbols) {
+      for (const memberDeclaration of symbol.declarations ?? []) {
+        addDeclaration(memberDeclaration);
+      }
+    }
+    types = [...symbols].map(
+      (symbol) => checker.getTypeOfSymbolAtLocation(symbol, declaration)
+    );
+    if (segment.called) {
+      const returnTypes = types.flatMap(
+        (type) => checker.getSignaturesOfType(type, import_typescript3.SignatureKind.Call).map((signature) => signature.getReturnType())
+      );
+      if (returnTypes.length === 0) {
+        if (types.some(
+          (type) => (type.flags & (import_typescript3.TypeFlags.Any | import_typescript3.TypeFlags.Unknown)) !== 0
+        )) {
+          return true;
+        }
+        return false;
+      }
+      types = returnTypes;
+    }
+  }
+  return true;
+};
+var addTemplateReads = (declaration, component, checker, addDeclaration, missingRootNames) => {
+  const source = templateText(declaration, component, checker);
+  if (source === null) {
+    return false;
+  }
+  const parsed = (0, import_compiler3.parseTemplate)(source, component.template.fileUrl);
+  if (parsed.errors?.length) {
+    return false;
+  }
+  const roots = new RootCollector();
+  const reads = new ReadCollector2();
+  for (const node of parsed.nodes) {
+    roots.visit(node);
+    reads.visit(node);
+  }
+  roots.roots.sort((left, right) => left.nameSpan.start - right.nameSpan.start);
+  const indexedRoots = [...component.template.identifiers].filter(isPropertyIdentifier).sort((left, right) => left.span.start - right.span.start);
+  const indexedByRoot = /* @__PURE__ */ new Map();
+  let indexedRootIndex = 0;
+  for (const root of roots.roots) {
+    const identifier = indexedRoots[indexedRootIndex];
+    if (identifier?.name === root.name) {
+      indexedByRoot.set(root, identifier);
+      indexedRootIndex += 1;
+    } else if (!missingRootNames.has(root.name)) {
+      return false;
+    }
+  }
+  if (indexedRootIndex !== indexedRoots.length) {
+    return false;
+  }
+  for (const chain of reads.reads) {
+    const identifier = indexedByRoot.get(chain.root);
+    if (!identifier) {
+      if (missingRootNames.has(chain.root.name)) {
+        continue;
       }
+      return false;
+    }
+    if (identifier.target === null) {
+      if (!addResolvedPath(
+        declaration,
+        chain.names,
+        checker,
+        addDeclaration,
+        true
+      )) {
+        return false;
+      }
+      continue;
+    }
+    if (identifier.target.kind !== referenceIdentifierKind) {
+      continue;
+    }
+    const referenceTarget = identifier.target.target;
+    if (!referenceTarget) {
+      return false;
+    }
+    const targetDeclaration = referenceTarget.directive;
+    const targetNames = chain.names.slice(1);
+    const targetResolved = !targetDeclaration || addResolvedPath(
+      targetDeclaration,
+      targetNames,
+      checker,
+      addDeclaration,
+      false
+    );
+    if (!targetResolved) {
+      return false;
     }
   }
+  return true;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/typescript-field-reads.util.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
+var hasReadConfiguration = (value) => "readConfiguration" in value && typeof value.readConfiguration === "function";
+var contextIndexErrorPattern = /^Impossible state: "(.+)" not found in "/u;
+var missingContextRootNames = (errors) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const error of errors) {
+    const match = contextIndexErrorPattern.exec(error.message);
+    if (!match?.[1]) {
+      return null;
+    }
+    names.add(match[1]);
+  }
+  return names;
+};
+var reusingCompilerHost = (program, options) => {
+  const base2 = (0, import_typescript4.createCompilerHost)(options, true);
+  return {
+    ...base2,
+    getSourceFile: (fileName, ...rest) => program.getSourceFile(fileName) ?? base2.getSourceFile(fileName, ...rest)
+  };
+};
+var collectAngularTemplateReads = (program, configFilePath, addDeclaration) => {
+  if (!hasReadConfiguration(compilerCli)) {
+    return null;
+  }
+  const configuration = compilerCli.readConfiguration(configFilePath);
+  if (configuration.errors.some(
+    (diagnostic) => diagnostic.category === import_typescript4.DiagnosticCategory.Error
+  )) {
+    return null;
+  }
+  const angularProgram = new compilerCli.NgtscProgram(
+    configuration.rootNames,
+    configuration.options,
+    reusingCompilerHost(program, configuration.options)
+  );
+  if (angularProgram.getNgOptionDiagnostics().some(
+    (diagnostic) => diagnostic.category === import_typescript4.DiagnosticCategory.Error
+  )) {
+    return null;
+  }
+  const indexedComponents = angularProgram.getIndexedComponents();
+  const typescriptProgram = angularProgram.getTsProgram();
+  const checker = typescriptProgram.getTypeChecker();
+  const components = projectComponents(typescriptProgram, checker);
+  if (!components || components.some((declaration) => !indexedComponents.has(declaration))) {
+    return null;
+  }
+  const templateFiles = /* @__PURE__ */ new Set();
+  for (const [declaration, component] of indexedComponents) {
+    if (isSpecFile(declaration.getSourceFile().fileName)) {
+      continue;
+    }
+    const missingRootNames = missingContextRootNames(component.errors);
+    if (!missingRootNames) {
+      return null;
+    }
+    if (!addTemplateReads(
+      declaration,
+      component,
+      checker,
+      addDeclaration,
+      missingRootNames
+    )) {
+      return null;
+    }
+    if (component.template.fileUrl !== component.fileUrl) {
+      templateFiles.add(component.template.fileUrl);
+    }
+  }
+  return [...templateFiles];
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
+var import_typescript7 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
+var import_typescript6 = require("typescript");
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-symbol-reads.ts
+var import_typescript5 = require("typescript");
+var addSymbolDeclarations = (checker, symbol, addDeclaration) => {
+  const resolved = (symbol.flags & import_typescript5.SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);
+  for (const declaration of resolved.declarations ?? []) {
+    addDeclaration(declaration);
+  }
+};
+var allPropertySymbols = (checker, type) => {
+  const symbols = new Set(
+    checker.getPropertiesOfType(checker.getApparentType(type))
+  );
+  if (type.isUnionOrIntersection()) {
+    for (const member of type.types) {
+      for (const symbol of allPropertySymbols(checker, member)) {
+        symbols.add(symbol);
+      }
+    }
+  }
+  return [...symbols];
+};
+var addNamedProperties = (checker, type, names, addDeclaration) => {
+  const symbols = names ? names.flatMap((name) => symbolsForName(checker, type, name)) : allPropertySymbols(checker, type);
+  for (const symbol of symbols) {
+    addSymbolDeclarations(checker, symbol, addDeclaration);
+  }
+  return symbols;
+};
+var literalPropertyNames = (type) => {
+  if (type.isStringLiteral() || type.isNumberLiteral()) {
+    return [String(type.value)];
+  }
+  if (!type.isUnion()) {
+    return null;
+  }
+  const names = [];
+  for (const member of type.types) {
+    const memberNames = literalPropertyNames(member);
+    if (!memberNames) {
+      return null;
+    }
+    names.push(...memberNames);
+  }
+  return names;
+};
+var propertyName = (checker, node) => {
+  if ((0, import_typescript5.isIdentifier)(node) || (0, import_typescript5.isPrivateIdentifier)(node) || (0, import_typescript5.isStringLiteralLike)(node) || (0, import_typescript5.isNumericLiteral)(node) || (0, import_typescript5.isBigIntLiteral)(node)) {
+    return [node.text];
+  }
+  return literalPropertyNames(checker.getTypeAtLocation(node.expression));
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
+var isBindingPattern = (node) => (0, import_typescript6.isArrayBindingPattern)(node) || (0, import_typescript6.isObjectBindingPattern)(node);
+var lazyType = (compute) => {
+  let type;
+  return () => type ??= compute();
+};
+var skippable = (names, nested, candidateNames) => !nested && names !== null && !names.some((name) => candidateNames.has(name));
+var collectBindingPattern = (pattern, type, checker, addDeclaration, candidateNames) => {
+  if ((0, import_typescript6.isArrayBindingPattern)(pattern)) {
+    for (const [index, element] of pattern.elements.entries()) {
+      if ((0, import_typescript6.isOmittedExpression)(element)) {
+        continue;
+      }
+      const names = element.dotDotDotToken ? null : [String(index)];
+      const nested = isBindingPattern(element.name);
+      if (skippable(names, nested, candidateNames)) {
+        continue;
+      }
+      const symbols = addNamedProperties(
+        checker,
+        type(),
+        names,
+        addDeclaration
+      );
+      if (nested) {
+        for (const symbol of symbols) {
+          collectBindingPattern(
+            element.name,
+            lazyType(() => checker.getTypeOfSymbolAtLocation(symbol, element)),
+            checker,
+            addDeclaration,
+            candidateNames
+          );
+        }
+      }
+    }
+    return;
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  for (const element of pattern.elements) {
+    if (element.dotDotDotToken) {
+      for (const symbol of allPropertySymbols(checker, type())) {
+        if (!consumed.has(symbol.name)) {
+          addSymbolDeclarations(checker, symbol, addDeclaration);
+        }
+      }
+      continue;
+    }
+    const names = element.propertyName ? propertyName(checker, element.propertyName) : (0, import_typescript6.isIdentifier)(element.name) ? [element.name.text] : null;
+    for (const name of names ?? []) {
+      consumed.add(name);
+    }
+    const nested = isBindingPattern(element.name);
+    if (skippable(names, nested, candidateNames)) {
+      continue;
+    }
+    const symbols = addNamedProperties(checker, type(), names, addDeclaration);
+    if (nested) {
+      for (const symbol of symbols) {
+        collectBindingPattern(
+          element.name,
+          lazyType(() => checker.getTypeOfSymbolAtLocation(symbol, element)),
+          checker,
+          addDeclaration,
+          candidateNames
+        );
+      }
+    }
+  }
+};
+var collectAssignmentPattern = (pattern, type, checker, addDeclaration, candidateNames) => {
+  if ((0, import_typescript6.isArrayLiteralExpression)(pattern)) {
+    for (const [index, element] of pattern.elements.entries()) {
+      if ((0, import_typescript6.isOmittedExpression)(element)) {
+        continue;
+      }
+      const names = (0, import_typescript6.isSpreadElement)(element) ? null : [String(index)];
+      const nested = (0, import_typescript6.isArrayLiteralExpression)(element) || (0, import_typescript6.isObjectLiteralExpression)(element);
+      if (skippable(names, nested, candidateNames)) {
+        continue;
+      }
+      const symbols = addNamedProperties(
+        checker,
+        type(),
+        names,
+        addDeclaration
+      );
+      if (nested) {
+        for (const symbol of symbols) {
+          collectAssignmentPattern(
+            element,
+            lazyType(() => checker.getTypeOfSymbolAtLocation(symbol, element)),
+            checker,
+            addDeclaration,
+            candidateNames
+          );
+        }
+      }
+    }
+    return;
+  }
+  const consumed = /* @__PURE__ */ new Set();
+  for (const property of pattern.properties) {
+    if ((0, import_typescript6.isSpreadAssignment)(property)) {
+      for (const symbol of allPropertySymbols(checker, type())) {
+        if (!consumed.has(symbol.name)) {
+          addSymbolDeclarations(checker, symbol, addDeclaration);
+        }
+      }
+      continue;
+    }
+    const names = propertyName(checker, property.name);
+    for (const name of names ?? []) {
+      consumed.add(name);
+    }
+    const nested = (0, import_typescript6.isPropertyAssignment)(property) && ((0, import_typescript6.isArrayLiteralExpression)(property.initializer) || (0, import_typescript6.isObjectLiteralExpression)(property.initializer));
+    if (skippable(names, nested, candidateNames)) {
+      continue;
+    }
+    const symbols = addNamedProperties(checker, type(), names, addDeclaration);
+    if (nested) {
+      for (const symbol of symbols) {
+        collectAssignmentPattern(
+          property.initializer,
+          lazyType(() => checker.getTypeOfSymbolAtLocation(symbol, property)),
+          checker,
+          addDeclaration,
+          candidateNames
+        );
+      }
+    }
+  }
+};
+var collectDestructuringReads = (node, checker, addDeclaration, candidateNames) => {
+  const isDestructuringBindingPattern = isBindingPattern(node) && !((0, import_typescript6.isBindingElement)(node.parent) && node.parent.name === node);
+  if (isDestructuringBindingPattern) {
+    const declaration = node.parent;
+    const source = (0, import_typescript6.isVariableDeclaration)(declaration) && declaration.initializer ? declaration.initializer : declaration;
+    collectBindingPattern(
+      node,
+      lazyType(() => checker.getTypeAtLocation(source)),
+      checker,
+      addDeclaration,
+      candidateNames
+    );
+    return;
+  }
+  const isDestructuringAssignment = (0, import_typescript6.isBinaryExpression)(node) && node.operatorToken.kind === import_typescript6.SyntaxKind.EqualsToken && ((0, import_typescript6.isArrayLiteralExpression)(node.left) || (0, import_typescript6.isObjectLiteralExpression)(node.left));
+  if (isDestructuringAssignment) {
+    collectAssignmentPattern(
+      node.left,
+      lazyType(() => checker.getTypeAtLocation(node.right)),
+      checker,
+      addDeclaration,
+      candidateNames
+    );
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
+var isExpressionWrapper = (parent, child) => ((0, import_typescript7.isParenthesizedExpression)(parent) || (0, import_typescript7.isAsExpression)(parent) || (0, import_typescript7.isTypeAssertionExpression)(parent) || (0, import_typescript7.isNonNullExpression)(parent) || (0, import_typescript7.isSatisfiesExpression)(parent)) && parent.expression === child;
+var isPatternContainer = (parent, child) => (0, import_typescript7.isArrayLiteralExpression)(parent) && parent.elements.some((element) => element === child) || (0, import_typescript7.isObjectLiteralExpression)(parent) && parent.properties.some((property) => property === child) || (0, import_typescript7.isPropertyAssignment)(parent) && parent.initializer === child || (0, import_typescript7.isSpreadAssignment)(parent) && parent.expression === child;
+var isWriteOnly = (node) => {
+  let current = node;
+  let parent = node.parent;
+  while (parent && (isExpressionWrapper(parent, current) || isPatternContainer(parent, current))) {
+    current = parent;
+    parent = parent.parent;
+  }
+  const isWriteOnlyBinaryAssignment = (0, import_typescript7.isBinaryExpression)(parent) && parent.left === current && parent.operatorToken.kind === import_typescript7.SyntaxKind.EqualsToken;
+  const isWriteOnlyDelete = (0, import_typescript7.isDeleteExpression)(parent) && parent.expression === current;
+  const isWriteOnlyIteration = ((0, import_typescript7.isForInStatement)(parent) || (0, import_typescript7.isForOfStatement)(parent)) && parent.initializer === current;
+  return isWriteOnlyBinaryAssignment || isWriteOnlyDelete || isWriteOnlyIteration;
+};
+var addPropertyAccessRead = (node, checker, addDeclaration, candidateNames) => {
+  if (!candidateNames.has(node.name.text) || isWriteOnly(node)) {
+    return;
+  }
+  const symbol = checker.getSymbolAtLocation(node.name);
+  if (symbol) {
+    addSymbolDeclarations(checker, symbol, addDeclaration);
+  }
+};
+var addElementAccessRead = (node, checker, addDeclaration, candidateNames) => {
+  if (isWriteOnly(node) || !node.argumentExpression) {
+    return;
+  }
+  const names = literalPropertyNames(
+    checker.getTypeAtLocation(node.argumentExpression)
+  );
+  if (names && !names.some((name) => candidateNames.has(name))) {
+    return;
+  }
+  addNamedProperties(
+    checker,
+    checker.getTypeAtLocation(node.expression),
+    names,
+    addDeclaration
+  );
+};
+var isAngularInterfaceMethod = (symbol) => (symbol.declarations ?? []).some(
+  (declaration) => (0, import_typescript7.isMethodSignature)(declaration) && declaration.getSourceFile().fileName.replaceAll("\\", "/").includes("/node_modules/@angular/")
+);
+var collectAngularInterfaceMethods = (node, checker, addDeclaration) => {
+  const implementsClauses = (node.heritageClauses ?? []).filter(
+    (clause) => clause.token === import_typescript7.SyntaxKind.ImplementsKeyword
+  );
+  if (implementsClauses.length === 0) {
+    return;
+  }
+  const classType = checker.getTypeAtLocation(node);
+  for (const clause of implementsClauses) {
+    for (const heritageType of clause.types) {
+      const type = checker.getTypeAtLocation(heritageType);
+      for (const interfaceMethod of type.getProperties()) {
+        if (!isAngularInterfaceMethod(interfaceMethod)) {
+          continue;
+        }
+        const implementation = classType.getProperty(interfaceMethod.name);
+        if (implementation) {
+          addSymbolDeclarations(checker, implementation, addDeclaration);
+        }
+      }
+    }
+  }
+};
+var collectCandidateNames = (sourceFiles) => {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if ((0, import_typescript7.isClassLike)(node) && (0, import_typescript7.canHaveDecorators)(node) && ((0, import_typescript7.getDecorators)(node)?.length ?? 0) > 0) {
+      for (const member of node.members) {
+        if (member.name && ((0, import_typescript7.isIdentifier)(member.name) || (0, import_typescript7.isStringLiteralLike)(member.name))) {
+          names.add(member.name.text);
+        }
+      }
+    }
+    (0, import_typescript7.forEachChild)(node, visit);
+  };
+  for (const sourceFile of sourceFiles) {
+    visit(sourceFile);
+  }
+  return names;
+};
+var collectTypeScriptReads = (program, addDeclaration) => {
+  const checker = program.getTypeChecker();
+  const sourceFiles = program.getSourceFiles().filter(
+    (sourceFile) => !sourceFile.isDeclarationFile && !program.isSourceFileFromExternalLibrary(sourceFile) && !isSpecFile(sourceFile.fileName) && /\.(?:[cm]?ts|tsx)$/u.test(sourceFile.fileName)
+  );
+  const candidateNames = collectCandidateNames(sourceFiles);
+  const visit = (node) => {
+    if ((0, import_typescript7.isPropertyAccessExpression)(node)) {
+      addPropertyAccessRead(node, checker, addDeclaration, candidateNames);
+    } else if ((0, import_typescript7.isElementAccessExpression)(node)) {
+      addElementAccessRead(node, checker, addDeclaration, candidateNames);
+    } else if ((0, import_typescript7.isClassLike)(node)) {
+      collectAngularInterfaceMethods(node, checker, addDeclaration);
+    }
+    collectDestructuringReads(node, checker, addDeclaration, candidateNames);
+    (0, import_typescript7.forEachChild)(node, visit);
+  };
+  for (const sourceFile of sourceFiles) {
+    visit(sourceFile);
+  }
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
+var projectUsageCache = /* @__PURE__ */ new WeakMap();
+var templateFileVersion = (fileName) => {
+  const { mtimeNs, size } = (0, import_node_fs3.statSync)(fileName, { bigint: true });
+  return { fileName: (0, import_node_path2.resolve)(fileName), mtimeNs, size };
+};
+var templateFileVersionsAreCurrent = (versions) => {
+  try {
+    return versions.every(({ fileName, mtimeNs, size }) => {
+      const current = (0, import_node_fs3.statSync)(fileName, { bigint: true });
+      return current.mtimeNs === mtimeNs && current.size === size;
+    });
+  } catch {
+    return false;
+  }
+};
+var cacheEntryIsCurrent = (entry) => {
+  const now = performance.now();
+  if (now - entry.checkedAt < entry.checkDuration * 20) {
+    return true;
+  }
+  const current = templateFileVersionsAreCurrent(entry.templateFileVersions);
+  entry.checkedAt = now;
+  entry.checkDuration = performance.now() - now;
+  return current;
+};
+var buildProjectUsage = (program) => {
+  try {
+    const configFilePath = program.getCompilerOptions()["configFilePath"];
+    if (typeof configFilePath !== "string") {
+      return null;
+    }
+    const declarations = /* @__PURE__ */ new Set();
+    const addDeclaration = (declaration) => {
+      declarations.add(declaration);
+    };
+    collectTypeScriptReads(program, addDeclaration);
+    const templateFiles = collectAngularTemplateReads(
+      program,
+      configFilePath,
+      addDeclaration
+    );
+    if (!templateFiles) {
+      return null;
+    }
+    return {
+      checkDuration: 0,
+      checkedAt: performance.now(),
+      templateFileVersions: templateFiles.map(templateFileVersion),
+      usage: {
+        has: (node) => declarations.has(node)
+      }
+    };
+  } catch {
+    return null;
+  }
+};
+var projectUsage = (program) => {
+  const cached = projectUsageCache.get(program);
+  if (cached && cacheEntryIsCurrent(cached)) {
+    return cached.usage;
+  }
+  const built = buildProjectUsage(program);
+  if (!built) {
+    projectUsageCache.delete(program);
+    return null;
+  }
+  projectUsageCache.set(program, built);
+  return built.usage;
+};
+
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-field-reads.ts
 var import_utils3 = require("@typescript-eslint/utils");
 var isTypeScriptExpressionWrapper = (node) => {
   switch (node.type) {
@@ -518,7 +1383,7 @@ var isDestructuringOrLoopTarget = (node) => {
   }
   return patternTarget && isSimpleAssignmentTarget(parent, current) || isLoopTarget(parent, current);
 };
-var isWriteOnly = (node) => isDirectWrite(node) || isDestructuringOrLoopTarget(node);
+var isWriteOnly2 = (node) => isDirectWrite(node) || isDestructuringOrLoopTarget(node);
 var destructuringParts = (node) => {
   if (node.type === import_utils3.TSESTree.AST_NODE_TYPES.VariableDeclarator) {
     return { pattern: node.id, source: node.init };
@@ -528,7 +1393,7 @@ var destructuringParts = (node) => {
   }
   return null;
 };
-var propertyName = (property) => {
+var propertyName2 = (property) => {
   if (property.type !== import_utils3.TSESTree.AST_NODE_TYPES.Property || property.computed) {
     return null;
   }
@@ -544,7 +1409,7 @@ var destructuredThisReads = (node) => {
   }
   const reads = [];
   for (const property of parts.pattern.properties) {
-    const name = propertyName(property);
+    const name = propertyName2(property);
     if (name === null) {
       return null;
     }
@@ -553,7 +1418,11 @@ var destructuredThisReads = (node) => {
   return reads;
 };
 
-// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/no-unused-angular-instance-fields.ts
+// packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
+var defaultOptions = {
+  allowEffectFields: false,
+  analysis: "local"
+};
 var createRule = import_utils4.ESLintUtils.RuleCreator(
   () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
 );
@@ -576,7 +1445,7 @@ var trackMemberRead = (node, stack, thisStack, dynamicClasses) => {
   if (node.computed && receiverIsThis) {
     dynamicClasses.add(current);
   }
-  if (receiverIsThis && !node.computed && node.property.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier && !isWriteOnly(node)) {
+  if (receiverIsThis && !node.computed && node.property.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier && !isWriteOnly2(node)) {
     current.reads.add(node.property.name);
   }
 };
@@ -633,7 +1502,7 @@ var lexicalThisVisitor = (thisStack) => ({
     }
   }
 });
-var visitor = (context, imports, classes, stack, dynamicClasses) => {
+var visitor = (context, imports, classes, stack, dynamicClasses, allowEffectFields, projectMemberUsed) => {
   const thisStack = [];
   return {
     ClassDeclaration(node) {
@@ -661,10 +1530,26 @@ var visitor = (context, imports, classes, stack, dynamicClasses) => {
       trackDestructuringRead(node, stack, thisStack, dynamicClasses);
     },
     "Program:exit"() {
-      reportUnusedMembers(context, imports, classes, dynamicClasses);
+      reportUnusedMembers(
+        context,
+        imports,
+        classes,
+        dynamicClasses,
+        allowEffectFields,
+        projectMemberUsed
+      );
     }
   };
 };
+var projectParserServices = (context) => {
+  try {
+    return import_utils4.ESLintUtils.getParserServices(context);
+  } catch {
+    throw new Error(
+      "Project analysis requires parser services with type information."
+    );
+  }
+};
 var no_unused_angular_instance_fields_default = createRule({
   name: "no-unused-instance-fields",
   meta: {
@@ -676,23 +1561,70 @@ var no_unused_angular_instance_fields_default = createRule({
       unusedField: "Angular instance field '{{name}}' is never read.",
       unusedMethod: "Angular instance method '{{name}}' is never read."
     },
-    schema: []
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowEffectFields: {
+            type: "boolean",
+            description: "Allow Angular effect() fields with automatic cleanup."
+          },
+          analysis: {
+            type: "string",
+            enum: ["local", "project"],
+            description: "Choose local-file or typed whole-project analysis."
+          }
+        },
+        additionalProperties: false
+      }
+    ]
   },
-  defaultOptions: [],
-  create(context) {
+  defaultOptions: [defaultOptions],
+  create(context, [options]) {
+    const analysis = options.analysis ?? "local";
+    if (analysis === "project" && isSpecFile(context.filename)) {
+      return {};
+    }
+    const parserServices = analysis === "project" ? projectParserServices(context) : void 0;
     const imports = /* @__PURE__ */ new Map();
     for (const node of context.sourceCode.ast.body) {
       if (node.type === import_utils4.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
         addAngularImport(node, imports);
       }
     }
-    if (imports.size === 0) {
+    let hasAngularClassImport = false;
+    for (const imported of imports.values()) {
+      if (imported === null || imported === "Component" || imported === "Directive") {
+        hasAngularClassImport = true;
+        break;
+      }
+    }
+    if (!hasAngularClassImport) {
       return {};
     }
+    let projectMemberUsed;
+    if (parserServices) {
+      let usage;
+      projectMemberUsed = (node) => {
+        if (usage === void 0) {
+          usage = projectUsage(parserServices.program);
+        }
+        return usage?.has(parserServices.esTreeNodeToTSNodeMap.get(node)) ?? true;
+      };
+    }
     const classes = [];
     const stack = [];
     const dynamicClasses = /* @__PURE__ */ new Set();
-    return visitor(context, imports, classes, stack, dynamicClasses);
+    const allowEffectFields = options.allowEffectFields ?? false;
+    return visitor(
+      context,
+      imports,
+      classes,
+      stack,
+      dynamicClasses,
+      allowEffectFields,
+      projectMemberUsed
+    );
   }
 });
 
@@ -714,11 +1646,17 @@ var angular = (0, import_config2.defineConfig)([
         ...import_globals.default.browser,
         ...import_globals.default.es2025,
         ...import_globals.default.node
+      },
+      parserOptions: {
+        projectService: true
       }
     },
     processor: import_angular_eslint2.processInlineTemplates,
     rules: {
-      "lint-suite-angular/no-unused-instance-fields": "error",
+      "lint-suite-angular/no-unused-instance-fields": [
+        "error",
+        { analysis: "project" }
+      ],
       "@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",
@@ -1102,44 +2040,38 @@ var import_eslint_import_resolver_typescript = require("eslint-import-resolver-t
 var import_eslint_plugin_import_x2 = __toESM(require("eslint-plugin-import-x"), 1);
 var import_config9 = require("eslint/config");
 
-// packages/lint-suite/src/lib/rules/explicit-accessibility.ts
+// packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
 var import_utils5 = require("@typescript-eslint/utils");
+var accessibilities = [
+  "public",
+  "private",
+  "protected"
+];
 var createRule2 = import_utils5.ESLintUtils.RuleCreator(
-  () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
+  () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
 );
-var defaultOptions = {
-  defaultAccessibility: "private"
-};
-var getNodeName = (node) => {
-  if (!node) {
-    return "<unknown>";
-  }
-  if ("key" in node && node.key) {
-    if (node.key.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-      return node.key.name;
-    }
-    if (node.key.type === import_utils5.TSESTree.AST_NODE_TYPES.PrivateIdentifier) {
-      return `#${node.key.name}`;
-    }
-    return "<computed/complex key>";
+var isPrivateMember = (node) => node.type !== import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty && node.key.type === import_utils5.TSESTree.AST_NODE_TYPES.PrivateIdentifier;
+var isConstructor = (node) => node.type === import_utils5.TSESTree.AST_NODE_TYPES.MethodDefinition && node.kind === "constructor";
+var reportTarget = (node) => {
+  if (node.type !== import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
+    return node.key;
   }
-  if ("kind" in node && node.kind === "constructor") {
-    return "constructor";
+  const { parameter } = node;
+  if (parameter.type === import_utils5.TSESTree.AST_NODE_TYPES.AssignmentPattern && parameter.left.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
+    return parameter.left;
   }
-  if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
-    const param = node.parameter;
-    if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-      return param.name;
-    }
-    if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
-      if (param.left.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-        return param.left.name;
-      }
-      return "<destructured parameter>";
-    }
-    return "<complex parameter>";
-  }
-  return "<unknown>";
+  return parameter;
+};
+var memberName = (target, sourceCode) => target.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier ? target.name : sourceCode.getText(target);
+var insertModifier = (node, accessibility, sourceCode) => {
+  const lastDecorator = node.decorators.at(-1);
+  const token = lastDecorator ? sourceCode.getTokenAfter(lastDecorator) : sourceCode.getFirstToken(node);
+  if (!token) {
+    return () => null;
+  }
+  const adjacentToDecorator = lastDecorator?.range[1] === token.range[0];
+  const text2 = `${adjacentToDecorator ? " " : ""}${accessibility} `;
+  return (fixer) => fixer.insertTextBefore(token, text2);
 };
 var explicit_accessibility_default = createRule2({
   name: "explicit-accessibility",
@@ -1149,87 +2081,157 @@ var explicit_accessibility_default = createRule2({
       description: "Require explicit accessibility modifiers on class members"
     },
     fixable: "code",
+    hasSuggestions: true,
     schema: [
       {
         type: "object",
         properties: {
           defaultAccessibility: {
             type: "string",
-            enum: ["public", "private", "protected"],
-            description: "The accessibility modifier to add if one is missing."
+            enum: ["public", "private", "protected", "none"],
+            description: "The accessibility modifier inserted by the auto-fix; constructors always get public. 'none' reports without an auto-fix and offers all three levels as suggestions."
           }
         },
         additionalProperties: false
       }
     ],
     messages: {
-      missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected)."
+      missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected).",
+      setAccessibility: "Add the '{{ accessibility }}' modifier."
     }
   },
-  defaultOptions: [defaultOptions],
-  create(context, [options]) {
-    const { defaultAccessibility } = { ...defaultOptions, ...options };
-    const sourceCode = context.sourceCode;
-    function checkNode(node) {
-      if (node.accessibility) {
+  defaultOptions: [{ defaultAccessibility: "public" }],
+  create(context, [{ defaultAccessibility = "public" }]) {
+    const { sourceCode } = context;
+    const check = (node) => {
+      if (node.accessibility || isPrivateMember(node)) {
         return;
       }
-      let reportNode = node;
-      const name = getNodeName(node);
-      if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.MethodDefinition || node.type === import_utils5.TSESTree.AST_NODE_TYPES.PropertyDefinition) {
-        reportNode = node.key;
-      } else {
-        const param = node.parameter;
-        if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-          reportNode = param;
-        } else if (param.type === import_utils5.TSESTree.AST_NODE_TYPES.AssignmentPattern && param.left.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
-          reportNode = param.left;
-        }
-      }
+      const target = reportTarget(node);
+      const fixAccessibility = isConstructor(node) && defaultAccessibility !== "none" ? "public" : defaultAccessibility;
       context.report({
-        node: reportNode ?? node,
+        node: target,
         messageId: "missingAccessibility",
-        data: { name },
-        fix(fixer) {
-          let insertText = `${defaultAccessibility} `;
-          let tokenToInsertBefore;
-          if (node.decorators.length > 0) {
-            const lastDecorator = node.decorators[node.decorators.length - 1];
-            tokenToInsertBefore = sourceCode.getTokenAfter(lastDecorator);
-          } else {
-            tokenToInsertBefore = sourceCode.getFirstToken(node);
-          }
-          if (node.type === import_utils5.TSESTree.AST_NODE_TYPES.TSParameterProperty && node.readonly) {
-            const firstToken = sourceCode.getFirstToken(node);
-            if (firstToken?.value === "readonly") {
-              tokenToInsertBefore = firstToken;
-            }
-          }
-          if (!tokenToInsertBefore) return null;
-          const tokenAfterInsertion = sourceCode.getTokenAfter(
-            tokenToInsertBefore,
-            { includeComments: false }
-          );
-          const textBetween = sourceCode.text.slice(
-            tokenToInsertBefore.range[1],
-            tokenAfterInsertion?.range[0]
-          );
-          if (!/^\s/.test(textBetween)) {
-            insertText = ` ${insertText}`;
-          }
-          return fixer.insertTextBefore(tokenToInsertBefore, insertText);
-        }
+        data: { name: memberName(target, sourceCode) },
+        ...fixAccessibility === "none" ? {} : { fix: insertModifier(node, fixAccessibility, sourceCode) },
+        suggest: accessibilities.filter((accessibility) => accessibility !== fixAccessibility).map((accessibility) => ({
+          messageId: "setAccessibility",
+          data: { accessibility },
+          fix: insertModifier(node, accessibility, sourceCode)
+        }))
       });
+    };
+    return {
+      AccessorProperty: check,
+      MethodDefinition: check,
+      PropertyDefinition: check,
+      TSAbstractAccessorProperty: check,
+      TSAbstractMethodDefinition: check,
+      TSAbstractPropertyDefinition: check,
+      TSParameterProperty: check
+    };
+  }
+});
+
+// packages/lint-suite/src/lib/rules/no-inline-object-types/no-inline-object-types.ts
+var import_utils6 = require("@typescript-eslint/utils");
+var createRule3 = import_utils6.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
+);
+var enclosingTypeAlias = (node) => {
+  let current = node.parent;
+  while (current && current.type !== import_utils6.TSESTree.AST_NODE_TYPES.Program) {
+    if (current.type === import_utils6.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return void 0;
+};
+var no_inline_object_types_default = createRule3({
+  name: "no-inline-object-types",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require nested object types inside a type alias to be extracted to a named type alias"
+    },
+    schema: [],
+    messages: {
+      inlineObjectType: "Inline object type must be extracted to a named type alias."
     }
+  },
+  defaultOptions: [],
+  create(context) {
     return {
-      MethodDefinition(node) {
-        checkNode(node);
-      },
-      PropertyDefinition(node) {
-        checkNode(node);
-      },
-      TSParameterProperty(node) {
-        checkNode(node);
+      TSTypeLiteral(node) {
+        if (node.parent.type !== import_utils6.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration && enclosingTypeAlias(node)) {
+          context.report({ node, messageId: "inlineObjectType" });
+        }
+      }
+    };
+  }
+});
+
+// packages/lint-suite/src/lib/rules/readonly-type-properties/readonly-type-properties.ts
+var import_utils7 = require("@typescript-eslint/utils");
+var createRule4 = import_utils7.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#readonly-type-properties"
+);
+var propertyName3 = (node, sourceCode) => node.key.type === import_utils7.TSESTree.AST_NODE_TYPES.Identifier ? node.key.name : sourceCode.getText(node.key);
+var PRIMITIVE_KEYWORDS = /* @__PURE__ */ new Set([
+  import_utils7.TSESTree.AST_NODE_TYPES.TSStringKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSSymbolKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSNullKeyword,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSUndefinedKeyword
+]);
+var isPrimitive = (type) => {
+  if (PRIMITIVE_KEYWORDS.has(type.type)) {
+    return true;
+  }
+  if (type.type === import_utils7.TSESTree.AST_NODE_TYPES.TSLiteralType || type.type === import_utils7.TSESTree.AST_NODE_TYPES.TSTemplateLiteralType) {
+    return true;
+  }
+  if (type.type === import_utils7.TSESTree.AST_NODE_TYPES.TSUnionType || type.type === import_utils7.TSESTree.AST_NODE_TYPES.TSIntersectionType) {
+    return type.types.every(isPrimitive);
+  }
+  return false;
+};
+var readonly_type_properties_default = createRule4({
+  name: "readonly-type-properties",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require readonly on primitive-typed type and interface properties"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      missingReadonly: "Type property '{{ name }}' should be readonly. Disable this rule on the line if mutation is required."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const { sourceCode } = context;
+    return {
+      TSPropertySignature(node) {
+        if (node.readonly || !node.typeAnnotation) {
+          return;
+        }
+        if (!isPrimitive(node.typeAnnotation.typeAnnotation)) {
+          return;
+        }
+        context.report({
+          node: node.key,
+          messageId: "missingReadonly",
+          data: { name: propertyName3(node, sourceCode) },
+          fix(fixer) {
+            const firstToken = sourceCode.getFirstToken(node);
+            return firstToken ? fixer.insertTextBefore(firstToken, "readonly ") : null;
+          }
+        });
       }
     };
   }
@@ -1238,7 +2240,9 @@ var explicit_accessibility_default = createRule2({
 // packages/lint-suite/src/lib/typescript.ts
 var localTypescriptRules = {
   rules: {
-    "explicit-accessibility": explicit_accessibility_default
+    "explicit-accessibility": explicit_accessibility_default,
+    "readonly-type-properties": readonly_type_properties_default,
+    "no-inline-object-types": no_inline_object_types_default
   }
 };
 var typescript = (0, import_config9.defineConfig)([
@@ -1255,7 +2259,8 @@ var typescript = (0, import_config9.defineConfig)([
     plugins: { local: localTypescriptRules },
     rules: {
       "local/explicit-accessibility": "error",
-      "@typescript-eslint/explicit-member-accessibility": "error",
+      "local/readonly-type-properties": "error",
+      "local/no-inline-object-types": "error",
       "@typescript-eslint/explicit-function-return-type": "error",
       "@typescript-eslint/no-empty-function": "error",
       "@typescript-eslint/no-unused-vars": "error",