@spinnaker/eslint-plugin 2026.2.2 → 2026.3.0

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

@@ -1,67 +0,0 @@
-import type { Rule, Scope } from 'eslint';
-import camelCase from 'lodash/camelCase';
-
-const findParentNodeByType = (node: Rule.Node, type: string) =>
-  !node ? null : node.type === type ? node : findParentNodeByType(node.parent, type);
-
-/**
- * Use object literal when declaring AngularJS components
- * Do not use new ComponentClass()
- *
- * @version 0.1.0
- * @category conventions
- */
-import angularRule from '../utils/angular-rule/angular-rule';
-
-const useObjectLiteral = function (context: Rule.RuleContext) {
-  return {
-    'angular?component': function (callee, thisGuy) {
-      const node: Rule.Node = thisGuy.node;
-      const scope: Scope.Scope = thisGuy.scope;
-      if (node.type === 'NewExpression') {
-        const calleeName = 'name' in node.callee ? node.callee.name : undefined;
-        const fix = (fixer: Rule.RuleFixer) => {
-          const variable = scope.variables.find((x) => x.name === calleeName);
-          const classDef = variable.defs[0].node;
-          const name = classDef.id.name;
-          const camelCaseName = camelCase(name);
-          const rename = name !== camelCaseName;
-
-          const objProperties = classDef.body.body.map((node) => {
-            return node.key.name + ': ' + context.getSourceCode().getText(node.value);
-          });
-
-          const impls = (classDef.implements || []).map((impl) => context.getSourceCode().getText(impl));
-          const identifier = `const ${camelCaseName}${impls.length ? `: ${impls.join(' & ')}` : ''}`;
-          const objectLiteral = `${identifier} = {\n` + `  ${objProperties.join(',\n  ')}\n` + `};`;
-
-          const otherReferences = findParentNodeByType(classDef, 'Program').tokens.filter((token) => {
-            const ignores = [classDef.id.range[0], node.callee.range[0]];
-            return (
-              token.type === 'Identifier' && token.value === name && ignores.every((pos) => pos !== token.range[0])
-            );
-          });
-
-          const otherFixes = rename ? [] : otherReferences.map((id) => fixer.replaceText(id, camelCaseName));
-
-          return [fixer.replaceText(classDef, objectLiteral), fixer.replaceText(node, camelCaseName), ...otherFixes];
-        };
-
-        const message = 'Use .component("foo", {}) instead of .component("foo", new FooComponentClass())';
-        context.report({ fix, node, message });
-      }
-    },
-  };
-};
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    fixable: 'code',
-    docs: {
-      description: 'Prefer .component("foo", {}) over .component("foo", new FooComponentClass())',
-    },
-  },
-  create: angularRule(useObjectLiteral),
-};
-export default ruleModule;

package/rules/ng-no-module-export.spec.ts

@@ -1,26 +0,0 @@
-import rule from './ng-no-module-export';
-import ruleTester from '../utils/ruleTester';
-
-ruleTester.run('ng-no-module-export', rule, {
-  valid: [
-    {
-      code: `
-        const angular = require('angular');
-        export const MODULE_NAME = 'foo';
-        angular.module(MODULE_NAME, [])
-          .component('componentName', {});
-      `,
-    },
-  ],
-
-  invalid: [
-    {
-      errors: [{ message: 'Prefer exporting the AngularJS module name instead of the entire module' }],
-      code: `
-        const angular = require('angular');
-        module.exports = angular.module('foo', [])
-          .component('componentName', {});
-      `,
-    },
-  ],
-});

package/rules/ng-no-module-export.ts

