@spinnaker/eslint-plugin 2026.2.3 → 2026.3.0

package/rules/ng-strictdi.ts

@@ -1,304 +0,0 @@
-/**
- * require a consistent DI syntax
- *
- * All your DI should use the same syntax : the Array, function, or $inject syntaxes ("di":  [2, "array, function, or $inject"])
- *
- * @version 0.1.0
- * @category conventions
- * @sinceAngularVersion 1.x
- */
-import type { Rule } from 'eslint';
-import { isEqual } from 'lodash';
-
-import angularRule from '../utils/angular-rule/angular-rule';
-import utils from '../utils/angular-rule/utils';
-
-const stripUnderscores = true;
-
-function normalizeParameter(param) {
-  return stripUnderscores ? param : param.replace(/^_(.+)_$/, (match, p1) => p1);
-}
-
-const rule = function (context: Rule.RuleContext) {
-  const $injectProperties = {};
-
-  function maybeNoteInjection(node) {
-    if (
-      node.left &&
-      node.left.property &&
-      ((utils.isLiteralType(node.left.property) && node.left.property.value === '$inject') ||
-        (utils.isIdentifierType(node.left.property) && node.left.property.name === '$inject'))
-    ) {
-      $injectProperties[node.left.object.name] = node.right;
-    }
-  }
-
-  function getDiStrings(name: string) {
-    const $inject = $injectProperties[name];
-    const elements = $inject && ($inject.elements || $inject.expression.elements);
-    return elements && elements.map((el) => el.value);
-  }
-
-  function compareParamsAndDI(node, name, type, context, params, diStrings) {
-    const paramNames = params.map((p) => normalizeParameter(p));
-    const diCount = diStrings ? diStrings.length : 0;
-    const paramCount = paramNames.length;
-
-    if (diCount === 0 && diCount !== paramCount) {
-      const message =
-        `The injected function${name ? ` '${name}'` : ''} ` +
-        `has ${paramCount} parameter(s): ${JSON.stringify(paramNames)}, ` +
-        `but no annotation was found`;
-
-      const injectStrings = params.map((p) => `'${p}'`).join(', ');
-
-      const fix = (fixer) => {
-        if (name && type === 'tsclass') {
-          return fixer.insertTextBefore(node, `public static $inject = [${injectStrings}];\n  `);
-        } else if (name && type === 'class') {
-          // find class node
-          let classNode = node;
-          while (classNode.type !== 'ClassDeclaration' && classNode.parent) {
-            classNode = classNode.parent;
-          }
-          return fixer.insertTextAfter(classNode, `\n${name}.$inject = [${injectStrings}];`);
-        } else if (name) {
-          return fixer.insertTextAfter(node, `\n${name}.$inject = [${injectStrings}];`);
-        } else {
-          return [fixer.insertTextBefore(node, `[${injectStrings}, `), fixer.insertTextAfter(node, `]`)];
-        }
-      };
-
-      // let program = node;
-      // while(program.parent) {program = program.parent}
-      // console.log(context.getSourceCode().getText(program));
-
-      context.report({ node, message, fix });
-    } else if (diCount !== paramCount) {
-      const message =
-        `The injected function${name ? ` '${name}'` : ''} ` +
-        `has ${paramCount} parameter(s): ${JSON.stringify(paramNames)}, ` +
-        `but there were ${diCount} DI strings${diCount === 0 ? '' : `: ${JSON.stringify(diStrings)} `}`;
-      context.report({ node, message });
-    } else if (!isEqual(diStrings, paramNames)) {
-      const message =
-        `The injected function${name ? ` '${name}'` : ''} ` +
-        `parameter names: ${JSON.stringify(paramNames)} ` +
-        `do not match the DI strings: ${JSON.stringify(diStrings)}`;
-      context.report({ node, message });
-    }
-  }
-
-  function fromArray(thisGuy) {
-    const { node, scope, callExpression } = thisGuy;
-    const args = node.elements.slice(0, -1);
-    const fn = node.elements.slice(-1)[0];
-    const diStrings = args.map((node) => node.value);
-
-    if (fn.type === 'Identifier') {
-      const name = fn.name;
-      const result = fromIdentifier({ node: fn, scope, callExpression });
-      const params = result.fn.params && result.fn.params.map((param) => param.name);
-      return { type: 'array', fn: result.fn, name, params, diStrings };
-    }
-
-    const params = fn.params && fn.params.map((param) => param.name);
-    return { type: 'array', fn, name: undefined, params, diStrings };
-  }
-
-  function fromIdentifier(thisGuy) {
-    const { node, scope } = thisGuy;
-    const reference = scope.references.find((r) => r.identifier.name === node.name);
-    const resolved = reference && reference.resolved;
-    if (resolved) {
-      const { defs, scope: resolvedScope } = resolved;
-      return processThisGuy({ node: defs[0].node, scope: resolvedScope });
-    }
-  }
-
-  function fromVariableDeclarator(thisGuy) {
-    const { node, scope } = thisGuy;
-    const { name } = node.id;
-    const fn = node.init;
-
-    const variable = scope.variables.find((v) => v.name === name);
-
-    if (!variable) {
-      throw new Error(`Weird, I couldn't find variable '${name}' in scope?`);
-    }
-
-    if (variable.defs.length > 1) {
-      throw new Error('It is pretty unexpected to find more than one def in this guys variable?');
-    }
-
-    const params = fn.params.map((param) => param.name);
-    const diStrings = getDiStrings(name);
-
-    // TODO: is this really function?
-    return { type: 'function', fn, name, params, diStrings };
-  }
-
-  function fromClassDeclaration(thisGuy) {
-    const { node } = thisGuy;
-    const { name } = node.id;
-    const ctor = node.body.body.find((node) => node.type === 'MethodDefinition' && node.kind === 'constructor');
-    if (!ctor) return null;
-    const isTypescript = !!context.getFilename().match(/\.tsx?$/);
-    const params = ctor.value.params.map((param) =>
-      param.type === 'TSParameterProperty' ? param.parameter.name : param.name,
-    );
-    const $inject = node.body.body.find(
-      (node) => node.type === 'ClassProperty' && node.static && node.key.name === '$inject',
-    );
-    const diStrings = $inject ? $inject.value.elements.map((el) => el.value) : getDiStrings(name);
-    return { type: isTypescript ? 'tsclass' : 'class', fn: ctor, name, params, diStrings };
-  }
-
-  function fromFunction(thisGuy) {
-    const { node: fn } = thisGuy;
-    const name = fn.type === 'FunctionDeclaration' ? fn.id.name : fn.name;
-    const params = fn.params.map((param) => param.name);
-    const diStrings = getDiStrings(name);
-    return { type: 'function', fn, name, params, diStrings };
-  }
-
-  function processThisGuy(thisGuy) {
-    if (!thisGuy || !thisGuy.node) {
-      throw new Error('processThisGuy: Unexpected null argument');
-    }
-
-    switch (thisGuy.node.type) {
-      case 'ArrayExpression':
-        return fromArray(thisGuy);
-      case 'ArrowFunctionExpression':
-      case 'FunctionExpression':
-      case 'FunctionDeclaration':
-        return fromFunction(thisGuy);
-      case 'Identifier':
-        return fromIdentifier(thisGuy);
-      case 'VariableDeclarator':
-        return fromVariableDeclarator(thisGuy);
-      case 'ClassDeclaration':
-        return fromClassDeclaration(thisGuy);
-      case 'MemberExpression': {
-        const memberExpression = context.getSourceCode().getText(thisGuy.node);
-        // allowlist some known symbols
-        if (!['angular.noop', 'noop'].includes(memberExpression)) {
-          console.warn(`Unable to handle MemberExpression: ${memberExpression}`);
-        }
-        return null;
-      }
-      case 'ImportSpecifier': {
-        // const importSpecifier = context.getSourceCode().getText(thisGuy.node);
-        // console.warn(`warn: Unable to handle ImportSpecifier: ${importSpecifier} in ${context.getFilename()}`);
-        return null;
-      }
-      default:
-        console.error(context.getSourceCode().getText(thisGuy.node));
-        throw new Error(`Unknown type: ${thisGuy.node.type}`);
-    }
-  }
-
-  function checkDi(callee, thisGuy) {
-    if (!thisGuy) {
-      throw new Error('checkDi: unexpected null argument');
-    } else if (!thisGuy.node) {
-      throw new Error('checkDi: missing node in thisGuy');
-    }
-
-    let result;
-    try {
-      result = processThisGuy(thisGuy);
-    } catch (error) {
-      console.error(`Internal error while processing ${context.getFilename()}`);
-      console.error(context.getSourceCode().getText(thisGuy.callExpression));
-      throw error;
-    }
-    if (!result) return;
-    const { type, fn, name, params, diStrings } = result;
-
-    // If there's an array, validate it
-    if (type === 'array') {
-      const expectedTypes = ['ArrowFunctionExpression', 'FunctionExpression', 'FunctionDeclaration'];
-      if (!expectedTypes.includes(fn.type)) {
-        const message = `Array-style: The last element should be an injected function, but it was: ${fn.type}`;
-        return context.report({ node: fn, message });
-      }
-
-      if (!diStrings.every((str) => typeof str === 'string')) {
-        return context.report({ node: fn, message: `Array-style: Elements [0..n-2] should all be strings` });
-      }
-    }
-
-    if (params.length) {
-      compareParamsAndDI(fn, name, type, context, params, diStrings);
-    }
-  }
-
-  return {
-    'angular?animation': checkDi,
-    'angular?config': checkDi,
-    'angular?controller': checkDi,
-    'angular?component': function (callee, thisGuy) {
-      if (thisGuy.node.type === 'ObjectExpression') {
-        const property = thisGuy.node.properties.find((prop) => prop.key.name === 'controller');
-        if (property) {
-          if (property.value.type !== 'Literal') {
-            return checkDi(callee, Object.assign({}, thisGuy, { node: property.value }));
-          }
-        }
-      }
-    },
-    'angular?decorator': checkDi,
-    'angular?directive': function (callee, thisGuy) {
-      if (thisGuy.node.type === 'ObjectExpression') {
-        const property = thisGuy.node.properties.find((prop) => prop.key.name === 'controller');
-        if (property) {
-          if (property.value.type !== 'Literal') {
-            return checkDi(callee, Object.assign({}, thisGuy, { node: property.value }));
-          }
-        }
-      }
-    },
-    'angular?factory': checkDi,
-    'angular?filter': checkDi,
-    'angular?inject': checkDi,
-    'angular?run': checkDi,
-    'angular?service': checkDi,
-    'angular?provider': function (callee, providerFn, $get) {
-      checkDi(null, providerFn);
-      checkDi(null, $get);
-    },
-    'CallExpression:exit': function (node) {
-      const { object, property } = node.callee;
-      if (object && object.name === '$provide' && property && property.name === 'decorator') {
-        checkDi(null, { node: node.arguments[1], scope: context.sourceCode.getScope(node) });
-      }
-    },
-    AssignmentExpression: function (node) {
-      maybeNoteInjection(node);
-    },
-    ClassDeclaration: function (node) {
-      const interfaces = ['IController', 'ng.IController'];
-      const implementsIController = (node.implements || []).some((impl) => interfaces.includes(impl.expression.name));
-      const isNamedSortaLikeOne = node.id.name.match(/(Ctrl|Controller)$/);
-      const isClassController = implementsIController || isNamedSortaLikeOne;
-
-      if (isClassController) {
-        checkDi(null, { node: node });
-      }
-    },
-  };
-};
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'All angularjs functions must be explicitly annotated',
-    },
-    fixable: 'code',
-  },
-  create: angularRule(rule),
-};
-export default ruleModule;

