@scayle/eslint-config-storefront 4.8.3-alpha.1 → 5.1.0

package/config/javascript.mjs

@@ -0,0 +1,159 @@
+import js from '@eslint/js'
+import globals from 'globals'
+
+// Core JavaScript correctness rules, plus a handful of Storefront-specific overrides
+// on top of `@eslint/js`'s `recommended` preset.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for core JavaScript correctness rules. */
+export function javascriptConfig() {
+  return [
+    {
+      name: 'storefront/javascript/setup',
+      languageOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+        globals: {
+          ...globals.browser,
+          ...globals.es2021,
+          ...globals.node,
+        },
+        parserOptions: {
+          ecmaFeatures: { jsx: true },
+        },
+      },
+    },
+    {
+      name: 'storefront/javascript/rules',
+      rules: {
+        ...js.configs.recommended.rules,
+        'accessor-pairs': [
+          'error',
+          { enforceForClassMembers: true, setWithoutGet: true },
+        ],
+        'array-callback-return': 'error',
+        'block-scoped-var': 'error',
+        'default-case-last': 'error',
+        'dot-notation': ['error', { allowKeywords: true }],
+        eqeqeq: ['error', 'smart'],
+        'new-cap': [
+          'error',
+          { capIsNew: false, newIsCap: true, properties: true },
+        ],
+        'no-alert': 'error',
+        'no-caller': 'error',
+        'no-eval': 'error',
+        'no-extend-native': 'error',
+        'no-extra-bind': 'error',
+        'no-implied-eval': 'error',
+        'no-iterator': 'error',
+        'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
+        'no-lone-blocks': 'error',
+        'no-multi-str': 'error',
+        'no-new': 'error',
+        'no-new-func': 'error',
+        'no-new-wrappers': 'error',
+        'no-octal-escape': 'error',
+        'no-proto': 'error',
+        'no-restricted-globals': [
+          'error',
+          { name: 'global', message: 'Use `globalThis` instead.' },
+          { name: 'self', message: 'Use `globalThis` instead.' },
+        ],
+        'no-restricted-properties': [
+          'error',
+          {
+            property: '__proto__',
+            message:
+              'Use `Object.getPrototypeOf` or `Object.setPrototypeOf` instead.',
+          },
+          {
+            property: '__defineGetter__',
+            message: 'Use `Object.defineProperty` instead.',
+          },
+          {
+            property: '__defineSetter__',
+            message: 'Use `Object.defineProperty` instead.',
+          },
+          {
+            property: '__lookupGetter__',
+            message: 'Use `Object.getOwnPropertyDescriptor` instead.',
+          },
+          {
+            property: '__lookupSetter__',
+            message: 'Use `Object.getOwnPropertyDescriptor` instead.',
+          },
+        ],
+        'no-self-compare': 'error',
+        'no-sequences': 'error',
+        'no-template-curly-in-string': 'error',
+        'no-throw-literal': 'error',
+        'no-undef-init': 'error',
+        'no-unmodified-loop-condition': 'error',
+        'no-unneeded-ternary': ['error', { defaultAssignment: false }],
+        'no-unreachable-loop': 'error',
+        'no-unused-expressions': [
+          'error',
+          {
+            allowShortCircuit: true,
+            allowTernary: true,
+            allowTaggedTemplates: true,
+          },
+        ],
+        'no-unused-vars': [
+          'error',
+          {
+            args: 'all',
+            argsIgnorePattern: '^_',
+            caughtErrors: 'all',
+            caughtErrorsIgnorePattern: '^_',
+            destructuredArrayIgnorePattern: '^_',
+            varsIgnorePattern: '^_',
+            ignoreRestSiblings: true,
+          },
+        ],
+        'no-use-before-define': [
+          'error',
+          { functions: false, classes: false, variables: true },
+        ],
+        'no-useless-call': 'error',
+        'no-useless-computed-key': 'error',
+        // Off: a subclass constructor that only forwards to `super(...)` is
+        // still meaningful documentation of the accepted argument types at
+        // an extension point (e.g. a mapper/service subclass), even when it
+        // matches the base class's signature exactly.
+        'no-useless-constructor': 'off',
+        'no-useless-rename': 'error',
+        'no-useless-return': 'error',
+        'no-var': 'error',
+        'object-shorthand': [
+          'error',
+          'always',
+          { avoidQuotes: true, ignoreConstructors: false },
+        ],
+        'one-var': ['error', { initialized: 'never' }],
+        'prefer-arrow-callback': [
+          'error',
+          { allowNamedFunctions: false, allowUnboundThis: true },
+        ],
+        'prefer-const': [
+          'error',
+          { destructuring: 'all', ignoreReadBeforeAssign: true },
+        ],
+        'prefer-exponentiation-operator': 'error',
+        'prefer-promise-reject-errors': 'error',
+        'prefer-regex-literals': ['error', { disallowRedundantWrapping: true }],
+        'prefer-rest-params': 'error',
+        'prefer-spread': 'error',
+        'prefer-template': 'error',
+        'symbol-description': 'error',
+        'unicode-bom': ['error', 'never'],
+        'use-isnan': [
+          'error',
+          { enforceForIndexOf: true, enforceForSwitchCase: true },
+        ],
+        'valid-typeof': ['error', { requireStringLiterals: true }],
+        'vars-on-top': 'error',
+        yoda: ['error', 'never'],
+      },
+    },
+  ]
+}

