@hs-web-team/eslint-config-node 4.2.2 → 5.1.0

package/package.json

@@ -1,7 +1,22 @@
 {
   "name": "@hs-web-team/eslint-config-node",
-  "version": "4.2.2",
+  "version": "5.1.0",
   "description": "HubSpot Marketing WebTeam shared configurations for ESLint, Prettier, Stylelint, and Cypress",
+  "files": [
+    ".prettierrc.json",
+    ".stylelintrc.json",
+    "base-rules.js",
+    "bin/",
+    "browser.js",
+    "cypress.config.cjs",
+    "cypress.config.d.ts",
+    "cypress/",
+    "docs/",
+    "examples/",
+    "gherkin/",
+    "index.js",
+    "plugins/"
+  ],
   "main": "index.js",
   "type": "module",
   "exports": {
@@ -17,7 +32,10 @@
     "./cypress": {
       "types": "./cypress/index.d.ts",
       "default": "./cypress/index.js"
-    }
+    },
+    "./plugin": "./plugins/hs-web-team/index.js",
+    "./gherkin/.gplintrc": "./gherkin/.gplintrc",
+    "./gherkin/coverage-config": "./gherkin/coverage-config.js"
   },
   "typesVersions": {
     "*": {
@@ -31,15 +49,17 @@
   },
   "scripts": {
     "postinstall": "node bin/check-peer-deps.cjs",
-    "lint": "npx eslint -c ./index.js *.js --fix",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "npx eslint . --fix",
+    "test": "node --test",
+    "playground:build": "node playground/build.js",
     "prepare": "git rev-parse --git-dir > /dev/null 2>&1 && git config core.hooksPath .githooks || true"
   },
   "engines": {
     "node": ">=24"
   },
   "bin": {
-    "add-prettier": "bin/add-prettier-scripts.js"
+    "add-prettier": "bin/add-prettier-scripts.js",
+    "gherkin-tag-coverage": "bin/gherkin-tag-coverage.js"
   },
   "repository": {
     "type": "git",
@@ -60,29 +80,34 @@
   },
   "homepage": "https://github.com/HubSpotWebTeam/wt-eslint-node#readme",
   "dependencies": {
-    "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
-    "@eslint/eslintrc": "^3.3.5",
+    "@bahmutov/cypress-esbuild-preprocessor": "2.2.8",
+    "@cucumber/gherkin": "38.0.0",
+    "@cucumber/messages": "32.3.1",
+    "@eslint/eslintrc": "3.3.6",
     "@eslint/js": "^9.39.1",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.3",
-    "axe-core": "^4.11.4",
-    "cypress-axe": "^1.7.0",
-    "esbuild": "^0.28.0",
-    "eslint": "^9.39.4",
-    "eslint-formatter-checkstyle": "^9.0.1",
-    "eslint-plugin-jsx-a11y": "^6.10.2",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^7.1.1",
-    "globals": "^17.6.0",
-    "jiti": "^2.7.0",
-    "js-yaml": "^4.1.1",
-    "prettier": "^3.8.3",
+    "@eslint/markdown": "8.0.3",
+    "@typescript-eslint/eslint-plugin": "^8.65.0",
+    "@typescript-eslint/parser": "^8.65.0",
+    "axe-core": "4.13.0",
+    "cypress-axe": "1.7.0",
+    "esbuild": "0.28.2",
+    "eslint": "9.39.5",
+    "eslint-formatter-checkstyle": "9.0.1",
+    "eslint-plugin-jsx-a11y": "6.10.2",
+    "eslint-plugin-react": "7.37.5",
+    "eslint-plugin-react-hooks": "7.1.1",
+    "globals": "17.11.0",
+    "gplint": "2.6.0",
+    "jiti": "2.7.0",
+    "js-yaml": "5.4.0",
+    "prettier": "3.9.6",
     "prettier-plugin-gherkin": "4.0.0",
-    "typescript-eslint": "^8.60.0"
+    "strip-json-comments": "5.0.3",
+    "typescript-eslint": "8.68.0"
   },
   "peerDependencies": {
-    "@badeball/cypress-cucumber-preprocessor": "^24.0.1",
-    "cypress": "^15.16.0",
+    "@badeball/cypress-cucumber-preprocessor": "24.0.1",
+    "cypress": "15.21.0",
     "stylelint": "^17.1.1",
     "stylelint-config-standard": "^40.0.0",
     "stylelint-config-standard-scss": "^17.0.0",
@@ -104,5 +129,10 @@
     "cypress": {
       "optional": true
     }
+  },
+  "devDependencies": {
+    "stylelint": "17.15.0",
+    "stylelint-config-standard-scss": "17.0.0",
+    "stylelint-declaration-strict-value": "1.12.1"
   }
 }