@@ -1,117 +0,0 @@
-/**
- * Prefer exporting a module's NAME instead of the entire angular.module()
- */
-
-import type { AST, Rule } from 'eslint';
-import { isCallExpression, isIdentifier, isMemberExpression } from '../utils/utils';
-
-const rule = function (context: Rule.RuleContext) {
-  function getSuggestedVariableNameForFile() {
-    const filename = context.getFilename();
-    if (filename.includes('/packages/')) {
-      return filename
-        .replace(/^.*\/packages\//g, '')
-        .replace(/\/src\//g, '/')
-        .replace(/\.[\w]*$/g, '')
-        .replace(/[^\w_]/g, '_')
-        .toUpperCase();
-    }
-  }
-
-  return {
-    AssignmentExpression: function (_node: any) {
-      const node = _node;
-      const left = node.left;
-      const right = node.right;
-      const isModuleExports = isModuleExportMemberExpression(left);
-      const moduleNameNode = getAngularModuleNameNode(right);
-      if (isModuleExports && moduleNameNode) {
-        const message = 'Prefer exporting the AngularJS module name instead of the entire module';
-        const variableName = getSuggestedVariableNameForFile();
-
-        const fix = (fixer: Rule.RuleFixer) => {
-          const assignmentRange = [left?.range[0], right?.range[0]] as AST.Range;
-          const exportModuleVariable = `export const ${variableName} = ${moduleNameNode.raw};\n`;
-          const exportNameVariable = `export const name = ${variableName}; // for backwards compatibility\n`;
-          return [
-            // Insert 'export const FOO = 'foo';
-            fixer.insertTextBefore(node, exportModuleVariable + exportNameVariable),
-            // Remove 'module.exports = '
-            fixer.replaceTextRange(assignmentRange, ''),
-            // Replace 'angular.module("foo"' with 'angular.module(FOO'
-            fixer.replaceText(moduleNameNode, variableName),
-          ];
-        };
-
-        if (variableName) {
-          context.report({ node, message, fix });
-        } else {
-          context.report({ node, message });
-        }
-      }
-    },
-  };
-};
-
-function isModuleExportMemberExpression(node) {
-  const object = node.object;
-  const property = node.property;
-  const isModuleExports = node.type === 'MemberExpression' && object.name === 'module' && property.name === 'exports';
-  const isBareExports = node.type === 'Identifier' && node.name === 'exports';
-  return isModuleExports || isBareExports;
-}
-
-function getAngularModuleNameNode(node) {
-  if (!isCallExpression(node)) return false;
-  const callee = node.callee as Rule.Node;
-
-  function angularModuleNameNode(callExpression: any) {
-    const isLiteral =
-      callExpression.arguments && callExpression.arguments[0] && callExpression.arguments[0].type === 'Literal';
-    return isLiteral ? callExpression.arguments[0] : undefined;
-  }
-
-  function isChainedCallExpression(_callee: any): boolean {
-    if (isMemberExpression(_callee)) {
-      return _callee.object && _callee.object.type === 'CallExpression';
-    }
-  }
-
-  function isAngularModuleCall(_callee) {
-    if (isMemberExpression(_callee)) {
-      return (
-        _callee.object &&
-        _callee.object.type === 'Identifier' &&
-        _callee.object.name === 'angular' &&
-        _callee.property &&
-        'name' in _callee.property &&
-        _callee.property.name === 'module'
-      );
-    }
-  }
-
-  function isRawModuleCall(_callee) {
-    return isIdentifier(_callee) && _callee.name === 'module';
-  }
-
-  if (isChainedCallExpression(callee)) {
-    return getAngularModuleNameNode((callee as any).object);
-  } else if (isRawModuleCall(callee)) {
-    if (node.arguments && node.arguments[0] && node.arguments[0].type === 'Literal') return angularModuleNameNode(node);
-  } else if (isAngularModuleCall(callee)) {
-    return angularModuleNameNode(node);
-  }
-}
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Instead of exporting the angular.module(), export the modules string identifier',
-    },
-    fixable: 'code',
-  },
-  create: rule,
-};
-
-export default ruleModule;

package/rules/ng-no-require-angularjs.spec.ts

@@ -1,27 +0,0 @@
-import rule from './ng-no-require-angularjs';
-import ruleTester from '../utils/ruleTester';
-
-ruleTester.run('ng-no-require-angularjs', rule, {
-  valid: [
-    {
-      code: `
-        import { module } from 'angular';
-        module('foo', []);
-      `,
-    },
-  ],
-
-  invalid: [
-    {
-      errors: [{ message: "Prefer module('foo', []) to angular.module('foo', [])" }],
-      code: `
-        import angular from 'angular';
-        angular.module('foo', []);
-      `,
-      output: `
-        import { module } from 'angular';
-        module('foo', []);
-      `,
-    },
-  ],
-});

package/rules/ng-no-require-angularjs.ts

