@spinnaker/eslint-plugin 2026.2.2 → 2026.3.0

package/base.config.js

@@ -32,7 +32,6 @@ module.exports = [
         ...globals.browser,
         ...globals.node,
         ...globals.jasmine,
-        angular: true,
         $: true,
         _: true,
       },
@@ -54,14 +53,6 @@ module.exports = [
       '@spinnaker/import-from-npm-not-relative': 2,
       '@spinnaker/import-from-presentation-not-core': 2,
       '@spinnaker/import-relative-within-subpackage': 2,
-      '@spinnaker/migrate-to-mock-http-client': 2,
-      '@spinnaker/ng-no-component-class': 2,
-      '@spinnaker/ng-no-module-export': 2,
-      '@spinnaker/ng-no-require-angularjs': 2,
-      '@spinnaker/ng-no-require-module-deps': 2,
-      '@spinnaker/ng-strictdi': 'off',
-      '@spinnaker/prefer-promise-like': 1,
-      '@spinnaker/react2angular-with-error-boundary': 2,
       '@spinnaker/rest-prefer-static-strings-in-initializer': 2,
       indent: 'off',
       'member-ordering': 'off',

package/eslint-plugin.spec.ts

@@ -0,0 +1,34 @@
+import plugin from './eslint-plugin';
+
+describe('ESLint config contracts', () => {
+  test('provides flat and legacy base configs', () => {
+    const configs = plugin.configs as Record<string, unknown>;
+
+    expect(Array.isArray(configs.base)).toBe(true);
+    expect(Array.isArray(configs['legacy-base'])).toBe(false);
+    expect(configs['legacy-base']).toEqual(
+      expect.objectContaining({
+        plugins: expect.arrayContaining(['@spinnaker/eslint-plugin']),
+        rules: expect.objectContaining({
+          '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
+        }),
+      }),
+    );
+  });
+
+  test('omits the retired migration rule while preserving the generic API chaining rule', () => {
+    const configs = plugin.configs as Record<string, unknown>;
+    const flatRules = (configs.base as Array<{ rules?: Record<string, unknown> }>)
+      .map((config) => config.rules)
+      .filter((rules): rules is Record<string, unknown> => Boolean(rules));
+    const legacyRules = (configs['legacy-base'] as { rules: Record<string, unknown> }).rules;
+
+    expect(plugin.rules).not.toHaveProperty('migrate-to-mock-http-client');
+    expect(flatRules.some((rules) => '@spinnaker/migrate-to-mock-http-client' in rules)).toBe(false);
+    expect(legacyRules).not.toHaveProperty('@spinnaker/migrate-to-mock-http-client');
+
+    expect(plugin.rules).toHaveProperty('api-no-unused-chaining');
+    expect(flatRules.some((rules) => '@spinnaker/api-no-unused-chaining' in rules)).toBe(true);
+    expect(legacyRules).toHaveProperty('@spinnaker/api-no-unused-chaining', 2);
+  });
+});

package/eslint-plugin.ts

@@ -7,14 +7,6 @@ import importFromNpmNotRelative from './rules/import-from-npm-not-relative';
 import importFromPresentationNotCore from './rules/import-from-presentation-not-core';
 import importRelativeWithinSubpackage from './rules/import-relative-within-subpackage';
 import importSort from './rules/import-sort';
-import migrateToMockHttpClient from './rules/migrate-to-mock-http-client';
-import ngNoComponentClass from './rules/ng-no-component-class';
-import ngNoModuleExport from './rules/ng-no-module-export';
-import ngNoRequireAngularJS from './rules/ng-no-require-angularjs';
-import ngNoRequireModuleDeps from './rules/ng-no-require-module-deps';
-import ngStrictDI from './rules/ng-strictdi';
-import preferPromiseLike from './rules/prefer-promise-like';
-import react2angularWithErrorBoundary from './rules/react2angular-with-error-boundary';
 import restPreferStaticStringsInInitializer from './rules/rest-prefer-static-strings-in-initializer';
 
 const rules = {
@@ -27,14 +19,6 @@ const rules = {
   'import-from-presentation-not-core': importFromPresentationNotCore,
   'import-relative-within-subpackage': importRelativeWithinSubpackage,
   'import-sort': importSort,
-  'migrate-to-mock-http-client': migrateToMockHttpClient,
-  'ng-no-component-class': ngNoComponentClass,
-  'ng-no-module-export': ngNoModuleExport,
-  'ng-no-require-angularjs': ngNoRequireAngularJS,
-  'ng-no-require-module-deps': ngNoRequireModuleDeps,
-  'ng-strictdi': ngStrictDI,
-  'prefer-promise-like': preferPromiseLike,
-  'react2angular-with-error-boundary': react2angularWithErrorBoundary,
   'rest-prefer-static-strings-in-initializer': restPreferStaticStringsInInitializer,
 };
 
@@ -44,6 +28,7 @@ const plugin = {
   get configs() {
     return {
       base: require('./base.config.js'),
+      'legacy-base': require('./legacy.config.js'),
       none: require('./none.config.js'),
     };
   },

package/legacy.config.js

@@ -0,0 +1,72 @@
+module.exports = {
+  env: {
+    browser: true,
+    jasmine: true,
+    node: true,
+  },
+  extends: ['eslint:recommended', 'prettier', 'plugin:@typescript-eslint/recommended'],
+  globals: {
+    $: 'readonly',
+    _: 'readonly',
+  },
+  ignorePatterns: ['**/*.spec.*', 'template/**/*'],
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    sourceType: 'module',
+  },
+  plugins: ['@spinnaker/eslint-plugin', 'react-hooks'],
+  rules: {
+    '@spinnaker/api-deprecation': 2,
+    '@spinnaker/api-no-slashes': 2,
+    '@spinnaker/api-no-unused-chaining': 2,
+    '@spinnaker/import-from-alias-not-npm': 2,
+    '@spinnaker/import-from-npm-not-alias': 2,
+    '@spinnaker/import-from-npm-not-relative': 2,
+    '@spinnaker/import-from-presentation-not-core': 2,
+    '@spinnaker/import-relative-within-subpackage': 2,
+    '@spinnaker/import-sort': 1,
+    '@spinnaker/rest-prefer-static-strings-in-initializer': 2,
+    '@typescript-eslint/array-type': ['error', { default: 'array-simple' }],
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/consistent-type-imports': ['error', { prefer: 'type-imports' }],
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/indent': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/no-empty-interface': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/no-parameter-properties': 'off',
+    '@typescript-eslint/no-require-imports': 'off',
+    '@typescript-eslint/no-this-alias': 'off',
+    '@typescript-eslint/no-unused-expressions': 'off',
+    '@typescript-eslint/no-unused-vars': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/triple-slash-reference': 'off',
+    indent: 'off',
+    'no-console': ['error', { allow: ['warn', 'error'] }],
+    'no-extra-boolean-cast': 'off',
+    'no-prototype-builtins': 'off',
+    'one-var': ['error', { initialized: 'never' }],
+    'prefer-rest-params': 'off',
+    'prefer-spread': 'off',
+    'react-hooks/rules-of-hooks': 'error',
+    'require-atomic-updates': 'off',
+  },
+  overrides: [
+    {
+      files: ['**/*.js', '**/*.jsx'],
+      rules: {
+        '@typescript-eslint/no-use-before-define': 'off',
+      },
+    },
+    {
+      files: ['**/*.ts', '**/*.tsx'],
+      rules: {
+        'no-undef': 'off',
+      },
+    },
+  ],
+};

package/none.config.js

@@ -19,7 +19,6 @@ module.exports = [
         ...globals.browser,
         ...globals.node,
         ...globals.jasmine,
-        angular: true,
         $: true,
         _: true,
       },

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "https://github.com/spinnaker/spinnaker.git"
   },
-  "version": "2026.2.2",
+  "version": "2026.3.0",
   "main": "index.js",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -22,9 +22,10 @@
     "ts-node": "*"
   },
   "devDependencies": {
+    "@babel/preset-env": "^7.15.0",
     "@babel/preset-typescript": "^7.15.0",
     "@eslint/compat": "^2.0.3",
-    "@eslint/eslintrc": "^3.3.5",
+    "@eslint/eslintrc": "^3.3.6",
     "@eslint/js": "^9.39.2",
     "@types/eslint": "9.6.1",
     "@types/estree": "*",
@@ -57,10 +58,9 @@
   ],
   "jest": {
     "testPathIgnorePatterns": [
-      "<rootDir>/template",
-      "<rootDir>/rules/ng-strictdi.spec.ts"
+      "<rootDir>/template"
     ],
     "testEnvironment": "node"
   },