package/config/rules.mjs

@@ -0,0 +1,220 @@
+import comments from '@eslint-community/eslint-plugin-eslint-comments'
+import pluginNode from 'eslint-plugin-n'
+import jsonc from 'eslint-plugin-jsonc'
+import pluginSonarjs from 'eslint-plugin-sonarjs'
+import pluginPromise from 'eslint-plugin-promise'
+import regexp from 'eslint-plugin-regexp'
+import { importX as pluginImportX } from 'eslint-plugin-import-x'
+import jsdoc from 'eslint-plugin-jsdoc'
+import e18e from '@e18e/eslint-plugin'
+
+// Small, single-plugin rule domains that don't warrant their own file. Each
+// still exports its own named factory, so composition and imports elsewhere
+// in the package are unaffected by living in this shared file.
+
+// ESLint directive comment hygiene (e.g. eslint-disable) rules.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries enforcing ESLint directive comment hygiene. */
+export function commentsConfig() {
+  return [
+    {
+      name: 'storefront/comments/rules',
+      plugins: { 'eslint-comments': comments },
+      rules: {
+        'eslint-comments/no-aggregating-enable': 'error',
+        'eslint-comments/no-duplicate-disable': 'error',
+        'eslint-comments/no-unlimited-disable': 'error',
+        'eslint-comments/no-unused-enable': 'error',
+      },
+    },
+  ]
+}
+
+// Node.js best-practice rules.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for Node.js best-practice rules. */
+export function nodeConfig() {
+  return [
+    {
+      name: 'storefront/node/rules',
+      plugins: { node: pluginNode },
+      rules: {
+        'node/handle-callback-err': ['error', '^(err|error)$'],
+        'node/no-deprecated-api': 'error',
+        'node/no-exports-assign': 'error',
+        'node/no-new-require': 'error',
+        'node/no-path-concat': 'error',
+        'node/prefer-global/buffer': ['error', 'never'],
+        'node/prefer-global/process': ['error', 'never'],
+        'node/process-exit-as-throw': 'error',
+      },
+    },
+  ]
+}
+
+// JSON / JSONC structural and stylistic rules.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for JSON/JSONC structural and stylistic rules. */
+export function jsoncConfig() {
+  return [
+    ...jsonc.configs['flat/recommended-with-jsonc'],
+    {
+      name: 'storefront/jsonc/rules',
+      files: ['**/*.json', '**/*.json5', '**/*.jsonc'],
+      rules: {
+        'jsonc/array-bracket-spacing': ['error', 'never'],
+        'jsonc/comma-dangle': ['error', 'never'],
+        'jsonc/comma-style': ['error', 'last'],
+        'jsonc/indent': ['error', 2],
+        'jsonc/key-spacing': [
+          'error',
+          { afterColon: true, beforeColon: false },
+        ],
+        'jsonc/object-curly-newline': [
+          'error',
+          { consistent: true, multiline: true },
+        ],
+        'jsonc/object-curly-spacing': ['error', 'always'],
+        'jsonc/object-property-newline': [
+          'error',
+          { allowAllPropertiesOnSameLine: true },
+        ],
+        'jsonc/quote-props': 'error',
+        'jsonc/quotes': 'error',
+      },
+    },
+  ]
+}
+
+// Pre-defined rule configurations for better performance
+/** @type {import('eslint').Linter.RulesRecord} */
+const SONARJS_RULES = {
+  'sonarjs/no-duplicate-string': 'off',
+  'sonarjs/todo-tag': 'warn',
+  'sonarjs/fixme-tag': 'warn',
+}
+
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for SonarJS rules. */
+export function sonarjsConfig() {
+  return [
+    /** @type {import('eslint').Linter.Config} */ (
+      pluginSonarjs.configs.recommended
+    ),
+    {
+      name: 'storefront/sonarjs/rules',
+      rules: SONARJS_RULES,
+    },
+  ]
+}
+
+// Pre-defined rule configurations for better performance
+/** @type {import('eslint').Linter.RulesRecord} */
+const PROMISE_RULES = {
+  'promise/no-multiple-resolved': 'error',
+  'promise/no-new-statics': 'error',
+  'promise/no-return-wrap': 'error',
+  'promise/always-return': 'warn',
+  'promise/avoid-new': 'warn',
+  'promise/catch-or-return': 'warn',
+  'promise/no-callback-in-promise': 'warn',
+  'promise/no-nesting': 'warn',
+  'promise/no-promise-in-callback': 'warn',
+  'promise/no-return-in-finally': 'warn',
+  'promise/param-names': 'warn',
+  'promise/valid-params': 'warn',
+  'promise/no-native': 'off',
+}
+
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for Promise usage rules. */
+export function promiseConfig() {
+  return [
+    {
+      name: 'storefront/promise/rules',
+      plugins: { promise: pluginPromise },
+      rules: PROMISE_RULES,
+    },
+  ]
+}
+
+// Regex correctness rules, including ReDoS-prone pattern detection.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for regex correctness rules. */
+export function regexpConfig() {
+  return [
+    {
+      name: 'storefront/regexp/rules',
+      ...regexp.configs['flat/recommended'],
+    },
+  ]
+}
+
+// Pre-defined rule configurations for better performance
+/** @type {import('eslint').Linter.RulesRecord} */
+const IMPORT_X_RULES = {
+  'import-x/consistent-type-specifier-style': ['error', 'prefer-top-level'],
+  'import-x/first': 'error',
+  'import-x/no-duplicates': 'error',
+  'import-x/no-mutable-exports': 'error',
+  'import-x/no-named-default': 'error',
+  'import-x/no-self-import': 'error',
+  'import-x/no-extraneous-dependencies': 'error',
+}
+
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for import/export correctness rules. */
+export function importXConfig() {
+  return [
+    {
+      name: 'storefront/import-x/rules',
+      plugins: { 'import-x': pluginImportX },
+      rules: IMPORT_X_RULES,
+    },
+  ]
+}
+
+// JSDoc validation. Storefront SDK packages require JSDoc on every exported symbol.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries validating JSDoc comments. */
+export function jsdocConfig() {
+  return [
+    {
+      name: 'storefront/jsdoc/rules',
+      plugins: { jsdoc },
+      rules: {
+        'jsdoc/check-access': 'warn',
+        'jsdoc/check-param-names': 'warn',
+        'jsdoc/check-property-names': 'warn',
+        'jsdoc/check-types': 'warn',
+        'jsdoc/empty-tags': 'warn',
+        'jsdoc/implements-on-classes': 'warn',
+        'jsdoc/no-defaults': 'warn',
+        'jsdoc/no-multi-asterisks': 'warn',
+        'jsdoc/require-param-name': 'warn',
+        'jsdoc/require-property': 'warn',
+        'jsdoc/require-property-description': 'warn',
+        'jsdoc/require-property-name': 'warn',
+        'jsdoc/require-returns-check': 'warn',
+        'jsdoc/require-returns-description': 'warn',
+        'jsdoc/require-yields-check': 'warn',
+        'jsdoc/check-alignment': 'warn',
+        'jsdoc/multiline-blocks': 'warn',
+      },
+    },
+  ]
+}
+
+// Modernization, module-replacement, and performance rules from the e18e
+// community (https://e18e.dev). Uses the plugin's own `recommended` preset
+// (all three of its rule categories), downgraded to `warn`: the plugin is
+// young (pre-1.0) and its rule set hasn't been reviewed against this
+// codebase yet, so findings surface without blocking CI.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for e18e modernization and performance rules. */
+export function e18eConfig() {
+  const recommendedRules = e18e.configs.recommended.rules ?? {}
+  /** @type {import('eslint').Linter.RulesRecord} */
+  const rules = Object.fromEntries(
+    Object.keys(recommendedRules).map((ruleName) => [ruleName, 'warn']),
+  )
+
+  return [
+    {
+      name: 'storefront/e18e/rules',
+      plugins: e18e.configs.recommended.plugins,
+      rules,
+    },
+  ]
+}