package/rules/prefer-promise-like.spec.ts

@@ -1,75 +0,0 @@
-import rule from './prefer-promise-like';
-import ruleTester from '../utils/ruleTester';
-const errorMessage = `Prefer using PromiseLike type instead of AngularJS IPromise.`;
-const unusedImportErrorMessage = `Unused IPromise import`;
-
-ruleTester.run('prefer-promise-like', rule, {
-  valid: [
-    {
-      code: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
-    },
-  ],
-
-  invalid: [
-    // IPromise in variable
-    {
-      code: `const foo: IPromise<any> = API.one('foo', 'bar').get();`,
-      output: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
-      errors: [errorMessage],
-    },
-    // IPromise in function arg
-    {
-      code: `function foo(promise: IPromise<any>) {}`,
-      output: `function foo(promise: PromiseLike<any>) {}`,
-      errors: [errorMessage],
-    },
-    // IPromise in class method return
-    {
-      code: `class Foo { foo(): IPromise<any> {} }`,
-      output: `class Foo { foo(): PromiseLike<any> {} }`,
-      errors: [errorMessage],
-    },
-    // ng.IPromise in variable
-    {
-      code: `const foo: ng.IPromise<any> = API.one('foo', 'bar').get();`,
-      output: `const foo: PromiseLike<any> = API.one('foo', 'bar').get();`,
-      errors: [errorMessage],
-    },
-    // ng.IPromise in function arg
-    {
-      code: `function foo(promise: ng.IPromise<any>) {}`,
-      output: `function foo(promise: PromiseLike<any>) {}`,
-      errors: [errorMessage],
-    },
-    // ng.IPromise in class method return
-    {
-      code: `class Foo { foo(): ng.IPromise<any> {} }`,
-      output: `class Foo { foo(): PromiseLike<any> {} }`,
-      errors: [errorMessage],
-    },
-    // Unused IPromise import
-    {
-      code: `import { IPromise } from 'angular';`,
-      output: ``,
-      errors: [unusedImportErrorMessage],
-    },
-    // Unused IPromise import 2
-    {
-      code: `import { module, IPromise } from 'angular';`,
-      output: `import { module } from 'angular';`,
-      errors: [unusedImportErrorMessage],
-    },
-    // Unused IPromise import 3
-    {
-      code: `import { IPromise, module } from 'angular';`,
-      output: `import { module } from 'angular';`,
-      errors: [unusedImportErrorMessage],
-    },
-    // Unused IPromise import 4
-    {
-      code: `import { QService, IPromise, module } from 'angular';`,
-      output: `import { QService, module } from 'angular';`,
-      errors: [unusedImportErrorMessage],
-    },
-  ],
-});