@@ -1,92 +0,0 @@
-/**
- * Prefer:
- * import { module } from 'angular';
- * module('mymodule', [])
- *
- * over:
- * import * as angular from 'angular';
- * angular.module('mymodule', [])
- */
-import type { Rule, Scope } from 'eslint';
-import { getProgram, isMemberExpression } from '../utils/utils';
-
-const rule = function (context: Rule.RuleContext) {
-  return {
-    'MemberExpression[object.name="angular"][property.name="module"]': function (_node: any) {
-      const node = _node;
-      const angularVar = findAngularVariable(node, context);
-      const angularImport = findAngularImportStatement(node);
-      // Double check that there is only a single use of 'angular' variable and that it's 'angular.module()')
-      if (angularImport && angularVar && angularVar.references.length === 1) {
-        const { parent } = angularVar.references[0].identifier as any;
-        if (isMemberExpression(parent)) {
-          if (
-            'name' in parent.object &&
-            parent.object.name === 'angular' &&
-            'name' in parent.property &&
-            parent.property.name === 'module'
-          ) {
-            const message = "Prefer module('foo', []) to angular.module('foo', [])";
-            const fix = getFixForAngularModule(node, angularImport);
-            return context.report({ node, message, fix });
-          }
-        }
-      }
-    },
-  };
-};
-
-function findAngularVariable(_node, context): Scope.Variable {
-  const program = getProgram(_node);
-
-  const programScope = context.getSourceCode().scopeManager.acquire(program);
-  const moduleScope = programScope && programScope.childScopes.find((s) => s.type === 'module');
-  return moduleScope && moduleScope.variables.find((v) => v.name === 'angular');
-}
-
-function findAngularImportStatement(_node): any {
-  let program = _node;
-  while (program && program.parent) {
-    program = program.parent;
-  }
-
-  return program.body.find((node) => {
-    return (
-      node.type === 'ImportDeclaration' &&
-      node.source &&
-      node.source.type === 'Literal' &&
-      node.source.value === 'angular'
-    );
-  });
-}
-
-/*
-Given:
-angular.module('module', ['dep']);
-
-Rewrites to:
-import { module } from 'angular';
-
-module('module', ['dep']);
- */
-function getFixForAngularModule(angularDotModuleNode: Rule.Node, importStatement: any) {
-  return function (fixer: Rule.RuleFixer) {
-    return [
-      fixer.replaceText(angularDotModuleNode, 'module'),
-      fixer.replaceText(importStatement, `import { module } from 'angular';`),
-    ];
-  };
-}
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: `Prefer import { module } from 'angular' over angular.module()`,
-    },
-    fixable: 'code',
-  },
-  create: rule,
-};
-
-export default ruleModule;

package/rules/ng-no-require-module-deps.spec.ts

@@ -1,33 +0,0 @@
-import rule from './ng-no-require-module-deps';
-import ruleTester from '../utils/ruleTester';
-
-ruleTester.run('ng-no-require-module-deps', rule, {
-  valid: [
-    {
-      code: `
-        import { module } from 'angular';
-        import FOO_MODULE from './foo';
-        module('foo', [FOO_MODULE]);
-      `,
-    },
-  ],
-
-  invalid: [
-    {
-      errors: [
-        {
-          message: 'Prefer \'import ANGULARJS_LIBRARY from "angularjs-library"\' over \'require("angularjs-library")\'',
-        },
-      ],
-      code: `
-        import angular from 'angular';
-        angular.module('foo', [ require('./foo') ]);
-      `,
-      output: `
-        import angular from 'angular';
-import __FOO from './foo';
-        angular.module('foo', [ __FOO ]);
-      `,
-    },
-  ],
-});

package/rules/ng-no-require-module-deps.ts

