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

package/.stylelintrc.json

@@ -21,9 +21,9 @@
     ],
     "scss/dollar-variable-pattern": null,
     "selector-class-pattern": [
-      "^-?[a-z0-9]([a-z0-9]|-(?!-))*$",
+      "^(?:-?[a-z0-9](?:[a-z0-9]|-(?!-))*|[a-z0-9]+(?:-[a-z0-9]+)*(?:__[a-z0-9]+(?:-[a-z0-9]+)*)?(?:--[a-z0-9]+(?:-[a-z0-9]+)*)?)$",
       {
-        "message": "Class names should only contain lowercase alphanumeric characters and hyphens, with no consecutive hyphens",
+        "message": "Class names must be kebab-case (e.g. block-element), or strict BEM (block__element--modifier) with at most one __element and one --modifier, in that order",
         "severity": "warning"
       }
     ],

package/README.md

@@ -10,6 +10,7 @@ This package provides ESLint rules and configurations for **Hubspot Marketing We
 - [Browser/React Setup](#browserreact-setup)
 - [Stylelint Setup](#stylelint-setup)
 - [Cypress Setup](#cypress-setup)
+- [Gherkin Tag Linting Setup](#gherkin-tag-linting-setup)
 - [Accessibility Testing](#accessibility-testing-optional)
 - [Custom Rules](#custom-rules)
 - [Where to use it](#where-to-use-it)
@@ -126,6 +127,26 @@ This package provides shared Cypress configuration for E2E testing.
 
 For detailed Cypress configuration and migration documentation, see [examples/cypress-usage.md](./examples/cypress-usage.md).
 
+## Gherkin Tag Linting Setup
+
+Cucumber selects tests by tag, so an untagged scenario is silently skipped and a green suite can hide tests that never ran. This package ships two checks that make that a build failure.
+
+This applies only to repositories whose Cypress suite is written in Gherkin `.feature` files. A Cypress suite written in Mocha has no tags to check. Neither check is part of `wtConfig`, `wtBrowserConfig`, or the Cypress config, so existing consumers are unaffected until they opt in with the script below.
+
+1. Add one script to `package.json`
+
+    ```json
+    {
+      "scripts": {
+        "lint:gherkin": "gplint cypress/e2e --config=node_modules/@hs-web-team/eslint-config-node/gherkin/.gplintrc && gherkin-tag-coverage"
+      }
+    }
+    ```
+
+`gplint` is bundled, so there is nothing extra to install. Repositories with no production environment opt out of the prod requirement with a `gherkin-coverage.json` file.
+
+For the full rule list, QA-only setup and troubleshooting, see [examples/gherkin-usage.md](./examples/gherkin-usage.md).
+
 ## Accessibility Testing (optional)
 
 This package includes a shared accessibility testing setup using [cypress-axe](https://github.com/component-driven/cypress-axe). Projects can opt in with a single import — no need to install `cypress-axe` or `axe-core` directly.
@@ -166,6 +187,7 @@ This package ships a `hs-web-team` ESLint plugin with custom rules that are acti
 | Rule | Severity | Summary |
 |------|----------|---------|
 | `hs-web-team/no-reduce-accumulator-copy` | error | Disallows O(n²) accumulator copies (spread, concat) inside `reduce`/`reduceRight` |
+| `hs-web-team/no-non-literal-constant-case` | warn | Disallows CONSTANT_CASE names whose value isn't a literal/static constant, or that are declared with `let`/`var` |
 
 For examples and remediation guidance, see [examples/custom-rules.md](./examples/custom-rules.md).
 

package/base-rules.js

@@ -0,0 +1,61 @@
+import globals from 'globals';
+
+// Underscore-prefixed HubSpot platform globals (e.g. window._hsq, window._hsg.__ip_lookup).
+// Exported so consuming projects can extend this list with their own no-underscore-dangle
+// allowances without duplicating the shared entries, e.g.:
+//   allow: [...underscoreDangleAllowlist, 'myProjectGlobal']
+export const underscoreDangleAllowlist = ['_hsg', '_hsp', '_hsq', '__ip_lookup'];
+
+export const nodeGlobals = { ...globals.node, ...globals.es2022, ...globals.jest };
+
+export const browserGlobals = {
+  ...globals.browser,
+  ...globals.es2021,
+  ...globals.jest,
+  $: true,
+  jQuery: true,
+  Invoca: true,
+};
+
+export const nodeBaseRules = {
+  'no-console': ['error', { allow: ['info', 'warn', 'error'] }],
+  camelcase: 'off',
+  'comma-dangle': ['warn', 'always-multiline'],
+  'arrow-parens': 0,
+  'no-plusplus': 0,
+  'no-underscore-dangle': ['error', { allow: ['__dirname', '__filename'] }],
+  'no-confusing-arrow': 0,
+  'import/no-unresolved': 0,
+  'import/prefer-default-export': 0,
+  'no-trailing-spaces': ['error', { skipBlankLines: true }],
+  'no-unused-expressions': ['warn', { allowTernary: true }],
+  'max-len': [2, { code: 120, ignoreStrings: true, ignoreTemplateLiterals: true }],
+  'operator-linebreak': 0,
+  'implicit-arrow-linebreaks': 0,
+  'implicit-arrow-linebreak': 0,
+  'object-curly-newline': 0,
+  'newline-per-chained-call': 0,
+  indent: 0,
+  'function-paren-newline': 0,
+  'max-params': ['warn', { max: 3 }],
+};
+
+export const browserBaseRules = {
+  'comma-dangle': ['warn', 'always-multiline'],
+  'no-param-reassign': ['warn', { props: false }],
+  'arrow-parens': 0,
+  'no-plusplus': 0,
+  'no-console': ['error', { allow: ['warn', 'error'] }],
+  'no-confusing-arrow': 0,
+  'no-underscore-dangle': ['error', { allow: underscoreDangleAllowlist }],
+  'no-trailing-spaces': ['error', { skipBlankLines: true }],
+  'no-unused-expressions': ['warn', { allowTernary: true }],
+  'max-len': [2, { code: 120, ignoreStrings: true, ignoreTemplateLiterals: true }],
+  'operator-linebreak': 0,
+  'implicit-arrow-linebreak': 0,
+  indent: 0,
+  'object-curly-newline': 0,
+  'function-paren-newline': 0,
+  'nonblock-statement-body-position': 0,
+  'max-params': ['warn', { max: 3 }],
+};

package/bin/gherkin-tag-coverage.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Fails when the suite as a whole is missing a required tag combination, e.g. no scenario
+ * anywhere is tagged @smoke @prod @en, which would make that CI job select zero specs and
+ * exit green.
+ *
+ * Silent on success, like gplint and eslint.
+ * Exit codes: 0 covered, 1 uncovered, 2 bad input.
+ *
+ * Usage: gherkin-tag-coverage [path]     (path defaults to cypress/e2e)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { loadCoverageConfig } from '../gherkin/load-config.js';
+import { findFeatureFiles, collectScenarios, findUncovered, formatProblems } from '../gherkin/suite-coverage.js';
+
+const target = process.argv[2] ?? path.join('cypress', 'e2e');
+
+if (!fs.existsSync(target)) {
+  console.error(`gherkin-tag-coverage: path not found: ${target}`);
+  process.exit(2);
+}
+
+let combinations;
+try {
+  ({ combinations } = await loadCoverageConfig());
+} catch (err) {
+  console.error(`gherkin-tag-coverage: ${err.message}`);
+  process.exit(2);
+}
+
+const files = findFeatureFiles(target);
+if (files.length === 0) {
+  console.error(`gherkin-tag-coverage: no .feature files found under ${target}`);
+  process.exit(1);
+}
+
+let scenarios;
+try {
+  scenarios = collectScenarios(files);
+} catch (err) {
+  console.error(`gherkin-tag-coverage: could not parse feature files. ${err.message}`);
+  process.exit(2);
+}
+
+if (scenarios.length === 0) {
+  console.error(
+    `gherkin-tag-coverage: found ${files.length} feature file(s) under ${target} but no scenarios in any of them.`,
+  );
+  process.exit(1);
+}
+
+const problems = findUncovered(scenarios, combinations);
+
+if (problems.length === 0) {
+  process.exit(0);
+}
+
+console.info(formatProblems(problems));
+process.exit(1);

package/browser.js

@@ -1,47 +1,13 @@
 import js from '@eslint/js';
-import globals from 'globals';
 import tseslint from 'typescript-eslint';
 import reactPlugin from 'eslint-plugin-react';
 import reactHooksPlugin from 'eslint-plugin-react-hooks';
 import jsxA11yPlugin from 'eslint-plugin-jsx-a11y';
 import { claudeCodePlugin } from './plugins/claude-code/index.js';
 import { hsWebTeamPlugin } from './plugins/hs-web-team/index.js';
+import { underscoreDangleAllowlist, browserBaseRules as baseRules, browserGlobals } from './base-rules.js';
 
-// Base rules adapted from the browser config
-const baseRules = {
-  'comma-dangle': ['warn', 'always-multiline'],
-  'no-param-reassign': ['warn', { props: false }],
-  'arrow-parens': 0,
-  'no-plusplus': 0,
-  'no-console': ['error', { allow: ['warn', 'error'] }],
-  'no-confusing-arrow': 0,
-  'no-underscore-dangle': [
-    'error',
-    {
-      allow: [
-        '_hsg',
-        '_hsq',
-      ],
-    },
-  ],
-  'no-trailing-spaces': ['error', { skipBlankLines: true }],
-  'no-unused-expressions': ['warn', { allowTernary: true }],
-  'max-len': [
-    2,
-    {
-      code: 120,
-      ignoreStrings: true,
-      ignoreTemplateLiterals: true,
-    },
-  ],
-  'operator-linebreak': 0,
-  'implicit-arrow-linebreak': 0,
-  indent: 0,
-  'object-curly-newline': 0,
-  'function-paren-newline': 0,
-  'nonblock-statement-body-position': 0,
-  'max-params': ['warn', { max: 3 }],
-};
+export { underscoreDangleAllowlist };
 
 // React-specific rules
 const reactRules = {
@@ -60,13 +26,7 @@ const reactRules = {
 };
 
 // Common ignore patterns
-const commonIgnores = [
-  '**/node_modules/**',
-  '**/dist/**',
-  '**/build/**',
-  '**/.next/**',
-  '**/coverage/**',
-];
+const commonIgnores = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.next/**', '**/coverage/**'];
 
 export default [
   // Global ignores
@@ -81,15 +41,7 @@ export default [
     languageOptions: {
       ecmaVersion: 2021,
       sourceType: 'module',
-      globals: {
-        ...globals.browser,
-        ...globals.es2021,
-        ...globals.jest,
-        // Custom browser globals from original config
-        $: true,
-        jQuery: true,
-        Invoca: true,
-      },
+      globals: browserGlobals,
       parserOptions: {
         ecmaFeatures: {
           jsx: true,
@@ -131,14 +83,7 @@ export default [
     languageOptions: {
       ecmaVersion: 2021,
       sourceType: 'module',
-      globals: {
-        ...globals.browser,
-        ...globals.es2021,
-        ...globals.jest,
-        $: true,
-        jQuery: true,
-        Invoca: true,
-      },
+      globals: browserGlobals,
       parserOptions: {
         ecmaFeatures: {
           jsx: true,

package/examples/browser-usage.md

@@ -57,6 +57,26 @@ If you're migrating from `@hs-web-team/eslint-config-browser` (ESLint 8):
 3. Ensure you're using Node.js >= 22
 4. Review and adapt any custom rules in your project
 
+## Extending the underscore-dangle allowlist
+
+`no-underscore-dangle` allows a fixed set of HubSpot platform globals (`_hsg`, `_hsp`, `_hsq`, `__ip_lookup`). If your project reads an additional underscore-prefixed global, extend the shared list instead of overriding the rule entirely:
+
+```javascript
+import wtBrowserConfig, { underscoreDangleAllowlist } from '@hs-web-team/eslint-config-node/browser';
+
+export default [
+  ...wtBrowserConfig,
+  {
+    rules: {
+      'no-underscore-dangle': [
+        'error',
+        { allow: [...underscoreDangleAllowlist, 'myProjectGlobal'] },
+      ],
+    },
+  },
+];
+```
+
 ## File Patterns
 
 The configuration applies to:

package/examples/custom-rules.md

@@ -57,3 +57,42 @@ const counts = items.reduce((acc, item) => {
   return acc;
 }, {});
 ```
+
+---
+
+## `hs-web-team/no-non-literal-constant-case` ⚠️ warn
+
+**Disallows `CONSTANT_CASE` names whose value isn't actually static.**
+
+A `CONSTANT_CASE` name signals to readers that the value is fixed and safe to assume unchanged for the lifetime of the program. When the value is actually computed at runtime — a function call, a conditional, a reference to a mutable binding — the name is misleading and can cost real debugging time (this rule was added after a `CONSTANT_CASE`-named variable turned out to be a debug-only runtime computation, defaulting to `0` for normal visitors).
+
+### What triggers it
+
+```js
+// ❌ Conditional — depends on runtime state
+const REDIRECT_DELAY_MS = isDebugMode() ? 1000 : 0;
+
+// ❌ Function call result
+const TOKEN = generateToken();
+
+// ❌ Declared with let/var — can be reassigned regardless of its current value
+let API_HOST = 'www.api-host.com';
+```
+
+### What to do instead
+
+```js
+// ✅ Rename to camelCase if the value genuinely isn't a constant
+const redirectDelayMs = isDebugMode() ? 1000 : 0;
+
+// ✅ Keep CONSTANT_CASE only when the value is a literal (or built purely from literals)
+const API_HOST = 'www.api-host.com';
+const RETRY_LIMITS = Object.freeze({ max: 3, backoffMs: 500 });
+const SORT_METHODS = new Set(['sort', 'toSorted']);
+```
+
+### What's allowed
+
+Literals, template literals with no interpolation, unary-wrapped literals (`-1`), arrays/objects composed entirely of the above (optionally wrapped in `Object.freeze(...)`), `new Set`/`new Map`/`new RegExp` (and their `Weak` variants) built from literal arguments, `process.env.X` references, and references to other `CONSTANT_CASE`-named identifiers are all treated as static and won't be flagged.
+
+**Not covered:** this rule only checks whether the *value* is static — it does not enforce that `CONSTANT_CASE` be reserved for exported bindings (a separate naming convention with much broader rollout impact, intentionally left out of this rule for now).

package/examples/gherkin-usage.md

@@ -0,0 +1,133 @@
+# Gherkin Tag Linting Usage
+
+This package provides shared tag linting for Cypress/Cucumber feature files.
+
+Cucumber selects which tests to run by tag, so a scenario with no tags is silently skipped. A
+suite can be fully green while some of its tests never execute. These two checks turn that into
+a build failure.
+
+## Applies to
+
+Only repositories whose Cypress suite is written in Gherkin, using
+`@badeball/cypress-cucumber-preprocessor` and `.feature` files.
+
+Both checks read `.feature` files and nothing else, so:
+
+- A Cypress suite written in Mocha (`.cy.js` / `.cy.ts` with `describe`/`it`) has nothing to
+  check. There are no tags to require, because Mocha does not select tests by tag.
+- Existing consumers of `@hs-web-team/eslint-config-node` are unaffected by upgrading. Neither
+  check is wired into `wtConfig`, `wtBrowserConfig`, or any Cypress config. Nothing runs until a
+  repository adds the `lint:gherkin` script below.
+
+## What is checked
+
+**Per scenario**, every scenario must carry:
+
+- at least one environment tag: `@qa` or `@prod`. Both together is valid.
+- at least one locale tag: `@en`, `@es`, `@fr`, `@de`, `@jp`, `@br`. Any number together is valid.
+
+Any other tag is allowed and ignored, including TestRail ids like `@a72w9o`. There is no tag
+allowlist.
+
+A tag counts wherever it is declared: the `Feature` line, a `Rule:`, the `Scenario:`, or an
+`Examples:` block. Inheritance works the same way as Cucumber's own `--tags` filtering.
+
+**Per suite**, the suite must contain at least one scenario tagged `@smoke @qa @en` and at least
+one tagged `@smoke @prod @en`. The same scenario may satisfy both, for example one tagged
+`@qa @prod @en @smoke`.
+
+This second check cannot be a lint rule, because a lint rule only ever sees one file at a time
+and never the whole suite.
+
+## Installation
+
+```bash
+npm i -D @hs-web-team/eslint-config-node@latest
+```
+
+`gplint` and the Gherkin parser are bundled, so there is nothing else to install.
+
+## Usage
+
+Add one script to your `package.json`:
+
+```json
+{
+  "scripts": {
+    "lint:gherkin": "gplint cypress/e2e --config=node_modules/@hs-web-team/eslint-config-node/gherkin/.gplintrc && gherkin-tag-coverage"
+  }
+}
+```
+
+Then run it:
+
+```bash
+npm run lint:gherkin
+```
+
+Both checks print nothing when they pass. A failure looks like this:
+
+```
+/path/to/cypress/e2e/login.feature
+   3:3  error  The tag(s) [@qa,@prod] should be present for Scenario.                required-tags
+   3:3  error  The tag(s) [@en,@es,@fr,@de,@jp,@br] should be present for Scenario.  required-tags
+
+✖ 2 problems (2 errors, 0 warnings)
+```
+
+Use `&&` rather than `;` to join the two commands. With `;` the exit code comes from the last
+command only, so a tag violation would pass CI.
+
+## QA-only repositories
+
+If a repository has no production environment, the `@smoke @prod @en` requirement can never be
+satisfied. Opt out by adding a `gherkin-coverage.json` next to `package.json`:
+
+```json
+{ "requiredCombinations": [["@smoke", "@qa", "@en"]] }
+```
+
+Do not satisfy the requirement by tagging a scenario `@prod` instead. Tags are what CI selects
+on, so that scenario would become eligible for the production run.
+
+A bare array works too:
+
+```json
+[["@smoke", "@qa", "@en"]]
+```
+
+## Passing a different path
+
+Both commands default to `cypress/e2e`. To point elsewhere:
+
+```bash
+gplint tests/features --config=node_modules/@hs-web-team/eslint-config-node/gherkin/.gplintrc
+gherkin-tag-coverage tests/features
+```
+
+Pass a **directory**, not a glob. `gplint` rewrites patterns containing `/**`, so
+`cypress/e2e/**/*.feature` matches nothing. Directories recurse to any depth.
+
+## Notes
+
+- `gplint` exits 0 when it matches no feature files, so a wrong path looks the same as a pass.
+  Check that the reported file count is non-zero when first setting this up, using
+  `--format=json` to list the files it found.
+- Tags are case sensitive. `@EN` does not satisfy `@en`, which is correct, because Cucumber
+  would not select it either.
+- A scenario written after a `Rule:` belongs to that Rule even if it is dedented back to feature
+  level, and inherits the Rule's tags. This is Gherkin behaviour, not a linter quirk.
+- An `Examples` table row cannot be tagged individually. Tags attach to the `Examples:` block and
+  every row inherits them.
+- Whitespace and formatting rules are deliberately not included, because Prettier owns those via
+  the bundled `prettier-plugin-gherkin`.
+- `gplint` prints an `ExperimentalWarning: Importing JSON modules` line to stderr on every run.
+  It is harmless.
+
+## Exit codes
+
+| Code | Meaning                                                                                   |
+| ---- | ----------------------------------------------------------------------------------------- |
+| 0    | Passed                                                                                    |
+| 1    | A real violation, or a missing suite-wide combination                                     |
+| 2    | Bad input, for example an unparseable feature file or a malformed `gherkin-coverage.json` |

package/gherkin/.gplintrc

@@ -0,0 +1,32 @@
+{
+  // Every scenario needs one tag from each list. Inherited tags count (Feature, Rule,
+  // Examples). Other tags are ignored. ignoreUntagged must stay false or fully untagged
+  // scenarios are skipped.
+  "required-tags": ["error", {
+    "ignoreUntagged": false,
+    "global": [
+      ["@qa", "@prod"],
+      ["@en", "@es", "@fr", "@de", "@jp", "@br"]
+    ]
+  }],
+
+  "no-duplicate-tags": "error",
+  // allowSeparated:false so "@qa @en #@smoke" fails. The default true allows it.
+  "no-partially-commented-tag-lines": ["error", { "allowSeparated": false }],
+
+  "no-empty-file": "error",
+  "no-files-without-scenarios": "error",
+  "no-unnamed-features": "error",
+  "no-unnamed-scenarios": "error",
+  "no-scenario-outlines-without-examples": "error",
+  "no-empty-background": "error",
+  "no-background-only-scenario": "error",
+  "no-dupe-feature-names": "error",
+  // in-feature, not the default "anywhere", which flags the same name in unrelated features.
+  "no-dupe-scenario-names": ["error", "in-feature"],
+  "use-and": "error",
+  "name-length": ["error", { "Feature": 60, "Scenario": 120, "Step": 475 }]
+
+  // Whitespace rules (indentation, no-trailing-spaces, new-line-at-eof,
+  // no-multiple-empty-lines) left off: prettier owns those.
+}

package/gherkin/coverage-config.js

@@ -0,0 +1,10 @@
+// Tag combinations the suite as a whole must contain at least one scenario for.
+// One scenario may satisfy several entries, e.g. a scenario tagged @qa @prod @en @smoke
+// covers both of these.
+//
+// Override per repo with a `gherkin-coverage.json` file next to package.json, either as a
+// bare array of combinations or as `{ "requiredCombinations": [...] }`.
+export default [
+  ['@smoke', '@qa', '@en'],
+  ['@smoke', '@prod', '@en'],
+];

package/gherkin/load-config.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import stripJsonComments from 'strip-json-comments';
+
+import defaultCombinations from './coverage-config.js';
+
+const OVERRIDE_FILE = 'gherkin-coverage.json';
+
+export async function loadCoverageConfig(cwd = process.cwd()) {
+  const overridePath = path.join(cwd, OVERRIDE_FILE);
+  if (!fs.existsSync(overridePath)) {
+    return { combinations: defaultCombinations, overridePath: null };
+  }
+
+  const override = JSON.parse(stripJsonComments(fs.readFileSync(overridePath, 'utf8')));
+  const combinations = Array.isArray(override) ? override : override?.requiredCombinations;
+
+  if (!Array.isArray(combinations) || combinations.some(combo => !Array.isArray(combo))) {
+    throw new Error(`${overridePath} must be an array of tag arrays, or { "requiredCombinations": [[...]] }.`);
+  }
+
+  return { combinations, overridePath };
+}

package/gherkin/suite-coverage.js

@@ -0,0 +1,126 @@
+/**
+ * Checks that the suite contains at least one scenario for each required tag combination.
+ *
+ * A gplint rule cannot do this: it is handed one file at a time and never sees the suite.
+ *
+ * Tags count no matter where they come from: the Feature line, a Rule, the Scenario, or an
+ * Examples block. This works because each file is compiled into "pickles" the same way
+ * Cucumber does, and a pickle's tag list is already the merged set Cucumber matches against
+ * when you run --tags.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import * as gherkin from '@cucumber/gherkin';
+import * as messages from '@cucumber/messages';
+
+export const RULE = 'suite-tag-coverage';
+
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'coverage']);
+
+export function findFeatureFiles(target) {
+  if (fs.statSync(target).isFile()) {
+    return target.endsWith('.feature') ? [target] : [];
+  }
+
+  const found = [];
+  for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+    const full = path.join(target, entry.name);
+    if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+      found.push(...findFeatureFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith('.feature')) {
+      found.push(full);
+    }
+  }
+  return found;
+}
+
+function parse(filePath) {
+  const parser = new gherkin.Parser(
+    new gherkin.AstBuilder(messages.IdGenerator.uuid()),
+    new gherkin.GherkinClassicTokenMatcher(),
+  );
+  const doc = parser.parse(fs.readFileSync(filePath, 'utf8'));
+  return { pickles: gherkin.compile(doc, filePath, messages.IdGenerator.uuid()), doc };
+}
+
+// A pickle knows which AST nodes it came from but not its line number, so build id -> line.
+function lineIndex(doc) {
+  const lines = new Map();
+  const visit = children => {
+    for (const child of children ?? []) {
+      if (child.rule) visit(child.rule.children);
+      if (!child.scenario) continue;
+      lines.set(child.scenario.id, child.scenario.location.line);
+      for (const examples of child.scenario.examples ?? []) {
+        for (const row of examples.tableBody ?? []) {
+          lines.set(row.id, row.location.line);
+        }
+      }
+    }
+  };
+  visit(doc.feature?.children);
+  return lines;
+}
+
+export function collectScenarios(files) {
+  const scenarios = [];
+  for (const file of files) {
+    const parsed = parse(file);
+    const lines = lineIndex(parsed.doc);
+    for (const pickle of parsed.pickles) {
+      scenarios.push({
+        file,
+        name: pickle.name,
+        line: lines.get(pickle.astNodeIds.at(-1)) ?? '?',
+        tags: new Set(pickle.tags.map(tag => tag.name)),
+      });
+    }
+  }
+  return scenarios;
+}
+
+/** Returns one problem per uncovered combination, anchored at the closest scenario. */
+export function findUncovered(scenarios, combinations) {
+  return combinations
+    .filter(combo => !scenarios.some(scenario => combo.every(tag => scenario.tags.has(tag))))
+    .map(combo => {
+      // Rank by how many tags are missing so the suggestion is the smallest possible fix.
+      const closest = scenarios
+        .map(scenario => ({ scenario, missing: combo.filter(tag => !scenario.tags.has(tag)) }))
+        .sort((a, b) => a.missing.length - b.missing.length)[0];
+
+      return {
+        file: closest.scenario.file,
+        line: closest.scenario.line,
+        column: 3,
+        message: `No scenario in the suite is tagged [${combo.join(' ')}]. Add ${closest.missing.join(' ')} here, or tag another scenario.`,
+      };
+    });
+}
+
+/** gplint's stylish format, so the lint and coverage checks read as one tool. */
+export function formatProblems(problems) {
+  const byFile = new Map();
+  for (const problem of problems) {
+    if (!byFile.has(problem.file)) byFile.set(problem.file, []);
+    byFile.get(problem.file).push(problem);
+  }
+
+  const width = Math.max(...problems.map(problem => `${problem.line}:${problem.column}`.length));
+  const lines = [];
+
+  for (const [file, fileProblems] of [...byFile.entries()].sort()) {
+    lines.push('', path.resolve(file));
+    for (const problem of fileProblems.sort((a, b) => a.line - b.line)) {
+      const at = `${problem.line}:${problem.column}`.padStart(width);
+      lines.push(`  ${at}  error  ${problem.message}  ${RULE}`);
+    }
+  }
+
+  const count = problems.length;
+  const plural = count === 1 ? '' : 's';
+  lines.push('', `✖ ${count} problem${plural} (${count} error${plural}, 0 warnings)`, '');
+
+  return lines.join('\n');
+}

package/index.js

@@ -1,60 +1,11 @@
 import js from '@eslint/js';
-import globals from 'globals';
 import tseslint from 'typescript-eslint';
 import { claudeCodePlugin } from './plugins/claude-code/index.js';
 import { hsWebTeamPlugin } from './plugins/hs-web-team/index.js';
-
-// Base rules for all JavaScript files
-const baseRules = {
-  'no-console': [
-    'error',
-    {
-      allow: ['info', 'warn', 'error'],
-    },
-  ],
-  camelcase: 'off',
-  'comma-dangle': ['warn', 'always-multiline'],
-  'arrow-parens': 0,
-  'no-plusplus': 0,
-  'no-underscore-dangle': [
-    'error',
-    {
-      allow: [
-        '__dirname',
-        '__filename',
-      ],
-    },
-  ],
-  'no-confusing-arrow': 0,
-  'import/no-unresolved': 0,
-  'import/prefer-default-export': 0,
-  'no-trailing-spaces': ['error', { skipBlankLines: true }],
-  'no-unused-expressions': ['warn', { allowTernary: true }],
-  'max-len': [
-    2,
-    {
-      code: 120,
-      ignoreStrings: true,
-      ignoreTemplateLiterals: true,
-    },
-  ],
-  'operator-linebreak': 0,
-  'implicit-arrow-linebreaks': 0,
-  'implicit-arrow-linebreak': 0,
-  'object-curly-newline': 0,
-  'newline-per-chained-call': 0,
-  indent: 0,
-  'function-paren-newline': 0,
-  'max-params': ['warn', { max: 3 }],
-};
+import { nodeBaseRules as baseRules, nodeGlobals } from './base-rules.js';
 
 // Common ignore patterns
-const commonIgnores = [
-  '**/node_modules/**',
-  '**/.serverless/**',
-  '**/.webpack/**',
-  '**/dist/**',
-];
+const commonIgnores = ['**/node_modules/**', '**/.serverless/**', '**/.webpack/**', '**/dist/**'];
 
 export default [
   // Global ignores
@@ -67,7 +18,7 @@ export default [
   {
     files: ['**/*.{js,mjs,cjs}'],
     languageOptions: {
-      globals: {...globals.node, ...globals.es2022, ...globals.jest},
+      globals: nodeGlobals,
     },
     rules: baseRules,
   },
@@ -80,7 +31,7 @@ export default [
   {
     files: ['**/*.{ts,mts,cts,tsx}'],
     languageOptions: {
-      globals: {...globals.node, ...globals.es2022, ...globals.jest},
+      globals: nodeGlobals,
     },
     rules: baseRules,
   },

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@hs-web-team/eslint-config-node",
-  "version": "5.0.0",
+  "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",
@@ -12,6 +13,7 @@
     "cypress/",
     "docs/",
     "examples/",
+    "gherkin/",
     "index.js",
     "plugins/"
   ],
@@ -31,7 +33,9 @@
       "types": "./cypress/index.d.ts",
       "default": "./cypress/index.js"
     },
-    "./plugin": "./plugins/hs-web-team/index.js"
+    "./plugin": "./plugins/hs-web-team/index.js",
+    "./gherkin/.gplintrc": "./gherkin/.gplintrc",
+    "./gherkin/coverage-config": "./gherkin/coverage-config.js"
   },
   "typesVersions": {
     "*": {
@@ -47,13 +51,15 @@
     "postinstall": "node bin/check-peer-deps.cjs",
     "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",
@@ -75,6 +81,8 @@
   "homepage": "https://github.com/HubSpotWebTeam/wt-eslint-node#readme",
   "dependencies": {
     "@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",
     "@eslint/markdown": "8.0.3",
@@ -89,10 +97,12 @@
     "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",
+    "strip-json-comments": "5.0.3",
     "typescript-eslint": "8.68.0"
   },
   "peerDependencies": {
@@ -119,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/hs-web-team/index.js

@@ -1,9 +1,11 @@
 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,
   },
 };
@@ -15,6 +17,7 @@ hsWebTeamPlugin.configs = {
     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-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 },
+        });
+      },
+    };
+  },
+};