package/rules/prefer-promise-like.ts

@@ -1,108 +0,0 @@
-import type { TSESTree } from '@typescript-eslint/types';
-import type { Rule } from 'eslint';
-import _ from 'lodash';
-
-/**
- * No slashes in string literals passed to API.one() / API.all()
- *
- * @version 0.1.0
- * @category
- */
-const rule = function (context: Rule.RuleContext) {
-  return {
-    TSTypeReference: function (_node) {
-      const node = _node as TSESTree.TSTypeReference;
-      // var foo: IPromise<any> = bar()
-      //          ^^^^^^^^
-      const type_IPromise = {
-        type: 'TSTypeReference',
-        typeName: {
-          type: 'Identifier',
-          name: 'IPromise',
-        },
-      };
-
-      // var foo: ng.IPromise<any> = bar()
-      //          ^^^^^^^^^^^
-      const type_ng_IPromise = {
-        type: 'TSTypeReference',
-        typeName: {
-          type: 'TSQualifiedName',
-          left: {
-            type: 'Identifier',
-            name: 'ng',
-          },
-          right: {
-            type: 'Identifier',
-            name: 'IPromise',
-          },
-        },
-      };
-
-      const message = `Prefer using PromiseLike type instead of AngularJS IPromise.`;
-      const fix = (fixer) => fixer.replaceText(node.typeName, 'PromiseLike');
-      if (_.isMatch(node, type_IPromise)) {
-        context.report({ fix, node: node.typeName as Rule.Node, message });
-      } else if (_.isMatch(node, type_ng_IPromise)) {
-        context.report({ fix, node: node.typeName as Rule.Node, message });
-      }
-    },
-
-    // If there are any unused IPromise imports, remove them
-    ImportDeclaration: function (_node: any) {
-      const node = _node;
-      const importIPromise = {
-        type: 'ImportSpecifier',
-        imported: {
-          type: 'Identifier',
-          name: 'IPromise',
-        },
-      };
-
-      const message = `Unused IPromise import`;
-
-      // import { foo, IPromise, bar } from 'angular';
-      //               ^^^^^^^^
-      const specifiers = node.specifiers || [];
-      const foundIPromiseImport = specifiers.find((s) => _.isMatch(s, importIPromise));
-
-      const variables = context.sourceCode.getScope(node).variables;
-      const variable = variables.find((x) => x.defs.some((def) => def.node === foundIPromiseImport));
-      const unused = variable && variable.references.length === 0;
-
-      const fix = (fixer: Rule.RuleFixer) => {
-        const importCount = node.specifiers.length;
-        if (importCount === 1) {
-          // Delete the whole import
-          return fixer.replaceText(node, '');
-        } else {
-          // Delete only IPromise from the import
-          const source = context
-            .getSourceCode()
-            .getText(node)
-            .replace(/,\s*IPromise/g, '')
-            .replace(/IPromise\s*,\s*/g, '');
-
-          return fixer.replaceText(node, source);
-        }
-      };
-
-      if (foundIPromiseImport && unused) {
-        context.report({ node, message, fix });
-      }
-    },
-  };
-};
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: ``,
-    },
-    fixable: 'code',
-  },
-  create: rule,
-};
-
-export default ruleModule;