package/plugins/claude-code/index.js

@@ -0,0 +1,50 @@
+import markdown from '@eslint/markdown';
+import maxLines from './rules/max-lines.js';
+
+// First-party ESLint plugin holding lint rules for Claude Code context files:
+// `CLAUDE.md` project-context files and the `SKILL.md` files under
+// `.claude/skills/`. Rules are referenced as `claude-code/<rule>` wherever the
+// plugin is registered.
+export const claudeCodePlugin = {
+  meta: { name: 'claude-code' },
+  rules: {
+    'max-lines': maxLines,
+  },
+};
+
+// Self-reference via `configs.recommended`, following the same pattern as
+// hsWebTeamPlugin (and typescript-eslint / eslint-plugin-react). It carries the
+// flat-config blocks that scope the rules to the right files. Severity is `warn`
+// so it never blocks; consumers can bump a rule to `error` or turn it `off`.
+//
+// `@eslint/markdown` supplies the `markdown/gfm` language — without it ESLint
+// would try to parse these files as JavaScript and error.
+//
+// Skills carry more detail than a `CLAUDE.md`, so `SKILL.md` gets a higher
+// (500-line) guideline than `CLAUDE.md` (100 lines), with tailored advice.
+claudeCodePlugin.configs = {
+  recommended: [
+    {
+      files: ['**/CLAUDE.md'],
+      language: 'markdown/gfm',
+      plugins: { markdown, 'claude-code': claudeCodePlugin },
+      rules: {
+        'claude-code/max-lines': [
+          'warn',
+          { max: 100, advice: 'Trim it or split sections into files Claude Code can import on demand.' },
+        ],
+      },
+    },
+    {
+      files: ['**/.claude/skills/**/SKILL.md'],
+      language: 'markdown/gfm',
+      plugins: { markdown, 'claude-code': claudeCodePlugin },
+      rules: {
+        'claude-code/max-lines': [
+          'warn',
+          { max: 500, advice: 'Trim it or move detail into reference files the skill loads on demand.' },
+        ],
+      },
+    },
+  ],
+};

package/plugins/claude-code/rules/max-lines.js

@@ -0,0 +1,52 @@
+const DEFAULT_MAX = 100;
+const DEFAULT_ADVICE = 'Trim it or split sections into files Claude Code can import on demand.';
+
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Warn when a doc file exceeds a maximum number of lines',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          max: { type: 'integer', minimum: 1 },
+          advice: { type: 'string' },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      tooManyLines: '{{file}} has {{count}} lines, over the {{max}}-line guideline. {{advice}}',
+    },
+  },
+  create(context) {
+    const { max = DEFAULT_MAX, advice = DEFAULT_ADVICE } = context.options[0] || {};
+    const { sourceCode } = context;
+    // Report against the file's basename so the message names the offending
+    // file (e.g. CLAUDE.md or SKILL.md) regardless of its directory.
+    const file = (context.filename || '').split('/').pop() || 'File';
+
+    return {
+      root() {
+        const { lines } = sourceCode;
+        // `lines` splits on line breaks; a trailing newline yields a final
+        // empty entry that should not count as a content line.
+        const count = lines.length > 0 && lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
+
+        if (count > max) {
+          context.report({
+            loc: {
+              start: { line: max + 1, column: 0 },
+              end: { line: lines.length, column: lines[lines.length - 1].length },
+            },
+            messageId: 'tooManyLines',
+            data: { file, count, max, advice },
+          });
+        }
+      },
+    };
+  },
+};

