@ethlete/eslint-plugin 1.0.0-next.22 → 1.0.0-next.24

package/src/rules/no-cdk-import.js

@@ -4,6 +4,7 @@
 const { createRequire } = require('node:module');
 const path = require('node:path');
 const fs = require('node:fs');
+const { MODULE_REFERENCE_SELECTOR, getModuleReference } = require('./internals/import-resolution');
 
 /**
  * Disallows importing from `@ethlete/cdk`, the maintenance-mode predecessor of `@ethlete/components`,
@@ -52,13 +53,6 @@ const loadMigrationMap = (mapPath, cwd) => {
   return map;
 };
 
-/** @param {any} specifier */
-const importedName = (specifier) => {
-  if (specifier.type !== 'ImportSpecifier') return null;
-
-  return specifier.imported.name ?? specifier.imported.value ?? null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const noCdkImport = {
   meta: {
@@ -95,13 +89,13 @@ const noCdkImport = {
     const entryFor = (name) => map?.[name] ?? null;
 
     return {
-      ImportDeclaration(node) {
-        const declaration = /** @type {any} */ (node);
-        const source = declaration.source.value;
+      [MODULE_REFERENCE_SELECTOR](node) {
+        const reference = getModuleReference(node);
+        const source = reference?.source;
 
-        if (typeof source !== 'string' || (source !== CDK_PACKAGE && !source.startsWith(`${CDK_PACKAGE}/`))) return;
+        if (!reference || (source !== CDK_PACKAGE && !source?.startsWith(`${CDK_PACKAGE}/`))) return;
 
-        const named = declaration.specifiers.filter(/** @param {any} s */ (s) => importedName(s));
+        const { named } = reference;
 
         if (!named.length) {
           context.report({ node, messageId: 'module', data: { cdk: CDK_PACKAGE, docs: migrationDocs } });
@@ -109,8 +103,7 @@ const noCdkImport = {
           return;
         }
 
-        for (const specifier of named) {
-          const name = /** @type {string} */ (importedName(specifier));
+        for (const { name, node: specifier } of named) {
           const entry = entryFor(name);
 
           if (!entry) {

package/src/rules/no-direct-dom-manipulation.js

@@ -100,6 +100,23 @@ const noDirectDomManipulation = {
 
         const methodName = callee.property.name;
 
+        if (
+          methodName === 'setProperty' &&
+          callee.object.type === 'MemberExpression' &&
+          callee.object.property.type === 'Identifier' &&
+          callee.object.property.name === 'style'
+        ) {
+          context.report({
+            node,
+            messageId: 'domMutation',
+            data: {
+              method: methodName,
+              alternative: 'renderer.setStyle(el, prop, value, RendererStyleFlags2.DashCase)',
+            },
+          });
+          return;
+        }
+
         // ── classList.add / .remove / .toggle / .replace ─────────────────────
         if (
           callee.object.type === 'MemberExpression' &&

package/src/rules/no-document-cookie.js

@@ -21,6 +21,8 @@
  *   deleteCookie('name');
  */
 
+const { isGlobalReference } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noDocumentCookie = {
   meta: {
@@ -42,6 +44,7 @@ const noDocumentCookie = {
         if (
           node.object.type === 'Identifier' &&
           node.object.name === 'document' &&
+          isGlobalReference(context.sourceCode, node.object) &&
           node.property.type === 'Identifier' &&
           node.property.name === 'cookie'
         ) {

package/src/rules/no-effect-cleanup-return.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { ANGULAR_CORE, getImportedName } = require('./internals/import-resolution');
+
 /**
  * Disallows returning a cleanup function from an `effect()` callback.
  *
@@ -115,7 +117,9 @@ const noEffectCleanupReturn = {
       CallExpression(node) {
         const { callee } = node;
 
-        if (callee.type !== 'Identifier' || !EFFECT_CALLEES.has(callee.name)) {
+        const calleeName = getImportedName(context.sourceCode, callee, ANGULAR_CORE);
+
+        if (!calleeName || !EFFECT_CALLEES.has(calleeName)) {
           return;
         }
 
@@ -130,7 +134,7 @@ const noEffectCleanupReturn = {
           context.report({
             node: callback.body,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
           });
 
           return;
@@ -147,21 +151,23 @@ const noEffectCleanupReturn = {
           return;
         }
 
-        // Only the mechanical shape is auto-fixed: a zero-parameter callback whose single `return` hands
-        // back a function literal. With an existing parameter, an early `return`, or a returned reference,
-        // the intent needs a human.
-        // The parameter list's `(` — the first one before the body, so this works for `() => {}` and
-        // `function () {}` alike (their first token differs).
         const openParen = sourceCode
           .getTokens(callback)
           .find((token) => token.value === '(' && token.range[1] <= callback.body.range[0]);
-        const fixable = callback.params.length === 0 && returns.length === 1 && cleanupReturns.length === 1;
+        const callbackScope = sourceCode.getScope(callback);
+        const hasOnCleanupBinding = callbackScope.variables.some((variable) => variable.name === 'onCleanup');
+        const fixable =
+          callback.params.length === 0 &&
+          returns.length === 1 &&
+          cleanupReturns.length === 1 &&
+          callback.body.body.at(-1) === cleanupReturns[0] &&
+          !hasOnCleanupBinding;
 
         for (const statement of cleanupReturns) {
           context.report({
             node: statement.argument,
             messageId: 'returnedCleanup',
-            data: { callee: callee.name },
+            data: { callee: calleeName },
             fix:
               fixable && openParen
                 ? (fixer) => [

package/src/rules/no-empty-angular-metadata-arrays.js

@@ -1,6 +1,10 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
+const { getMetadataEntryRemovalRange } = require('./internals/angular-metadata-fix');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 
 /**
@@ -12,40 +16,6 @@ const getPropertyName = (key) => {
   return null;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
-/**
- * @param {import('eslint').SourceCode} sourceCode
- * @param {any} metadata
- * @param {any} property
- */
-const getRemovalRange = (sourceCode, metadata, property) => {
-  const properties = metadata.properties.filter((entry) => entry.type === 'Property');
-  const propertyIndex = properties.indexOf(property);
-  const openingBrace = sourceCode.getFirstToken(metadata);
-  const closingBrace = sourceCode.getLastToken(metadata);
-
-  if (!openingBrace || !closingBrace) return property.range;
-  if (properties.length === 1) return [openingBrace.range[1], closingBrace.range[0]];
-  if (propertyIndex < properties.length - 1) return [property.range[0], properties[propertyIndex + 1].range[0]];
-
-  return [properties[propertyIndex - 1].range[1], property.range[1]];
-};
-
 const MESSAGE_IDS = {
   hostDirectives: 'noEmptyHostDirectives',
   imports: 'noEmptyImports',
@@ -71,7 +41,7 @@ const noEmptyAngularMetadataArrays = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const decorator = /** @type {any} */ (node);
@@ -92,7 +62,7 @@ const noEmptyAngularMetadataArrays = {
             node: property,
             messageId: MESSAGE_IDS[propertyName],
             fix(fixer) {
-              return fixer.replaceTextRange(getRemovalRange(sourceCode, metadata, property), '');
+              return fixer.replaceTextRange(getMetadataEntryRemovalRange(sourceCode, metadata, property), '');
             },
           });
         }

package/src/rules/no-enum.js

@@ -0,0 +1,115 @@
+// @ts-check
+'use strict';
+
+/**
+ * Disallow `enum` and `const enum` — use a const object plus a derived union type.
+ *
+ * An enum is the only TypeScript construct that emits runtime code from a type declaration, so it
+ * cannot be erased and it cannot be tree-shaken. Its members are nominal, so a plain string is not
+ * assignable to an enum-typed parameter even when the value matches. A `const enum` is worse: a
+ * transpile-only consumer (esbuild, SWC, Babel) has no cross-file type information, so it cannot
+ * inline the member and the build fails or emits a missing binding.
+ *
+ * A const object with `as const` plus a derived union gives the same dotted access, keeps the name
+ * usable in a type position, accepts a matching literal, and tree-shakes.
+ *
+ * BAD:
+ *   export enum MatchState {
+ *     Live = 'live',
+ *   }
+ *
+ * GOOD:
+ *   export const MatchState = {
+ *     Live: 'live',
+ *   } as const;
+ *
+ *   export type MatchState = (typeof MatchState)[keyof typeof MatchState];
+ *
+ * The fixer runs only on an enum whose members all have a string literal initializer. It widens a
+ * member used in a type position (`state: MatchState.Live`), which then needs `typeof`.
+ */
+
+/** typescript-eslint v8 nests members under a TSEnumBody; earlier versions put them on the declaration. */
+const membersOf = (node) => node.body?.members ?? node.members ?? [];
+
+const isStringLiteral = (node) => node?.type === 'Literal' && typeof node.value === 'string';
+
+/** Only a plain string enum converts to a const object without changing what a member holds. */
+const isFixable = (node) => {
+  if (node.declare) return false;
+
+  const members = membersOf(node);
+
+  if (!members.length) return false;
+
+  return members.every(
+    (member) => isStringLiteral(member.initializer) && (member.id.type === 'Identifier' || isStringLiteral(member.id)),
+  );
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEnum = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow enum and const enum. Use a const object with `as const` plus a derived union type.',
+      recommended: true,
+    },
+    fixable: 'code',
+    messages: {
+      noEnum:
+        "No enums. '{{name}}' emits runtime code that cannot be tree-shaken, and its members are nominal. Use a const object with 'as const' plus a derived union type.",
+      noConstEnum:
+        "No 'const enum'. A transpile-only consumer (esbuild, SWC, Babel) cannot inline '{{name}}' and its build fails. Use a const object with 'as const' plus a derived union type.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const { sourceCode } = context;
+
+    const buildReplacement = (node, target) => {
+      const name = node.id.name;
+      const indent = ' '.repeat(target.loc.start.column);
+      const memberIndent = `${indent}  `;
+      const exported = target.type === 'ExportNamedDeclaration' ? 'export ' : '';
+
+      const lines = membersOf(node).flatMap((member) => {
+        const comments = sourceCode.getCommentsBefore(member).flatMap((comment) =>
+          sourceCode
+            .getText(comment)
+            .split('\n')
+            // A block comment's continuation lines carry one more space so the leading `*` stays aligned.
+            .map((line, index) => `${memberIndent}${index === 0 ? '' : ' '}${line.trim()}`),
+        );
+
+        const key = sourceCode.getText(member.id);
+        const value = sourceCode.getText(member.initializer);
+
+        return [...comments, `${memberIndent}${key}: ${value},`];
+      });
+
+      return [
+        `${exported}const ${name} = {`,
+        ...lines,
+        `${indent}} as const;`,
+        '',
+        `${indent}${exported}type ${name} = (typeof ${name})[keyof typeof ${name}];`,
+      ].join('\n');
+    };
+
+    return {
+      TSEnumDeclaration(node) {
+        const target = node.parent?.type === 'ExportNamedDeclaration' ? node.parent : node;
+
+        context.report({
+          node: node.id,
+          messageId: node.const ? 'noConstEnum' : 'noEnum',
+          data: { name: node.id.name },
+          fix: isFixable(node) ? (fixer) => fixer.replaceTextRange(target.range, buildReplacement(node, target)) : null,
+        });
+      },
+    };
+  },
+};
+
+module.exports = noEnum;

package/src/rules/no-inject-chain.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { isImportedAs } = require('./internals/import-resolution');
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noInjectChain = {
   meta: {
@@ -19,7 +21,7 @@ const noInjectChain = {
     return {
       MemberExpression(node) {
         const obj = node.object;
-        if (obj.type === 'CallExpression' && obj.callee.type === 'Identifier' && obj.callee.name === 'inject') {
+        if (obj.type === 'CallExpression' && isImportedAs(context.sourceCode, obj.callee, 'inject')) {
           // Allow inject(X).method() — immediately-invoked patterns like
           // inject(DestroyRef).onDestroy(...) are intentional Angular idioms.
           const parent = node.parent;

package/src/rules/no-leading-underscore-class-member.js

@@ -16,6 +16,16 @@ const getDirectMemberName = (node) => {
   return node.key?.type === 'Identifier' ? node.key.name : null;
 };
 
+/**
+ * @param {any} key
+ * @param {boolean} computed
+ */
+const getReferencedName = (key, computed) => {
+  if (!computed && key?.type === 'Identifier') return key.name;
+  if (key?.type === 'Literal' && typeof key.value === 'string') return key.value;
+  return null;
+};
+
 /** @type {import('eslint').Rule.RuleModule} */
 const noLeadingUnderscoreClassMember = {
   meta: {
@@ -36,6 +46,7 @@ const noLeadingUnderscoreClassMember = {
      *   declaredNames: Set<string>,
      *   membersByName: Map<string, any[]>,
      *   memberReads: any[],
+     *   untrackedNames: Set<string>,
      * }>}
      */
     const classStack = [];
@@ -66,6 +77,7 @@ const noLeadingUnderscoreClassMember = {
           declaredNames: new Set(),
           membersByName: new Map(),
           memberReads: [],
+          untrackedNames: new Set(),
         });
       },
 
@@ -73,11 +85,19 @@ const noLeadingUnderscoreClassMember = {
         const frame = classStack.pop();
         if (!frame) return;
 
+        const targetNameCounts = new Map();
+        for (const oldName of frame.membersByName.keys()) {
+          const newName = getFixedName(oldName);
+          targetNameCounts.set(newName, (targetNameCounts.get(newName) ?? 0) + 1);
+        }
+
         for (const [oldName, memberNodes] of frame.membersByName) {
           const newName = getFixedName(oldName);
           const canFix =
             newName.length > 0 &&
             !frame.declaredNames.has(newName) &&
+            targetNameCounts.get(newName) === 1 &&
+            !frame.untrackedNames.has(oldName) &&
             memberNodes.every((memberNode) => memberNode.accessibility === 'private');
 
           for (const memberNode of memberNodes) {
@@ -108,10 +128,20 @@ const noLeadingUnderscoreClassMember = {
       MemberExpression(node) {
         const frame = classStack[classStack.length - 1];
         if (!frame) return;
-        if (node.object?.type !== 'ThisExpression' || node.computed) return;
-        if (node.property?.type !== 'Identifier') return;
 
-        frame.memberReads.push(node);
+        if (node.object?.type === 'ThisExpression' && !node.computed && node.property?.type === 'Identifier') {
+          frame.memberReads.push(node);
+          return;
+        }
+
+        const name = getReferencedName(node.property, node.computed);
+        if (name) frame.untrackedNames.add(name);
+      },
+
+      'ObjectPattern > Property'(node) {
+        const frame = classStack[classStack.length - 1];
+        const name = getReferencedName(node.key, node.computed);
+        if (frame && name) frame.untrackedNames.add(name);
       },
     };
   },

package/src/rules/no-legacy-angular-decorators.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /**
  * Disallows legacy Angular decorators in favour of their modern signal-based
  * equivalents and the `host: {}` shorthand.
@@ -25,20 +27,6 @@
  *   → ✅ host: { '[class.active]': 'isActive', '(click)': 'onClick()' }
  */
 
-/**
- * Returns the identifier name of a decorator.
- * Works for both `@Foo` (Identifier) and `@Foo(...)` (CallExpression).
- *
- * @param {any} decorator
- * @returns {string | null}
- */
-const getDecoratorName = (decorator) => {
-  const expr = decorator.expression;
-  if (expr.type === 'Identifier') return expr.name;
-  if (expr.type === 'CallExpression' && expr.callee.type === 'Identifier') return expr.callee.name;
-  return null;
-};
-
 /**
  * Returns the static string key of a class member, or null for computed keys.
  *
@@ -72,11 +60,12 @@ const getIndent = (sourceCode, node) => {
 };
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const getAngularMetadata = (classNode) => {
+const getAngularMetadata = (sourceCode, classNode) => {
   for (const decorator of classNode.decorators ?? []) {
-    const decoratorName = getDecoratorName(decorator);
+    const decoratorName = getAngularDecoratorName(sourceCode, decorator);
     if (decoratorName !== 'Component' && decoratorName !== 'Directive') continue;
 
     const expression = decorator.expression;
@@ -106,7 +95,7 @@ const findObjectProperty = (objectExpression, propertyName) =>
  * @param {string} entryText
  */
 const buildObjectTextWithAppendedProperty = (sourceCode, objectExpression, entryText) => {
-  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
+  const properties = objectExpression.properties;
   const isMultiline = Boolean(
     objectExpression.loc && objectExpression.loc.start.line !== objectExpression.loc.end.line,
   );
@@ -138,8 +127,7 @@ ${closingIndent}}`;
  * @param {any} objectExpression
  */
 const hasTrailingComma = (sourceCode, objectExpression) => {
-  const properties = objectExpression.properties.filter((property) => property.type === 'Property');
-  const lastProperty = properties[properties.length - 1];
+  const lastProperty = objectExpression.properties.at(-1);
   if (!lastProperty) return false;
 
   const tokenAfter = sourceCode.getTokenAfter(lastProperty);
@@ -158,7 +146,7 @@ const buildHostBindingFix = (sourceCode, decoratorNode, memberNode, bindingKey,
   const classNode = classBody?.parent;
   if (!classNode) return null;
 
-  const metadata = getAngularMetadata(classNode);
+  const metadata = getAngularMetadata(sourceCode, classNode);
   if (!metadata) return null;
 
   const hostProperty = findObjectProperty(metadata, 'host');
@@ -312,7 +300,7 @@ const rule = {
 
       Decorator(node) {
         const anyNode = /** @type {any} */ (node);
-        const decoratorName = getDecoratorName(anyNode);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, anyNode);
         if (!decoratorName) return;
 
         // Only act on decorators attached to class members, not to the class itself
@@ -379,6 +367,14 @@ const rule = {
                 const expression = anyNode.expression;
                 if (expression.type !== 'CallExpression' && expression.type !== 'Identifier') return null;
 
+                if (
+                  expression.type === 'CallExpression' &&
+                  expression.arguments.length > 0 &&
+                  (expression.arguments[0]?.type !== 'Literal' || typeof expression.arguments[0].value !== 'string')
+                ) {
+                  return null;
+                }
+
                 const bindingName =
                   expression.type === 'CallExpression'
                     ? expression.arguments[0]?.type === 'Literal' && typeof expression.arguments[0].value === 'string'

package/src/rules/no-legacy-prepare-without-injector.js

@@ -273,7 +273,12 @@ const noLegacyPrepareWithoutInjector = {
   },
   create(context) {
     const sourceCode = context.sourceCode;
-    const creatorPattern = new RegExp(context.options[0]?.creatorPattern ?? '^legacy');
+    let creatorPattern;
+    try {
+      creatorPattern = new RegExp(context.options[0]?.creatorPattern ?? '^legacy');
+    } catch {
+      creatorPattern = /^legacy/u;
+    }
     /** Names known to be legacy creators: imported under the naming convention, or declared locally. */
     const creatorNames = new Set();
 
@@ -297,38 +302,42 @@ const noLegacyPrepareWithoutInjector = {
      * @param {string[]} needed
      */
     const buildCoreImportFix = (needed) => {
-      const coreImport = /** @type {any} */ (
-        sourceCode.ast.body.find(
+      const coreImports = /** @type {any[]} */ (
+        sourceCode.ast.body.filter(
           (node) =>
             node.type === 'ImportDeclaration' &&
             node.source.type === 'Literal' &&
             node.source.value === '@angular/core',
         )
       );
+      const existing = new Set(
+        coreImports.flatMap((coreImport) =>
+          coreImport.specifiers
+            .filter((specifier) => specifier.type === 'ImportSpecifier' && coreImport.importKind !== 'type')
+            .map((specifier) => specifier.imported.name),
+        ),
+      );
+      const missing = needed.filter((name) => !existing.has(name));
+      if (missing.length === 0) return null;
+
+      const editableImport = coreImports.find(
+        (coreImport) =>
+          coreImport.importKind !== 'type' &&
+          coreImport.specifiers.length > 0 &&
+          coreImport.specifiers.every((specifier) => specifier.type === 'ImportSpecifier'),
+      );
 
-      if (!coreImport) {
+      if (!editableImport) {
         const imports = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
-        const lastImport = imports[imports.length - 1];
-        const text = `import { ${needed.join(', ')} } from '@angular/core';`;
+        const lastImport = coreImports.at(-1) ?? imports.at(-1);
+        const text = `import { ${missing.join(', ')} } from '@angular/core';`;
 
         return lastImport
           ? /** @param {any} fixer */ (fixer) => fixer.insertTextAfter(lastImport, `\n${text}`)
           : /** @param {any} fixer */ (fixer) => fixer.insertTextBefore(sourceCode.ast.body[0], `${text}\n\n`);
       }
 
-      const specifiers = coreImport.specifiers ?? [];
-
-      if (specifiers.some(/** @param {any} specifier */ (specifier) => specifier.type !== 'ImportSpecifier')) {
-        return null;
-      }
-
-      const existing = new Set(specifiers.map(/** @param {any} specifier */ (specifier) => specifier.imported.name));
-      const missing = needed.filter((name) => !existing.has(name));
-      const lastSpecifier = specifiers[specifiers.length - 1];
-
-      if (missing.length === 0 || !lastSpecifier) {
-        return null;
-      }
+      const lastSpecifier = editableImport.specifiers.at(-1);
 
       return /** @param {any} fixer */ (fixer) => fixer.insertTextAfter(lastSpecifier, `, ${missing.join(', ')}`);
     };
@@ -368,12 +377,6 @@ const noLegacyPrepareWithoutInjector = {
           );
       }
 
-      // `prepare(args)` - spreading is the only way to keep whatever the variable holds.
-      if (argument.type === 'Identifier' || argument.type === 'MemberExpression') {
-        return /** @param {any} fixer */ (fixer) =>
-          fixer.replaceText(argument, `{ ...${sourceCode.getText(argument)}, ${injectorProperty} }`);
-      }
-
       return null;
     };
 
@@ -457,7 +460,20 @@ const noLegacyPrepareWithoutInjector = {
 
         const classBody = findEnclosingClassBody(node);
         const existingInjector = classBody ? findInjectorMemberName(classBody) : null;
-        const injectorName = existingInjector ?? 'injector';
+        const declaredNames = new Set(
+          classBody?.body
+            .map((member) => (member.key?.type === 'Identifier' ? member.key.name : null))
+            .filter(Boolean) ?? [],
+        );
+        let injectorName = existingInjector ?? 'injector';
+        if (!existingInjector && declaredNames.has(injectorName)) {
+          injectorName = 'queryInjector';
+          let suffix = 2;
+          while (declaredNames.has(injectorName)) {
+            injectorName = `queryInjector${suffix}`;
+            suffix += 1;
+          }
+        }
         const argumentFix = classBody ? buildArgumentFix(node, `this.${injectorName}`) : null;
 
         context.report({