package/rules/react2angular-with-error-boundary.spec.ts

@@ -1,29 +0,0 @@
-import rule from './react2angular-with-error-boundary';
-import ruleTester from '../utils/ruleTester';
-const errorMessage = `Wrap react2angular components in an error boundary using 'withErrorBoundary()'`;
-
-ruleTester.run('api-no-slashes', rule, {
-  valid: [
-    {
-      code: `react2angular(withErrorBoundary(MyComponent), ['foo', 'bar']);`,
-    },
-  ],
-
-  invalid: [
-    {
-      code: `react2angular(MyComponent, ['foo', 'bar']);`,
-      errors: [errorMessage],
-      output: `import { withErrorBoundary } from '@spinnaker/core';\nreact2angular(withErrorBoundary(MyComponent, 'react2angular component'), ['foo', 'bar']);`,
-    },
-
-    {
-      errors: [errorMessage],
-      code: `import { SpinnakerContainer } from '@spinnaker/core';
-module(SPINNAKER_CONTAINER_COMPONENT, []).component('spinnakerContainer',
-react2angular(SpinnakerContainer, ['authenticating', 'routing']));`,
-      output: `import { SpinnakerContainer, withErrorBoundary } from '@spinnaker/core';
-module(SPINNAKER_CONTAINER_COMPONENT, []).component('spinnakerContainer',
-react2angular(withErrorBoundary(SpinnakerContainer, 'spinnakerContainer'), ['authenticating', 'routing']));`,
-    },
-  ],
-});