@@ -1,211 +0,0 @@
-import type { Rule } from 'eslint';
-import fs from 'fs';
-import path from 'path';
-
-/**
- * Prefer exporting a module's NAME instead of the entire angular.module()
- *
- * @version 0.1.0
- * @category conventions
- * @sinceAngularVersion 1.x
- */
-const rule = function (context: Rule.RuleContext) {
-  return {
-    ArrayExpression: function (_node: any) {
-      const node = _node;
-      if (isInAngularModuleCall(node)) {
-        const requireDotNames = node.elements.map((element) => getRequireDotNameNode(element)).filter((x) => !!x);
-        requireDotNames.forEach(([_node, relativePath]) => {
-          const message = `Prefer 'import { ANGULARJS_MODULE } from "./module"' over 'require("./module").name'`;
-          const fix = getFixForRequireDotName(_node, context.getFilename(), relativePath);
-          context.report({ node: _node, message, fix });
-        });
-
-        const requireDotAnythings = node.elements
-          .map((element) => getRequireDotAnythingNode(element))
-          .filter((x) => !!x);
-        requireDotAnythings.forEach(([_node, requiredString, propertyName]) => {
-          const message = `Prefer 'import { default as ANGULARJS_MODULE } from "./module"' over 'require("./module").default'`;
-          const fix = getFixForRequireDotAnything(_node, requiredString, propertyName);
-          context.report({ node: _node, message, fix });
-        });
-
-        const bareRequires = node.elements.map((element) => getBareRequireNode(element)).filter((x) => !!x);
-        bareRequires.forEach(([_node, requiredString]) => {
-          const message = `Prefer 'import ANGULARJS_LIBRARY from "angularjs-library"' over 'require("angularjs-library")'`;
-          const fix = getFixForBareRequire(_node, requiredString);
-          context.report({ node: _node, message, fix });
-        });
-      }
-    },
-  };
-};
-
-/*
-Given:
-angular.module('module', [
-  require('angular-ui-bootstrap')
-]);
-
-Rewrites to:
-import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
-
-angular.module('module', [
-  ANGULAR_UI_BOOTSTRAP
-]);
- */
-function getFixForBareRequire(node: any, requiredString: string) {
-  return function (fixer: Rule.RuleFixer) {
-    const variableName = requiredString.replace(/[^\w_]/g, '_').toUpperCase();
-    const lastImport = findLastImportStatement(node);
-    const importStatement = `\nimport ${variableName} from '${requiredString}';`;
-    if (lastImport) {
-      return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
-    } else {
-      return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
-    }
-  };
-}
-
-/*
-Given:
-angular.module('module', [
-  require('some/require/string').default
-]);
-
-Rewrites to:
-import { default as SOME_REQUIRE_STRING } from 'some/require/string';
-
-angular.module('module', [
-  SOME_REQUIRE_STRING
-]);
- */
-function getFixForRequireDotAnything(node: any, requiredString: string, property: string) {
-  return function (fixer: Rule.RuleFixer) {
-    const variableName = requiredString
-      .replace(/^[^\w_]*/g, '')
-      .replace(/[^\w_]/g, '_')
-      .toUpperCase();
-    const lastImport = findLastImportStatement(node);
-    const importStatement = `\nimport { ${property} as ${variableName} } from '${requiredString}';`;
-    if (lastImport) {
-      return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
-    } else {
-      return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
-    }
-  };
-}
-
-/*
-Given:
-angular.module('module', [
-  require('./path/to/dependency').name
-]);
-
-Rewrites to:
-import { DEPENDENCY_SYMBOL } from './path/to/dependency';
-
-angular.module('module', [
-  DEPENDENCY_SYMBOL
-]);
- */
-function getFixForRequireDotName(node: any, filename: string, relativePath: string) {
-  const modulesPath = filename.replace(/modules\/.*/, 'modules/');
-
-  const path1 = path.resolve(filename, '..', relativePath);
-  const path2 = path.resolve(modulesPath, relativePath.replace(/^([a-zA-Z]+)\//, '$1/src/'));
-  const path3 = path.resolve(modulesPath, relativePath);
-
-  for (const path of [path1, path2, path3]) {
-    for (const extension of ['.ts', '.js']) {
-      if (fs.existsSync(path + extension)) {
-        const fileSource = fs.readFileSync(path + extension).toString();
-        const match = /export const name = ([\w_]*);/.exec(fileSource);
-        if (match) {
-          const variableName = match[1];
-          return function (fixer) {
-            const lastImport = findLastImportStatement(node);
-            const importStatement = `\nimport { ${variableName} } from '${relativePath}';`;
-            if (lastImport) {
-              return [fixer.replaceText(node, variableName), fixer.insertTextAfter(lastImport, importStatement)];
-            } else {
-              return [fixer.replaceText(node, variableName), fixer.insertTextBeforeRange([0, 0], importStatement)];
-            }
-          };
-        }
-      }
-    }
-  }
-}
-
-function findLastImportStatement(_node: any) {
-  let program = _node as Rule.Node;
-  while (program && program.parent) {
-    program = program.parent;
-  }
-
-  if (program && program.type === 'Program') {
-    const imports = program.body.filter((node) => node.type === 'ImportDeclaration');
-    if (imports.length) {
-      return imports[imports.length - 1];
-    }
-  }
-}
-
-// require('./some/nested/angularjs/module').name
-function getRequireDotNameNode(node: any): [any, string] {
-  if (node.type !== 'MemberExpression') return undefined;
-  if (node.property.type !== 'Identifier' || node.property.name !== 'name') return undefined;
-  if (node.object.type !== 'CallExpression' || (node.object.callee as any).name !== 'require') return undefined;
-  if (node.object.arguments.length !== 1 || node.object.arguments[0].type !== 'Literal') return undefined;
-
-  // [node, './some/nested/angularjs/module']
-  return [node, node.object.arguments[0].value as string];
-}
-
-// require('something').anything
-function getRequireDotAnythingNode(node: any): [any, string, string] {
-  if (node.type !== 'MemberExpression') return undefined;
-  if (node.property.type !== 'Identifier') return undefined;
-  if (node.object.type !== 'CallExpression' || (node.object.callee as any).name !== 'require') return undefined;
-  if (node.object.arguments.length !== 1 || node.object.arguments[0].type !== 'Literal') return undefined;
-
-  // [node, 'something', 'anything']
-  return [node, node.object.arguments[0].value as string, node.property.name];
-}
-
-// require('something')
-function getBareRequireNode(node): [any, string] {
-  if (node.type !== 'CallExpression' || node.callee.name !== 'require') return undefined;
-  if (node.arguments.length !== 1 || node.arguments[0].type !== 'Literal') return undefined;
-
-  // [node, 'something']
-  return [node, node.arguments[0].value as string];
-}
-
-function isInAngularModuleCall(arrayExpression) {
-  const { parent = {} } = arrayExpression;
-  if (parent.type === 'CallExpression') {
-    const { callee = {} } = parent;
-    const { type, object, property } = callee;
-    const isAngularModule =
-      type === 'MemberExpression' && object && object.name === 'angular' && property && property.name === 'module';
-    const isRawModule = type === 'Identifier' && callee.name === 'module';
-
-    return isAngularModule || isRawModule;
-  }
-  return false;
-}
-
-const ruleModule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Import an angular module name symbol instead of using require("../foo").name',
-    },
-    fixable: 'code',
-  },
-  create: rule,
-};
-
-export default ruleModule;