package/plugins/hs-web-team/index.js

@@ -0,0 +1,24 @@
+import { noAbbreviations } from './rules/no-abbreviations.js';
+import { noNonLiteralConstantCase } from './rules/no-non-literal-constant-case.js';
+import { noReduceAccumulatorCopy } from './rules/no-reduce-accumulator-copy.js';
+
+export const hsWebTeamPlugin = {
+  rules: {
+    'no-abbreviations': noAbbreviations,
+    'no-non-literal-constant-case': noNonLiteralConstantCase,
+    'no-reduce-accumulator-copy': noReduceAccumulatorCopy,
+  },
+};
+
+// Self-reference allows the plugin to register itself via configs.recommended,
+// following the same pattern as typescript-eslint and eslint-plugin-react.
+hsWebTeamPlugin.configs = {
+  recommended: {
+    plugins: { 'hs-web-team': hsWebTeamPlugin },
+    rules: {
+      'hs-web-team/no-abbreviations': 'warn',
+      'hs-web-team/no-non-literal-constant-case': 'warn',
+      'hs-web-team/no-reduce-accumulator-copy': 'error',
+    },
+  },
+};

package/plugins/hs-web-team/rules/no-abbreviations.js

@@ -0,0 +1,135 @@
+const DEFAULT_EXCEPTIONS = new Set(['e', '_']);
+const DEFAULT_MIN_LENGTH = 2;
+
+const SORT_METHODS = new Set(['sort', 'toSorted']);
+const ARRAY_ITERATION_METHODS = new Set([
+  'map',
+  'flatMap',
+  'forEach',
+  'filter',
+  'find',
+  'findIndex',
+  'findLast',
+  'findLastIndex',
+  'some',
+  'every',
+  // reduce/reduceRight are intentionally excluded: their callback signature is
+  // (accumulator, currentValue, currentIndex, …), so position 1 is the current
+  // *value*, not the index. The i-at-position-1 heuristic does not apply.
+]);
+
+/**
+ * Returns true if the VariableDeclarator is in the init of a for/for...of/for...in statement.
+ * Walks the parent chain directly — no scope API needed.
+ *
+ * @param {import('eslint').Rule.Node} declaratorNode - VariableDeclarator node
+ */
+function isDeclaredInForLoopInit(declaratorNode) {
+  const declaration = declaratorNode.parent; // VariableDeclaration
+  const enclosing = declaration?.parent;
+  if (!enclosing) return false;
+  return (
+    (enclosing.type === 'ForStatement' && enclosing.init === declaration) ||
+    enclosing.type === 'ForInStatement' ||
+    enclosing.type === 'ForOfStatement'
+  );
+}
+
+/**
+ * Returns true if funcNode is a direct inline callback to a method whose name is in methodNames.
+ * Only matches non-computed method calls (arr.sort(...), not arr['sort'](...)).
+ *
+ * @param {import('eslint').Rule.Node} funcNode - ArrowFunctionExpression or FunctionExpression
+ * @param {Set<string>} methodNames
+ */
+function isCallbackToMethod(funcNode, methodNames) {
+  const callExpr = funcNode.parent;
+  if (callExpr?.type !== 'CallExpression') return false;
+  if (!callExpr.arguments.includes(funcNode)) return false;
+  const { callee } = callExpr;
+  return (
+    callee?.type === 'MemberExpression' &&
+    !callee.computed &&
+    methodNames.has(callee.property.name)
+  );
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+export const noAbbreviations = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow abbreviated identifier names (e.g. `w` instead of `warnings`)',
+      url: 'https://docs.hubwt.com/docs/developers/coding-on-the-web-team/coding-standards/javascript-standards/#avoid-abbreviation',
+      recommended: true,
+    },
+    messages: {
+      tooShort:
+        'Identifier "{{name}}" is too short ({{length}} < {{min}}). Use a descriptive name.',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          exceptions: { type: 'array', items: { type: 'string' }, uniqueItems: true },
+          minLength: { type: 'integer', minimum: 1 },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] ?? {};
+    const exceptions = new Set([...DEFAULT_EXCEPTIONS, ...(options.exceptions ?? [])]);
+    const minLength = options.minLength ?? DEFAULT_MIN_LENGTH;
+
+    return {
+      Identifier(node) {
+        const { name, parent } = node;
+
+        if (name.length >= minLength) return;
+        if (exceptions.has(name)) return;
+
+        // Only flag declaration sites — not usage sites.
+        //
+        // Object destructuring shorthand (const { w } = response) is intentionally
+        // excluded: `w` may be an external API property name the developer doesn't
+        // control. The idiomatic fix — const { w: warning } = response — is correct
+        // but non-obvious enough to leave as opt-in. Array destructuring IS included
+        // because the element binding name is always chosen by the developer.
+        const isDeclaration =
+          (parent.type === 'VariableDeclarator' && parent.id === node) ||
+          (parent.type === 'ArrayPattern' && parent.elements.includes(node)) ||
+          (parent.type === 'FunctionDeclaration' && parent.id === node) ||
+          (parent.type === 'FunctionDeclaration' && parent.params.includes(node)) ||
+          (parent.type === 'ArrowFunctionExpression' && parent.params.includes(node)) ||
+          (parent.type === 'FunctionExpression' && parent.params.includes(node));
+
+        if (!isDeclaration) return;
+
+        // For-loop variables (i, j, k…) are exempt regardless of length.
+        if (parent.type === 'VariableDeclarator' && isDeclaredInForLoopInit(parent)) return;
+
+        // a and b are conventional sort-comparator names — exempt only inside .sort()/.toSorted().
+        if ((name === 'a' || name === 'b') && isCallbackToMethod(parent, SORT_METHODS)) return;
+
+        // i is a conventional index name — exempt only when it is the index param (position 1)
+        // of an array iteration callback: items.map((item, i) => ...).
+        // Position 1 is the index slot for every array iteration method except reduce/reduceRight
+        // (where it's position 2), but naming the reduce index `i` is uncommon enough to skip.
+        if (
+          name === 'i' &&
+          parent.params?.indexOf(node) === 1 &&
+          isCallbackToMethod(parent, ARRAY_ITERATION_METHODS)
+        ) return;
+
+        context.report({
+          node,
+          messageId: 'tooShort',
+          data: { name, length: name.length, min: minLength },
+        });
+      },
+    };
+  },
+};