package/config/test.mjs

@@ -0,0 +1,36 @@
+import vitest from '@vitest/eslint-plugin'
+import noOnlyTests from 'eslint-plugin-no-only-tests'
+
+export const GLOB_TESTS = [
+  '**/__tests__/**/*.{js,jsx,ts,tsx,mjs,cjs,mjsx,cts,ctsx}',
+  '**/*.spec.*',
+  '**/*.test.*',
+  '**/*.bench.*',
+  '**/*.benchmark.*',
+]
+
+// Test-file rules (Vitest conventions, no `.only` left behind).
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for test-file conventions. */
+export function testConfig() {
+  return [
+    {
+      name: 'storefront/test/rules',
+      files: GLOB_TESTS,
+      plugins: {
+        vitest,
+        'no-only-tests': noOnlyTests,
+      },
+      rules: {
+        'vitest/consistent-test-it': [
+          'error',
+          { fn: 'it', withinDescribe: 'it' },
+        ],
+        'vitest/no-identical-title': 'error',
+        'vitest/no-import-node-test': 'error',
+        'no-only-tests/no-only-tests': process.env.CI ? 'error' : 'warn',
+        'vitest/prefer-hooks-in-order': 'error',
+        'vitest/prefer-lowercase-title': 'error',
+      },
+    },
+  ]
+}