package/rules/ng-strictdi.spec.ts

@@ -1,100 +0,0 @@
-import rule from './ng-strictdi';
-import ruleTester from '../utils/ruleTester';
-ruleTester.run('ng-strictdi', rule, {
-  valid: [
-    {
-      code: `
-        import { module } from 'angular';
-        module('foo', [])
-          .directive('myDirective', ['$scope', function($scope) {}]);
-      `,
-    },
-    {
-      code: `
-        import { module } from 'angular';
-        class Controller {
-          static $inject = ['$scope'];
-          constructor($scope) {
-          }
-        }
-        module('foo', [])
-          .directive('myDirective', ['$scope', function($scope) {}]);
-      `,
-    },
-    {
-      code: `
-        import { module } from 'angular';
-        module('foo', [])
-          .directive('myDirective', ['$scope', function($scope) {}]);
-      `,
-    },
-  ],
-
-  invalid: [
-    {
-      errors: [{ message: 'The injected function has 1 parameter(s): ["$scope"], but no annotation was found' }],
-      code: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .controller('myController', function($scope) {});
-      `,
-      output: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .controller('myController', ['$scope', function($scope) {}]);
-      `,
-    },
-    {
-      errors: [
-        { message: 'The injected function \'MyClass\' has 1 parameter(s): ["$scope"], but no annotation was found' },
-      ],
-      code: `
-        import { module } from 'angular';
-        // Do not rename this to MyClassController or the checkDi rule will fire twice
-        class MyClass {
-          constructor($scope) {
-          }
-        }
-        module('foo', []).controller('myClassController', MyClass);
-      `,
-      output: `
-        import { module } from 'angular';
-        // Do not rename this to MyClassController or the checkDi rule will fire twice
-        class MyClass {
-          constructor($scope) {
-          }
-        }
-MyClass.$inject = ['$scope'];
-        module('foo', []).controller('myClassController', MyClass);
-      `,
-    },
-    {
-      errors: [{ message: 'The injected function has 1 parameter(s): ["$scope"], but no annotation was found' }],
-      code: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .directive('myDirective', { controller: function namedFunction($scope) {} });
-      `,
-      output: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .directive('myDirective', { controller: ['$scope', function namedFunction($scope) {}] });
-      `,
-    },
-    {
-      errors: [
-        { message: 'The injected function has 2 parameter(s): ["$scope","$location"], but no annotation was found' },
-      ],
-      code: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .directive('myDirective', { controller: function ($scope, $location) {} });
-      `,
-      output: `
-        const angular = require('angular');
-        angular.module('foo', [])
-          .directive('myDirective', { controller: ['$scope', '$location', function ($scope, $location) {}] });
-      `,
-    },
-  ],
-});