package/plugins/hs-web-team/rules/no-non-literal-constant-case.js

@@ -0,0 +1,137 @@
+const CONSTANT_CASE_REGEX = /^[A-Z][A-Z0-9_]*$/;
+
+// TS wrapper nodes carry no runtime meaning for "is this value static" —
+// unwrap them before inspecting the underlying expression.
+const TS_WRAPPER_TYPES = new Set([
+  'TSAsExpression',
+  'TSSatisfiesExpression',
+  'TSNonNullExpression',
+  'TSTypeAssertion',
+]);
+
+function unwrap(node) {
+  let current = node;
+  while (current && TS_WRAPPER_TYPES.has(current.type)) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function isProcessEnvAccess(node) {
+  return (
+    node.type === 'MemberExpression' &&
+    node.object.type === 'MemberExpression' &&
+    node.object.object.type === 'Identifier' &&
+    node.object.object.name === 'process' &&
+    node.object.property.type === 'Identifier' &&
+    node.object.property.name === 'env'
+  );
+}
+
+function isObjectFreezeCall(node) {
+  return (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'MemberExpression' &&
+    !node.callee.computed &&
+    node.callee.object.type === 'Identifier' &&
+    node.callee.object.name === 'Object' &&
+    node.callee.property.type === 'Identifier' &&
+    node.callee.property.name === 'freeze' &&
+    node.arguments.length === 1
+  );
+}
+
+// Set/Map and friends are the idiomatic "frozen collection" for lookup tables
+// (e.g. `new Set(['a', 'b'])`) — treated as static when every constructor arg is.
+const STATIC_COLLECTION_CONSTRUCTORS = new Set(['Set', 'Map', 'WeakSet', 'WeakMap', 'RegExp']);
+
+function isStaticCollectionConstructor(node) {
+  return (
+    node.type === 'NewExpression' &&
+    node.callee.type === 'Identifier' &&
+    STATIC_COLLECTION_CONSTRUCTORS.has(node.callee.name)
+  );
+}
+
+function isStaticElement(node) {
+  return isStaticExpression(node.type === 'SpreadElement' ? node.argument : node);
+}
+
+function isStaticExpression(rawNode) {
+  const node = unwrap(rawNode);
+  if (!node) return true;
+
+  switch (node.type) {
+    case 'Literal':
+      return true;
+    case 'TemplateLiteral':
+      return node.expressions.length === 0;
+    case 'UnaryExpression':
+      return isStaticExpression(node.argument);
+    case 'ArrayExpression':
+      return node.elements.every((element) => element === null || isStaticElement(element));
+    case 'ObjectExpression':
+      return node.properties.every((prop) =>
+        prop.type === 'SpreadElement'
+          ? isStaticExpression(prop.argument)
+          : isStaticExpression(prop.value),
+      );
+    case 'CallExpression':
+      return isObjectFreezeCall(node) && isStaticExpression(node.arguments[0]);
+    case 'NewExpression':
+      return isStaticCollectionConstructor(node) && node.arguments.every(isStaticElement);
+    case 'Identifier':
+      // A reference to another CONSTANT_CASE-named binding is treated as static.
+      // This is a syntactic check, not a scope resolution: if that binding's own
+      // initializer isn't actually static, this same rule flags it at its declaration.
+      return CONSTANT_CASE_REGEX.test(node.name);
+    case 'MemberExpression':
+      return isProcessEnvAccess(node);
+    default:
+      return false;
+  }
+}
+
+export const noNonLiteralConstantCase = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow CONSTANT_CASE variable names whose value is not a literal/static constant',
+      recommended: true,
+    },
+    messages: {
+      nonLiteralInit:
+        'CONSTANT_CASE name "{{name}}" implies a static constant, but its value is computed ({{ nodeType }}). Rename to camelCase, or replace the value with a literal constant.',
+      reassignableBinding:
+        'CONSTANT_CASE name "{{name}}" implies a static constant, but it is declared with "{{kind}}" and can be reassigned. Use "const", or rename to camelCase.',
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== 'Identifier') return;
+        if (!node.init) return;
+
+        const { name } = node.id;
+        if (!CONSTANT_CASE_REGEX.test(name)) return;
+
+        const { kind } = node.parent;
+        if (kind !== 'const') {
+          context.report({ node: node.id, messageId: 'reassignableBinding', data: { name, kind } });
+          return;
+        }
+
+        if (isStaticExpression(node.init)) return;
+
+        context.report({
+          node: node.id,
+          messageId: 'nonLiteralInit',
+          data: { name, nodeType: unwrap(node.init).type },
+        });
+      },
+    };
+  },
+};