package/config/typescript.mjs

@@ -0,0 +1,92 @@
+import { defineConfig } from 'eslint/config'
+import tseslint from 'typescript-eslint'
+
+// TypeScript rules. Type-aware rules only activate when `tsconfigPath` is provided,
+// since they require a full TypeScript program build (`parserOptions.projectService`).
+//
+// The `@typescript-eslint` plugin is registered unscoped (no `files`) so that consumers
+// can reference `@typescript-eslint/*` rules from their own `files: ['**/*.vue']`
+// overrides (the plugin, not just the rule set, must be visible to those file globs too).
+// Core `no-unused-vars` is turned off only for the TypeScript file types below, scoped
+// to the same `files:` array as `@typescript-eslint/no-unused-vars`: it isn't type-aware,
+// so it misreads TypeScript-only constructs (e.g. a named parameter inside a type literal)
+// as real unused bindings. `.js`/`.mjs`/`.cjs` files keep the core rule from javascript.mjs.
+// Consumers that wire up `@typescript-eslint/parser` for another extension (like `.vue` via
+// `vue-eslint-parser`) should register `@typescript-eslint/no-unused-vars` there themselves,
+// since only they know which file types actually parse as TypeScript.
+/**
+ * @param {object} [config]
+ * @param {string} [config.tsconfigPath] Absolute path to the tsconfig.json to type-check
+ *   against. When omitted, only non-type-aware TypeScript rules apply.
+ * @returns {import('eslint').Linter.Config[]} Flat config entries for TypeScript rules.
+ */
+export function typescriptConfig(config = {}) {
+  const { tsconfigPath } = config
+
+  return defineConfig(
+    {
+      name: 'storefront/typescript/plugin',
+      plugins: { '@typescript-eslint': tseslint.plugin },
+    },
+    {
+      name: 'storefront/typescript',
+      files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'],
+      extends: [
+        tseslint.configs.recommended,
+        ...(tsconfigPath ? [tseslint.configs.recommendedTypeChecked] : []),
+      ],
+      ...(tsconfigPath
+        ? {
+            languageOptions: {
+              parserOptions: {
+                projectService: { defaultProject: tsconfigPath },
+                tsconfigRootDir: process.cwd(),
+              },
+            },
+          }
+        : {}),
+      rules: {
+        'no-unused-vars': 'off',
+        'no-use-before-define': 'off',
+        '@typescript-eslint/no-use-before-define': [
+          'error',
+          { functions: false, classes: false, variables: true },
+        ],
+        '@typescript-eslint/consistent-type-definitions': [
+          'error',
+          'interface',
+        ],
+        '@typescript-eslint/consistent-type-imports': [
+          'error',
+          {
+            prefer: 'type-imports',
+            fixStyle: 'separate-type-imports',
+            disallowTypeAnnotations: false,
+          },
+        ],
+        '@typescript-eslint/method-signature-style': ['error', 'property'],
+        '@typescript-eslint/no-import-type-side-effects': 'error',
+        '@typescript-eslint/no-explicit-any': [
+          'warn',
+          { ignoreRestArgs: true },
+        ],
+        '@typescript-eslint/no-empty-object-type': [
+          'error',
+          { allowInterfaces: 'always' },
+        ],
+        '@typescript-eslint/no-unused-vars': [
+          'error',
+          {
+            args: 'all',
+            argsIgnorePattern: '^_',
+            caughtErrors: 'all',
+            caughtErrorsIgnorePattern: '^_',
+            destructuredArrayIgnorePattern: '^_',
+            varsIgnorePattern: '^_',
+            ignoreRestSiblings: true,
+          },
+        ],
+      },
+    },
+  )
+}