package/rules/react2angular-with-error-boundary.ts

@@ -1,119 +0,0 @@
-import type { Rule } from 'eslint';
-import _ from 'lodash';
-import { isLiteral } from '../utils/utils';
-
-/**
- * react2angular: Always wrap react components in an error boundary
- * Uses withErrorBoundary from core/presentation
- * @version 0.1.0
- */
-const rule = function (context: Rule.RuleContext) {
-  let coreImport: any;
-
-  return {
-    // Find an import from @spinnaker/core or core/presentation
-    // This will be used to add the import for withErrorBoundary
-    ImportDeclaration: function (_node: any) {
-      const node = _node;
-      // import { foo, bar } from 'package';
-      //                           ^^^^^^^
-      const from = node.source.value || '';
-      if (from === '@spinnaker/core') {
-        coreImport = node;
-      }
-    },
-    CallExpression: function (_node: any) {
-      const node = _node;
-      // Find:
-      // react2angular(SomeComponent, ...)
-      const match = {
-        type: 'CallExpression',
-        callee: {
-          type: 'Identifier',
-          name: 'react2angular',
-        },
-      };
-
-      if (!_.isMatch(node, match)) {
-        return;
-      }
-
-      const r2aComponent = node.arguments[0];
-
-      const wrappedInErrorBoundaryMatch = {
-        type: 'CallExpression',
-        callee: {
-          type: 'Identifier',
-          name: 'withErrorBoundary',
-        },
-      };
-
-      // The react2angular component is already wrapped, nice!
-      if (_.isMatch(r2aComponent, wrappedInErrorBoundaryMatch)) {
-        return;
-      }
-
-      const message = `Wrap react2angular components in an error boundary using 'withErrorBoundary()'`;
-      const filename = context.getFilename();
-      const originalComponentSrc = context.getSourceCode().getText(r2aComponent);
-
-      // Try to determine the angularjs component name
-      // Look for component('angularComponentName', react2angular(ReactComponent, ....))
-      //                    ^^^^^^^^^^^^^^^^^^^^^^
-
-      const parentMatch = {
-        type: 'CallExpression',
-        callee: {
-          property: {
-            type: 'Identifier',
-            name: 'component',
-          },
-        },
-      };
-      const isComponentCallExpression = (node): node is any => _.isMatch(node, parentMatch);
-
-      let componentName = `'react2angular component'`;
-      const parentNode = node.parent;
-      if (isComponentCallExpression(parentNode)) {
-        const [componentNameLiteralNode, arg2] = parentNode.arguments || [];
-        if (arg2 === node && isLiteral(componentNameLiteralNode)) {
-          componentName = componentNameLiteralNode.raw;
-        }
-      }
-
-      const fix = (fixer: Rule.RuleFixer) => {
-        const wrapped = `withErrorBoundary(${originalComponentSrc}, ${componentName})`;
-        const insertErrorBoundary = fixer.replaceText(r2aComponent, wrapped);
-
-        const fixes = [insertErrorBoundary];
-
-        if (coreImport && coreImport.specifiers.length > 0) {
-          // Append to the existing core/presentation or @spinnaker/core import
-          const lastImport = coreImport.specifiers[coreImport.specifiers.length - 1];
-          fixes.push(fixer.insertTextAfter(lastImport, `, withErrorBoundary`));
-        } else {
-          const importString = filename.includes('/modules/core/')
-            ? 'core/presentation/SpinErrorBoundary'
-            : '@spinnaker/core';
-          fixes.push(fixer.insertTextBeforeRange([0, 0], `import { withErrorBoundary } from '${importString}';\n`));
-        }
-        return fixes;
-      };
-
-      context.report({ message, node, fix });
-    },
-  };
-};
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: `react2angular: Always wrap react components in an error boundary`,
-    },
-    fixable: 'code',
-  },
-  create: rule,
-};
-
-export default ruleModule;