package/plugins/hs-web-team/rules/no-reduce-accumulator-copy.js

@@ -0,0 +1,90 @@
+const RECOMMENDATION =
+  'Prefer a for...of loop with in-place mutation, or a purpose-built method (flatMap, Object.groupBy, flat) if it fits your pattern.';
+
+function isReduceCall(node) {
+  if (!node) return false;
+
+  const callee = node.callee;
+  if (!callee || !callee.property || !callee.property.name) {
+    return false;
+  }
+
+  return (
+    callee.property.name === 'reduce' || callee.property.name === 'reduceRight'
+  );
+}
+
+function isReduceAccumulator(def) {
+  return (
+    def &&
+    def.type === 'Parameter' &&
+    def.node.parent &&
+    isReduceCall(def.node.parent) &&
+    def.node.params &&
+    def.node.params.length &&
+    // def.name is the Identifier AST node for the definition; this identity
+    // check confirms it is the first parameter (the accumulator), not a later one.
+    def.name === def.node.params[0]
+  );
+}
+
+export const noReduceAccumulatorCopy = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow O(n²) accumulator copies (spread, concat) inside reduce/reduceRight callbacks',
+      recommended: true,
+    },
+    messages: {
+      AccumulatorSpread: `Spreading the reduce accumulator is O(n²). ${RECOMMENDATION}`,
+      AccumulatorShallowCopy: `Calling .{{ method }}() on the reduce accumulator is O(n²). ${RECOMMENDATION}`,
+    },
+    schema: [],
+  },
+
+  create(context) {
+    const { sourceCode } = context;
+
+    function checkIsAccumulatorSpread(node) {
+      if (!node.argument || node.argument.type !== 'Identifier') return;
+
+      const scope = sourceCode.getScope(node);
+      const spreadee = scope.set.get(node.argument.name);
+      const spreadeeDef =
+        spreadee && spreadee.defs && spreadee.defs.length && spreadee.defs[0];
+
+      if (isReduceAccumulator(spreadeeDef)) {
+        context.report({ node, messageId: 'AccumulatorSpread' });
+      }
+    }
+
+    function checkIsAccumulatorShallowCopy(node) {
+      if (
+        node.callee.type !== 'MemberExpression' ||
+        !node.callee.property ||
+        !node.callee.object ||
+        node.callee.object.type !== 'Identifier'
+      ) {
+        return;
+      }
+
+      const method = node.callee.property.name;
+      if (method !== 'concat') return;
+
+      const scope = sourceCode.getScope(node);
+      const variable = scope.set.get(node.callee.object.name);
+      const definition =
+        variable && variable.defs && variable.defs.length && variable.defs[0];
+
+      if (isReduceAccumulator(definition)) {
+        context.report({ node, messageId: 'AccumulatorShallowCopy', data: { method } });
+      }
+    }
+
+    return {
+      SpreadElement: checkIsAccumulatorSpread,
+      CallExpression: checkIsAccumulatorShallowCopy,
+    };
+  },
+};

