@ethlete/eslint-plugin 1.0.0-next.13 → 1.0.0-next.15

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.0.0-next.15
+
+### Minor Changes
+
+- [`6f4b966`](https://github.com/ethlete-io/ethdk/commit/6f4b966c4dc0244b9dfc40978f42362fe9c89a58) Thanks [@TomTomB](https://github.com/TomTomB)! - Expose the `recommendedSpec` flat config (relaxes `no-non-null-assertion` in `*.spec.ts`) as `ethlete.configs.recommendedSpec`.
+
+## 1.0.0-next.14
+
+### Patch Changes
+
+- [`423b30b`](https://github.com/ethlete-io/ethdk/commit/423b30ba4f368d7cee8c464ebd89b5df20d3934c) Thanks [@TomTomB](https://github.com/TomTomB)! - The `static` class member ban now excepts `ngTemplateContextGuard`, which Angular's template type checker requires to be static.
+
+- [`7ca77d4`](https://github.com/ethlete-io/ethdk/commit/7ca77d4a9e1dd3abad7237227c62643159719b74) Thanks [@TomTomB](https://github.com/TomTomB)! - `no-trivial-return-type`: self-referencing (recursive) functions keep their return type annotation — TypeScript cannot infer a return type that depends on itself (TS7023), so the fixer no longer strips it there.
+
 ## 1.0.0-next.13
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.13",
+  "version": "1.0.0-next.15",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",

package/src/configs/recommended.js

@@ -139,9 +139,10 @@ const recommendedTs = {
         selector: 'FunctionExpression[async=true]',
         message: 'No async/await. Use RxJS for all async operations.',
       },
-      // No static class members
+      // No static class members — except ngTemplateContextGuard, which Angular's template
+      // type checker requires to be static (it types a structural directive's `let-` bindings)
       {
-        selector: 'MethodDefinition[static=true]',
+        selector: "MethodDefinition[static=true]:not([key.name='ngTemplateContextGuard'])",
         message: 'No static class members.',
       },
       {

package/src/index.js

@@ -131,6 +131,8 @@ const configs = {
   recommendedTs: recommendedTsWithPlugin,
   /** Angular template rules (merged into a files: ['**\/*.html'] block) */
   recommendedTemplate: recommendedTemplateWithPlugin,
+  /** Relaxed rules for spec files (files: ['**\/*.spec.ts']) */
+  recommendedSpec,
   /**
    * Both together as a flat array — the most common usage:
    *   export default [...baseConfig, ...ethlete.configs.recommended]

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

@@ -116,7 +116,6 @@ const buildObjectTextWithAppendedProperty = (sourceCode, objectExpression, entry
     return existingText.length === 0 ? `{ ${entryText} }` : `{ ${existingText.join(', ')}, ${entryText} }`;
   }
 
-  const openingBrace = sourceCode.getFirstToken(objectExpression);
   const closingBrace = sourceCode.getLastToken(objectExpression);
   const closingIndent = closingBrace ? getIndent(sourceCode, closingBrace) : '';
   const propertyIndent = properties[0] ? getIndent(sourceCode, properties[0]) : `${closingIndent}  `;

package/src/rules/no-trivial-return-type.js

@@ -11,6 +11,11 @@
  *
  * ALSO GOOD (non-trivial, keep it):
  *   const parse = (): Date => new Date(value)
+ *
+ * Self-referencing (recursive) functions are exempt: TypeScript cannot infer a
+ * return type that depends on itself (TS7023 under noImplicitAny), so the
+ * annotation is required there:
+ *   const walk = (node): boolean => node.ok && walk(node.next)
  */
 
 const TRIVIAL_TYPES = new Set([
@@ -69,6 +74,93 @@ const noTrivialReturnType = {
       return false;
     };
 
+    /**
+     * The names under which a function implementation can call itself: its own name
+     * (named function expression, or the variable an arrow is assigned to) and/or
+     * `this.<key>` for class/object methods and class-field arrows.
+     * @param {any} fn
+     */
+    const selfReferenceNames = (fn) => {
+      /** @type {{ kind: 'name' | 'this', name: string }[]} */
+      const names = [];
+
+      if (fn.id && fn.id.type === 'Identifier') {
+        names.push({ kind: 'name', name: fn.id.name });
+      }
+
+      const parent = fn.parent;
+
+      if (parent) {
+        if (
+          (parent.type === 'MethodDefinition' || parent.type === 'PropertyDefinition' || parent.type === 'Property') &&
+          !parent.computed &&
+          parent.key &&
+          parent.key.type === 'Identifier'
+        ) {
+          names.push({ kind: 'this', name: parent.key.name });
+        }
+
+        if (parent.type === 'VariableDeclarator' && parent.id && parent.id.type === 'Identifier') {
+          names.push({ kind: 'name', name: parent.id.name });
+        }
+      }
+
+      return names;
+    };
+
+    /**
+     * Whether the function body references the function itself (recursion) — there the
+     * annotation is required, since TypeScript cannot infer a self-dependent return type.
+     * @param {any} fn
+     */
+    const isSelfReferencing = (fn) => {
+      const names = selfReferenceNames(fn);
+
+      if (!names.length || !fn.body) {
+        return false;
+      }
+
+      const stack = [fn.body];
+
+      while (stack.length) {
+        const current = stack.pop();
+
+        if (!current || typeof current !== 'object') continue;
+
+        if (Array.isArray(current)) {
+          stack.push(...current);
+          continue;
+        }
+
+        if (typeof current.type !== 'string') continue;
+
+        for (const { kind, name } of names) {
+          if (kind === 'name' && current.type === 'Identifier' && current.name === name) {
+            return true;
+          }
+
+          if (
+            kind === 'this' &&
+            current.type === 'MemberExpression' &&
+            current.object.type === 'ThisExpression' &&
+            !current.computed &&
+            current.property.type === 'Identifier' &&
+            current.property.name === name
+          ) {
+            return true;
+          }
+        }
+
+        for (const key of Object.keys(current)) {
+          if (key === 'parent') continue;
+          const value = current[key];
+          if (value && typeof value === 'object') stack.push(value);
+        }
+      }
+
+      return false;
+    };
+
     /**
      * @param {import('eslint').Rule.Node} node
      */
@@ -81,6 +173,7 @@ const noTrivialReturnType = {
 
       const annotation = fn.returnType.typeAnnotation;
       if (!TRIVIAL_TYPES.has(annotation.type)) return;
+      if (isSelfReferencing(fn)) return;
 
       const label = TRIVIAL_LABELS[annotation.type] ?? annotation.type;