package/config/unicorn.mjs

@@ -0,0 +1,33 @@
+import pluginUnicorn from 'eslint-plugin-unicorn'
+
+const GLOB_SRC = '**/*.?([cm])[jt]s?(x)'
+
+// Modernization rules: a curated subset of eslint-plugin-unicorn, not its full
+// `recommended` preset (hundreds of opinionated rules, many stylistic).
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for modernization rules. */
+export function unicornConfig() {
+  return [
+    {
+      name: 'storefront/unicorn/rules',
+      files: [GLOB_SRC],
+      plugins: { unicorn: pluginUnicorn },
+      rules: {
+        'unicorn/consistent-empty-array-spread': 'error',
+        'unicorn/error-message': 'error',
+        'unicorn/escape-case': 'error',
+        'unicorn/new-for-builtins': 'error',
+        'unicorn/no-instanceof-builtins': 'error',
+        'unicorn/no-new-array': 'error',
+        'unicorn/no-new-buffer': 'error',
+        'unicorn/number-literal-case': 'error',
+        'unicorn/prefer-dom-node-text-content': 'error',
+        'unicorn/prefer-includes': 'error',
+        'unicorn/prefer-node-protocol': 'error',
+        'unicorn/prefer-number-properties': 'error',
+        'unicorn/prefer-string-starts-ends-with': 'error',
+        'unicorn/prefer-type-error': 'error',
+        'unicorn/throw-new-error': 'error',
+      },
+    },
+  ]
+}

package/config/v3/importResolver.mjs