package/.githooks/commit-msg

@@ -1,28 +0,0 @@
-#!/bin/sh
-
-commit_msg=$(head -1 "$1")
-
-# Skip merge and revert commits (auto-generated messages)
-case "$commit_msg" in
-  Merge\ *|Revert\ *) exit 0 ;;
-esac
-
-pattern="^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\([a-zA-Z0-9_/-]+\))?!?: .+"
-
-if ! echo "$commit_msg" | grep -qE "$pattern"; then
-  echo ""
-  echo "ERROR: Commit message does not follow Conventional Commits format."
-  echo ""
-  echo "  Expected:  type(optional-scope): description"
-  echo "  Types:     feat | fix | docs | style | refactor | test | chore | ci | perf | revert | build"
-  echo ""
-  echo "  Examples:"
-  echo "    feat: add new rule for import order"
-  echo "    fix: correct comma-dangle config for browser"
-  echo "    feat!: drop support for Node 18  (breaking change -> major bump)"
-  echo "    feat(browser): add React 19 support"
-  echo ""
-  echo "  See: https://www.conventionalcommits.org"
-  echo ""
-  exit 1
-fi

package/.github/CODEOWNERS

@@ -1 +0,0 @@
-* @HubSpotWebTeam/webteamdevs

package/.github/workflows/main.yml

@@ -1,24 +0,0 @@
-name: Merge to Main
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  build:
-    # The type of runner that the job will run on
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node: [24]
-
-    name: Node ${{ matrix.node }} lint
-    steps:
-      - uses: actions/checkout@v6
-      - name: Run unit tests
-        uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node }}
-      - run: npm install
-      - run: npm run lint