-  "gitHead": "db086c61529c9421e8c0c2d4a2b8eca88c675ac8"
+  "gitHead": "0f7d75f5d4b42c1675e2ecc69a53f8eb73090eb9"
 }

package/rules/api-no-unused-chaining.spec.ts

@@ -2,7 +2,7 @@ import rule from '../rules/api-no-unused-chaining';
 import ruleTester from '../utils/ruleTester';
 const errorMessage = (text) => `Unused API.xyz() method chaining no longer works. Re-assign the result of: ${text}`;
 
-ruleTester.run('api-no-slashes', rule, {
+ruleTester.run('api-no-unused-chaining', rule, {
   valid: [
     { code: `const fooBar = API.one('foo', 'bar');` },
     { code: `let fooBar = API.one('foo', 'bar'); fooBar = fooBar.useCache()` },
@@ -22,5 +22,9 @@ ruleTester.run('api-no-slashes', rule, {
       code: `var foo = API.one('foo/bad'); foo.withParams({});`,
       errors: [errorMessage(`foo.withParams({});`)],
     },
+    {
+      code: `var foo = API.one('foo/bad'); foo.data({});`,
+      errors: [errorMessage(`foo.data({});`)],
+    },
   ],
 });

package/rules/api-no-unused-chaining.ts

@@ -9,21 +9,10 @@ const isApiConfigCall = _.overSome([
   _.matches({ property: { type: 'Identifier', name: 'data' } }),
 ]);
 
-const falsePostitives = _.overSome([
-  _.matches({
-    property: { type: 'Identifier', name: 'data' },
-    object: { type: 'Identifier', name: '$element' },
-  }),
-]);
-
 const create = function (context) {
   return {
     ExpressionStatement(node) {
-      if (
-        node.expression.type === 'CallExpression' &&
-        isApiConfigCall(node.expression.callee) &&
-        !falsePostitives(node.expression.callee)
-      ) {
+      if (node.expression.type === 'CallExpression' && isApiConfigCall(node.expression.callee)) {
         const text = context.getSourceCode().getText(node);
         context.report({
           node,

package/rules/import-sort.spec.ts

@@ -5,7 +5,7 @@ ruleTester.run('import-sort', rule, {
   valid: [
     {
       code: `
-import angular from 'angular';
+import axios from 'axios';
 import 'jquery';
 import React, { useCallback, useState } from 'react';
 import * as Select from 'react-select';
@@ -29,11 +29,11 @@ import './styles.less';
     {
       code: `
 import React, {useState, useCallback} from 'react';
-import angular from 'angular';
+import axios from 'axios';
 import * as Select from 'react-select';
       `,
       output: `
-import angular from 'angular';
+import axios from 'axios';
 import React, { useCallback, useState } from 'react';
 import * as Select from 'react-select';
       `,
@@ -47,7 +47,7 @@ const {useState, useCallback} = React;
 
 import { Application } from 'core/application';
 import Bar from "./bar";
-import angular from 'angular';
+import axios from 'axios';
 // Some comment about react-select
 import * as Select from 'react-select';
 import {
@@ -62,7 +62,7 @@ import 'bootstrap.less';
       `,
       // For some strange reason eslint fixer writes additional newline characters
       output: `
-import angular from 'angular';
+import axios from 'axios';
 import 'jquery';
 import React from 'react';
 // Some comment about react-select

package/rules/import-sort.ts

@@ -142,9 +142,9 @@ const printImportDeclaration = (context, importDeclaration) => {
  * Returns a custom textual representation of import declarations which will be used to verify if they are already
  * sorted. For example
  *
- *   `import React, {useState, useCallback} from 'react';\nimport angular from 'angular';`
+ *   `import React, {useState, useCallback} from 'react';\nimport axios from 'axios';`
  *    will be written as
- *   `react: React, useState, useCallback\nangular: angular`
+ *   `react: React, useState, useCallback\naxios: axios`
  */
 const getText = (importDeclarations) => {
   return importDeclarations.reduce((output, importDeclaration) => {

package/test.eslintrc

@@ -1,20 +1,18 @@
 {
   parser: '@typescript-eslint/parser',
-  "rules": {
+  rules: {},
+  parserOptions: {
+    ecmaVersion: 8,
+    sourceType: 'module',
   },
-  "parserOptions": {
-    "ecmaVersion": 8,
-    "sourceType": "module"
+  env: {
+    browser: true,
+    node: true,
+    es6: true,
+    jasmine: true,
   },
-  "env": {
-    "browser": true,
-    "node": true,
-    "es6": true,
-    "jasmine": true,
+  globals: {
+    $: true,
+    _: true,
   },
-  "globals": {
-    "angular": true,
-    "$": true,
-    "_": true,
-  }
 }

package/utils/utils.spec.ts

@@ -0,0 +1,16 @@
+import type { Rule, Scope } from 'eslint';
+
+import { getVariableInScope } from './utils';
+
+describe('getVariableInScope', () => {
+  test('uses the legacy context scope API when SourceCode does not provide one', () => {
+    const variable = {} as Scope.Variable;
+    const context = ({
+      getScope: () => ({
+        references: [{ identifier: { name: 'value' }, resolved: variable }],
+      }),
+    } as unknown) as Rule.RuleContext;
+
+    expect(getVariableInScope(context, { name: 'value', type: 'Identifier' })).toBe(variable);
+  });
+});

package/utils/utils.ts

@@ -53,7 +53,9 @@ export function getVariableInScope(context: Rule.RuleContext, identifier: Identi
     return undefined;
   }
 
-  const { references } = context.sourceCode.getScope((identifier as unknown) as Rule.Node);
+  const { references } = context.sourceCode?.getScope
+    ? context.sourceCode.getScope((identifier as unknown) as Rule.Node)
+    : ((context as unknown) as { getScope: () => Pick<Scope.Scope, 'references'> }).getScope();
   const ref = references.find((r) => r.identifier.name === identifier.name);
   return ref ? ref.resolved : undefined;
 }

package/rules/migrate-to-mock-http-client.spec.ts

@@ -1,78 +0,0 @@
-import rule from './migrate-to-mock-http-client';
-import ruleTester from '../utils/ruleTester';
-
-ruleTester.run('migrate-to-mock-http-client', rule, {
-  valid: [
-    {
-      code: 'it(() => { const http = mockHttpClient(); })',
-    },
-  ],
-  invalid: [
-    {
-      code: `it('does things', () => { $httpBackend.flush() })`,
-      output: `it('does things', async () => { $httpBackend.flush() })`,
-      errors: ['Migrate to MockHttpClient (step 1): make test function async'],
-    },
-
-    // Step 1 make async
-    {
-      code: `
-describe('foo bar', () => {
-  it('does things', () => {
-    $httpBackend.flush()
-  })
-})`,
-      output: `
-describe('foo bar', () => {
-  it('does things', async () => {
-    $httpBackend.flush()
-  })
-})`,
-      errors: ['Migrate to MockHttpClient (step 1): make test function async'],
-    },
-
-    // Step 2 create mock
-    {
-      code: `
-describe('foo bar', () => {
-  it('does things', async () => {
-    $httpBackend.flush()
-  })
-})`,
-      output: `import { mockHttpClient } from 'core/api/mock/jasmine';
-
-describe('foo bar', () => {
-  it('does things', async () => {
-    const http = mockHttpClient();
-$httpBackend.flush()
-  })
-})`,
-      errors: ['Migrate to MockHttpClient (step 2): Create a MockHttpClient named "http"'],
-    },
-
-    // Step 3 change variables
-    {
-      code: `
-import { mockHttpClient } from 'core/api/mock/jasmine';
-describe('foo bar', () => {
-  it('does things', async () => {
-    const http = mockHttpClient();
-    $httpBackend.expectGET('/foo/bar').respond(200, { bar: 15 });
-    service.fetchBars();
-    $httpBackend.flush()
-  })
-})`,
-      output: `
-import { mockHttpClient } from 'core/api/mock/jasmine';
-describe('foo bar', () => {
-  it('does things', async () => {
-    const http = mockHttpClient();
-    http.expectGET('/foo/bar').respond(200, { bar: 15 });
-    service.fetchBars();
-    await http.flush()
-  })
-})`,
-      errors: ['Migrate to MockHttpClient (step 3): replace $httpBackend with http'],
-    },
-  ],
-});

package/rules/migrate-to-mock-http-client.ts

@@ -1,121 +0,0 @@
-import type { Rule } from 'eslint';
-
-import { getImportName } from '../utils/ast';
-import { getProgram } from '../utils/utils';
-
-const ruleModule: Rule.RuleModule = {
-  create(context) {
-    const text = (node) => context.getSourceCode().getText(node);
-
-    return {
-      CallExpression(_node: any) {
-        const node = _node;
-        /** it(() => {}) */
-        const isItBlock = node.callee.type === 'Identifier' && node.callee.name === 'it';
-
-        if (isItBlock) {
-          const itBlockText = text(node);
-          const testFunction = node.arguments[1] as any;
-
-          const doesFunctionIncludeHttpBackend = !!testFunction && itBlockText.includes('$httpBackend');
-
-          if (doesFunctionIncludeHttpBackend) {
-            const isFirstArgAFunction = ['FunctionExpression', 'ArrowFunctionExpression'].includes(testFunction.type);
-
-            if (isFirstArgAFunction) {
-              // Fix 1: make the test 'async'
-              if (testFunction.async !== true) {
-                return context.report({
-                  node,
-                  message: 'Migrate to MockHttpClient (step 1): make test function async',
-                  fix: (fixer) => fixer.insertTextBefore(testFunction, 'async '),
-                });
-              }
-
-              // Fix 2: Add a 'http' variable
-              if (
-                testFunction.body.type === 'BlockStatement' &&
-                !text(testFunction.body.body[0]).includes('mockHttpClient')
-              ) {
-                const program = getProgram(node);
-                const allImports = program.body.filter((item) => item.type === 'ImportDeclaration') as any[];
-
-                const importSpecifiers = allImports
-                  .map((decl) => decl.specifiers as any[])
-                  .reduce((acc, x) => acc.concat(x), []);
-
-                const mockHttpClientImport = importSpecifiers.find((specifier) => {
-                  return specifier.imported && getImportName(specifier.imported) === 'mockHttpClient';
-                });
-
-                return context.report({
-                  node,
-                  message: 'Migrate to MockHttpClient (step 2): Create a MockHttpClient named "http"',
-                  fix: (fixer) => {
-                    const insertHttp = fixer.insertTextBefore(
-                      testFunction.body.body[0],
-                      'const http = mockHttpClient();\n',
-                    );
-
-                    let insertImport = fixer.insertTextBeforeRange(
-                      [0, 0],
-                      `import { mockHttpClient } from 'core/api/mock/jasmine';\n`,
-                    );
-
-                    // Put after 'use strict'
-                    const sourcecode = text(program);
-                    const [preamble] = /^['"]use strict['"];?/.exec(sourcecode) || [];
-                    if (preamble) {
-                      const insertPos = preamble.length;
-                      insertImport = fixer.insertTextAfterRange(
-                        [insertPos, insertPos],
-                        `\nimport { mockHttpClient } from 'core/api/mock/jasmine';`,
-                      );
-                    }
-
-                    if (mockHttpClientImport) {
-                      return insertHttp;
-                    } else {
-                      return [insertHttp, insertImport];
-                    }
-                  },
-                });
-              }
-
-              // Fix 3:
-              // - replace "$httpBackend.when('GET'" with "$httpBackend.expectGET("
-              // - replace "$httpBackend.whenGET" with "$httpBackend.expectGET"
-              // - replace "$httpBackend" with "http"
-              return context.report({
-                node,
-                message: 'Migrate to MockHttpClient (step 3): replace $httpBackend with http',
-                fix: (fixer) => {
-                  const newItBlockText = itBlockText
-                    .replace(/(this\.)?\$httpBackend\.when(GET|POST|PUT|PATCH|DELETE)/g, '$httpBackend.expect$2')
-                    .replace(
-                      /(this\.)?\$httpBackend\.when\(['"](GET|POST|PUT|PATCH|DELETE)['"], /g,
-                      '$httpBackend.expect$2(',
-                    )
-                    .replace(/(this\.)?\$httpBackend/g, 'http')
-                    .replace(/http.flush/g, 'await http.flush')
-                    .replace(/await await /g, 'await ');
-
-                  return fixer.replaceText(node, newItBlockText);
-                },
-              });
-            }
-          }
-        }
-      },
-    };
-  },
-  meta: {
-    fixable: 'code',
-    type: 'problem',
-    docs: {
-      description: 'Do not import API',
-    },
-  },
-};
-
-export default ruleModule;

package/rules/ng-no-component-class.spec.ts

@@ -1,45 +0,0 @@
-import rule from './ng-no-component-class';
-import ruleTester from '../utils/ruleTester';
-
-ruleTester.run('ng-no-component-class', rule, {
-  valid: [
-    {
-      code: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .component('componentName', componentObject);
-
-        const componentObject = {
-          controller: function() {},
-          template: 'a template'
-        }
-      `,
-    },
-  ],
-
-  invalid: [
-    {
-      errors: [{ message: 'Use .component("foo", {}) instead of .component("foo", new FooComponentClass())' }],
-      code: `
-        import angular from 'angular';
-        angular.module('foo', [])
-          .component('componentName', new ComponentClass());
-
-        class ComponentClass {
-          controller = function() {};
-          template = 'a template';
-        }
-      `,
-      output: `
-        import angular from 'angular';
-        angular.module('foo', [])
-          .component('componentName', componentClass);
-
-        const componentClass = {
-  controller: function() {},
-  template: 'a template'
-};
-      `,
-    },
-  ],
-});