@@ -0,0 +1,71 @@
+import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript'
+
+// Resolves aliased imports (e.g. tsconfig.json `paths` like `@client/*`) to their real
+// files, so import-x/no-restricted-paths, import-x/no-cycle, and import-x/order can see
+// through them instead of only matching literal relative imports. Without this, every
+// rule that compares resolved paths silently no-ops on an alias it can't resolve.
+/**
+ * @param {string} [tsconfigPath] Absolute path to the tsconfig.json to resolve aliases
+ *   against (from `resolver.tsconfigPath`, falling back to `typescript.tsconfigPath`).
+ *   Omit both to use the resolver's own `<cwd>/tsconfig.json` default.
+ * @returns {import('eslint').Linter.Config[]} Flat config entries wiring the resolver and
+ *   the setting import-x/no-cycle needs to use it correctly.
+ */
+export function importResolverConfig(tsconfigPath) {
+  return [
+    {
+      name: 'storefront/v3/import-resolver',
+      settings: {
+        'import-x/resolver-next': [
+          createTypeScriptImportResolver(
+            tsconfigPath ? { project: tsconfigPath } : undefined,
+          ),
+        ],
+        // import-x/no-cycle builds its own export map per file and gates that on
+        // this setting (distinct from the import-x/extensions *rule*). It defaults
+        // to .js/.mjs/.cjs only, so without this, every .ts/.tsx file silently
+        // returns a null export map and cycles through them go undetected past
+        // depth 1, alias or not.
+        //
+        // .vue is deliberately not listed here: the export map builder's parser
+        // (via import-x/parsers) can't replicate the <script setup lang="ts">
+        // sub-parser wiring vueConfig() sets up, so it errors on every .vue file's
+        // <template> block. Those errors are swallowed rather than surfaced as lint
+        // failures, but they also mean a walk that needs to build a .vue file's
+        // export map (rather than lint it directly) can't see past it. A cycle
+        // that runs through a .vue file still gets caught when ESLint lints that
+        // .vue file itself, since it parses that one file with the real language
+        // config, not the export map builder.
+        'import-x/extensions': ['.js', '.mjs', '.cjs', '.ts', '.tsx'],
+      },
+    },
+  ]
+}
+
+// The default groups list omits 'internal' (the rank an aliased import gets once it
+// resolves), which would otherwise drop every @client/@server/@shared-style import to
+// last place instead of sorting with 'external' the way Vue 3 projects conventionally
+// write them. 'builtin' stays its own rank, ahead of both: a `node:*` import belongs at
+// the top of the file the same way it already does under the default groups.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for import ordering, aware of resolved aliases. */
+export function importOrderConfig() {
+  return [
+    {
+      name: 'storefront/v3/import-order',
+      rules: {
+        'import-x/order': [
+          'error',
+          {
+            groups: [
+              'builtin',
+              ['external', 'internal'],
+              'parent',
+              'sibling',
+              'index',
+            ],
+          },
+        ],
+      },
+    },
+  ]
+}

package/config/v3/storybook.mjs

@@ -0,0 +1,10 @@
+import storybook from 'eslint-plugin-storybook'
+
+// https://github.com/storybookjs/eslint-plugin-storybook
+// Applies only to files matching `*.stories.*` / `*.story.*`.
+/** @returns {import('eslint').Linter.Config[]} Flat config entries for Storybook file conventions. */
+export function storybookConfig() {
+  return /** @type {import('eslint').Linter.Config[]} */ (
+    storybook.configs['flat/recommended']
+  )
+}

package/config/v3/tailwind.mjs

@@ -0,0 +1,30 @@
+import { defineConfig } from 'eslint/config'
+import eslintPluginBetterTailwindcss from 'eslint-plugin-better-tailwindcss'
+
+/**
+ * @param {object} config
+ * @param {string} config.entryPoint Path to the project's Tailwind CSS entry point
+ *   (e.g. `./src/client/index.css`), passed to the plugin's `entryPoint` setting.
+ * @returns {import('eslint').Linter.Config[]} Flat config entries for Tailwind CSS class validation.
+ */
+export function tailwindConfig(config) {
+  const { entryPoint } = config ?? {}
+
+  if (!entryPoint) {
+    throw new Error('storefrontV3: config.tailwind.entryPoint is required')
+  }
+
+  return defineConfig({
+    name: 'storefront/v3/tailwind',
+    extends: [eslintPluginBetterTailwindcss.configs.recommended],
+    rules: {
+      'better-tailwindcss/enforce-consistent-line-wrapping': 'off',
+      // The eslint plugin uses a different class order than the prettier plugin.
+      // Disabled to avoid conflicts between the two.
+      'better-tailwindcss/enforce-consistent-class-order': 'off',
+    },
+    settings: {
+      'better-tailwindcss': { entryPoint },
+    },
+  })
+}