@hypersolid-dev/eslint-config 0.0.0-stage → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [0.1.1](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/branchCompare?baseVersion=GTv0.1.0&targetVersion=GTv0.1.1) (2026-11-06)
+
+### Bug Fixes
+
+* **react-native:** disable unicorn rules that suggest APIs Hermes lacks ([b93eaa2](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_git/eslint-config-hypersolid/commit/b93eaa2812181a277b5a3c551338de320a808586)), closes [AB#5173](https://dev.azure.com/wearetriple/Triple%20-%20Webteam/_workitems/edit/5173)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hypersolid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,154 @@
-# Temporary Holding Version
+# @hypersolid-dev/eslint-config
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Shared ESLint flat config for Hypersolid TypeScript projects. Type-aware by default, every enabled rule is an `error`, and formatting is left to your formatter.
+
+## Requirements
+
+- Node 24+
+- ESLint `^10.4.0` (flat config only, no `.eslintrc`)
+- TypeScript `>=5.8 <6.1` (typescript-eslint does not support TypeScript 7 yet)
+- A `tsconfig.json` that includes the files you lint
+
+## Install
+
+```bash
+pnpm add -D @hypersolid-dev/eslint-config eslint typescript
+```
+
+The plugins are regular dependencies of this package, so you don't install them yourself.
+
+## Presets
+
+| Preset | Import | For |
+| --- | --- | --- |
+| `base` | `@hypersolid-dev/eslint-config/base` | Every TypeScript project. Required, and always first. |
+| `react` | `@hypersolid-dev/eslint-config/react` | React for the web. |
+| `react-native` | `@hypersolid-dev/eslint-config/react-native` | React Native and Expo. Use instead of `react`. |
+| `node` | `@hypersolid-dev/eslint-config/node` | Node.js services, scripts and CLIs. |
+| `next` | `@hypersolid-dev/eslint-config/next` | Next.js. Stack on top of `react`. |
+
+Each preset is a function that returns an array of config objects. Presets don't include `base`: spread `base` first, then the presets you need, then your own overrides.
+
+`base` takes `tsconfigRootDir`, the directory your `tsconfig.json` lives in, and throws without it. In an `eslint.config.js` next to your `tsconfig.json`, that's `import.meta.dirname`.
+
+### TypeScript library or package
+
+```js
+// eslint.config.js
+import base from '@hypersolid-dev/eslint-config/base';
+
+export default [...base({ tsconfigRootDir: import.meta.dirname })];
+```
+
+### Node.js
+
+```js
+import base from '@hypersolid-dev/eslint-config/base';
+import node from '@hypersolid-dev/eslint-config/node';
+
+export default [...base({ tsconfigRootDir: import.meta.dirname }), ...node()];
+```
+
+### React
+
+```js
+import base from '@hypersolid-dev/eslint-config/base';
+import react from '@hypersolid-dev/eslint-config/react';
+
+export default [...base({ tsconfigRootDir: import.meta.dirname }), ...react()];
+```
+
+### React Native / Expo
+
+```js
+import base from '@hypersolid-dev/eslint-config/base';
+import reactNative from '@hypersolid-dev/eslint-config/react-native';
+
+export default [...base({ tsconfigRootDir: import.meta.dirname }), ...reactNative()];
+```
+
+`react-native` bans browser globals that don't exist on React Native (`document`, `localStorage`, …), and ignores `.expo`, `android`, `ios` and `expo-env.d.ts`.
+
+### Next.js
+
+```js
+import base from '@hypersolid-dev/eslint-config/base';
+import next from '@hypersolid-dev/eslint-config/next';
+import react from '@hypersolid-dev/eslint-config/react';
+
+export default [...base({ tsconfigRootDir: import.meta.dirname }), ...react(), ...next()];
+```
+
+## Overriding rules
+
+Add your own config objects after the presets. A later object wins for the files it matches.
+
+```js
+import base from '@hypersolid-dev/eslint-config/base';
+
+export default [
+  ...base({ tsconfigRootDir: import.meta.dirname }),
+  {
+    rules: {
+      // Turn a rule off everywhere.
+      'unicorn/consistent-boolean-name': 'off',
+      // Change a rule's options; restate the severity.
+      curly: ['error', 'all'],
+    },
+  },
+  {
+    // Relax rules for one part of the project.
+    files: ['scripts/**'],
+    rules: {
+      'no-console': 'off',
+    },
+  },
+];
+```
+
+A rule's options are replaced, not merged. For example, overriding `no-restricted-globals` drops the presets' entries (`isNaN`, `isFinite`, and the browser globals in `react-native`), so repeat any you want to keep.
+
+To ignore files, add an object with only `ignores`:
+
+```js
+export default [...base({ tsconfigRootDir: import.meta.dirname }), { ignores: ['generated/**'] }];
+```
+
+`base` already ignores `node_modules`, `dist`, `build`, `coverage` and lockfiles.
+
+## Formatting and import order
+
+This config has no formatting or stylistic rules, and it doesn't sort imports (`import-x/order` is off). Use a formatter such as Prettier or Biome for both.
+
+## Root config files
+
+Root files such as `eslint.config.js` or `vite.config.ts` are often outside the tsconfig's `include`. `base` lints `*.config.{js,mjs,cjs,ts,mts,cts}` in the project root with a default project, so they don't need to be in your tsconfig.
+
+## Known issues
+
+- `eslint-plugin-jsx-a11y` (used by `react`) declares support for ESLint 9 only. It works on ESLint 10, but installing prints a peer-dependency warning, and installs with `strict-peer-dependencies` fail.
+- In `next`, `@next/next/no-html-link-for-pages` prints "Pages directory cannot be found" on App Router projects. Turn it off if you don't use the `pages` directory:
+
+  ```js
+  { rules: { '@next/next/no-html-link-for-pages': 'off' } }
+  ```
+
+## Development
+
+```bash
+pnpm install --ignore-scripts
+```
+
+```bash
+pnpm lint
+```
+
+```bash
+pnpm test
+```
+
+`pnpm lint` builds the package and lints this repo with its own `base` preset. `pnpm test` runs fixture tests: for each preset, every invalid fixture in `test/fixtures/<preset>/invalid` must trigger the rule it's named after, and the valid fixtures must produce no messages. See [AGENTS.md](AGENTS.md) for conventions.
+
+## Versioning
+
+Releases follow [semver](https://semver.org/) and are published from CI on every merge to `main`, with the version derived from [Conventional Commits](https://www.conventionalcommits.org/). A new or stricter rule is a major release, because it can fail your lint run. See [CHANGELOG.md](CHANGELOG.md) for what changed in each version.

package/dist/base.d.ts

@@ -0,0 +1,6 @@
+import type { Linter } from 'eslint';
+export type BaseOptions = {
+    /** Directory of the consumer's tsconfig, usually `import.meta.dirname`. */
+    tsconfigRootDir: string;
+};
+export default function base(options: BaseOptions): Linter.Config[];

package/dist/base.js

@@ -0,0 +1,121 @@
+import js from '@eslint/js';
+import json from '@eslint/json';
+import { createTypeScriptImportResolver } from 'eslint-import-resolver-typescript';
+import { createNodeResolver, flatConfigs as importX } from 'eslint-plugin-import-x';
+import noSecrets from 'eslint-plugin-no-secrets';
+import unicorn from 'eslint-plugin-unicorn';
+import { configs as tsConfigs } from 'typescript-eslint';
+import { CODE_FILES, NUMBER_GLOBAL_RESTRICTIONS, raiseWarnings, scopeToCode } from './shared.js';
+export default function base(options) {
+    if (!options.tsconfigRootDir) {
+        throw new Error('@hypersolid-dev/eslint-config: base() requires tsconfigRootDir');
+    }
+    return raiseWarnings([
+        {
+            name: '@hypersolid-dev/base/ignores',
+            ignores: ['**/node_modules', '**/dist', '**/build', '**/coverage', '**/pnpm-lock.yaml', '**/package-lock.json', '**/yarn.lock'],
+        },
+        ...scopeToCode([
+            // ESLint's own bug-catching rules. Bad: `if (x = 1)`, `const a = 1; const a = 2;`.
+            js.configs.recommended,
+            // Type-aware TypeScript rules, the strict set. Bad: `const n: any = data; n.foo()`, `if (alwaysTrue)`.
+            ...tsConfigs.strictTypeChecked,
+            // Unicorn's recommended set minus its taste rules (file naming, `no-null`, `no-array-reduce`,
+            // abbreviations, formatting); what remains catches bugs and outdated APIs.
+            // Bad: `array.indexOf(x) !== -1` (use `includes`), `new Error()` without a message.
+            unicorn.configs.unopinionated,
+            // Import mistakes. Bad: `import { missing } from './module.js'`, importing the same module twice.
+            importX.recommended,
+            // Makes import-x understand TypeScript files and `import type`.
+            importX.typescript,
+        ]),
+        {
+            name: '@hypersolid-dev/base',
+            files: CODE_FILES,
+            languageOptions: {
+                parserOptions: {
+                    // Root config files usually sit outside the tsconfig's `include`.
+                    projectService: { allowDefaultProject: ['*.config.{js,mjs,cjs,ts,mts,cts}'] },
+                    tsconfigRootDir: options.tsconfigRootDir,
+                },
+            },
+            plugins: { 'no-secrets': noSecrets },
+            settings: {
+                'import-x/resolver-next': [createTypeScriptImportResolver(), createNodeResolver()],
+            },
+            rules: {
+                // Braces on any multi-line body. Bad: `if (a)\n  return 1;`.
+                curly: ['error', 'multi-line'],
+                // Strict equality only, `null` included. Bad: `a == b`.
+                eqeqeq: ['error', 'always'],
+                // No leftover debug output. Bad: `console.log(user)`.
+                'no-console': 'error',
+                // One ternary per expression. Bad: `a ? 'x' : b ? 'y' : 'z'`.
+                'no-nested-ternary': 'error',
+                // Arrow functions as callbacks. Bad: `list.map(function (x) { return x; })`.
+                'prefer-arrow-callback': 'error',
+                // A rethrow keeps the original error as `cause`. Bad: `catch (error) { throw new Error('failed'); }`.
+                'preserve-caught-error': 'error',
+                // The coercing globals. Bad: `isNaN('x')` (use `Number.isNaN`).
+                'no-restricted-globals': ['error', ...NUMBER_GLOBAL_RESTRICTIONS],
+                // `type` over `interface`. Bad: `interface User { name: string }`.
+                '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
+                // Every promise is awaited or handled; `void` does not count. Bad: `save();`, `void save();`.
+                '@typescript-eslint/no-floating-promises': ['error', { ignoreVoid: false }],
+                // Type-only imports use `import type`, so nothing is loaded at runtime. Bad: `import { type User } from './user.js'`.
+                '@typescript-eslint/no-import-type-side-effects': 'error',
+                // `??` over `||` for defaults, so `0` and `''` survive. Bad: `count || 10`.
+                '@typescript-eslint/prefer-nullish-coalescing': 'error',
+                // `sort()` needs a comparator; the default sorts numbers as strings. Bad: `[10, 9].sort()`.
+                '@typescript-eslint/require-array-sort-compare': 'error',
+                // No value returned where `void` is expected. Bad: `run(() => 1)` with `run(callback: () => void)`.
+                '@typescript-eslint/strict-void-return': ['error', { allowReturnAny: true }],
+                // A `switch` on a union handles every member. Bad: `switch (shape) { case 'circle': … }` missing `'square'`.
+                '@typescript-eslint/switch-exhaustiveness-check': 'error',
+                // The caught value is named `error`. Bad: `catch (e)`.
+                'unicorn/catch-error-name': 'error',
+                // A boolean reads as a claim. Bad: `const visible = true` (use `isVisible`).
+                'unicorn/consistent-boolean-name': ['error', { checkFunctions: 'never' }],
+                // A compound word is one word. Bad: `callBack`, `dataBase`.
+                'unicorn/consistent-compound-words': 'error',
+                // No non-standard abbreviations. Bad: `btn`, `cfg`. Allowed: `props`, `args`, `fn`, `ref`, `env`, `params`.
+                'unicorn/name-replacements': [
+                    'error',
+                    { replacements: { props: false, args: false, fn: false, ref: false, env: false, params: false } },
+                ],
+                // A verb prefix promises a function. Bad: `const getUser = { name: 'Ada' }`.
+                'unicorn/no-non-function-verb-prefix': 'error',
+                // `finally` does not wait for an async callback. Bad: `promise.finally(async () => { await close(); })`.
+                'unicorn/no-async-promise-finally': 'error',
+                // `await` inside `Promise.all` runs the calls one by one. Bad: `Promise.all([await a, await b])`.
+                'unicorn/no-await-in-promise-methods': 'error',
+                // Only the first resolve/reject counts. Bad: `new Promise((resolve) => { resolve(1); resolve(2); })`.
+                'unicorn/no-multiple-promise-resolver-calls': 'error',
+                // `Promise.all` around one promise. Bad: `Promise.all([fetchUser()])`.
+                'unicorn/no-single-promise-in-promise-methods': 'error',
+                // A `then` property makes `await` treat the object as a promise. Bad: `const task = { then() {} }`.
+                'unicorn/no-thenable': 'error',
+                // `.value` exists only on fulfilled results. Bad: `(await Promise.allSettled(list)).map((result) => result.value)`.
+                'unicorn/no-unsafe-promise-all-settled-values': 'error',
+                // An async function already wraps its return value. Bad: `async () => Promise.resolve(1)`.
+                'unicorn/no-useless-promise-resolve-reject': 'error',
+                // Import order is formatting, out of scope (AGENTS.md).
+                'import-x/order': 'off',
+                // High-entropy strings that look like credentials. Bad: `const token = 'ghp_Zx8kQ2vLm9…'`.
+                'no-secrets/no-secrets': 'error',
+            },
+        },
+        {
+            name: '@hypersolid-dev/base/json',
+            files: ['**/*.json'],
+            language: 'json/json',
+            plugins: { json, 'no-secrets': noSecrets },
+            rules: {
+                // JSON correctness. Bad: `{ "name": "a", "name": "b" }`.
+                ...json.configs.recommended.rules,
+                // Letters-only strings are keys and words (`verbatimModuleSyntax`), not credentials.
+                'no-secrets/no-secrets': ['error', { ignoreContent: ['^[A-Za-z]+$'] }],
+            },
+        },
+    ]);
+}

package/dist/next.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export default function next(): Linter.Config[];

package/dist/next.js

@@ -0,0 +1,16 @@
+import nextPlugin from '@next/eslint-plugin-next';
+import { raiseWarnings, scopeToCode } from './shared.js';
+// eslint-disable-next-line import-x/no-named-as-default-member -- CommonJS: its types list a named `configs` export that Node cannot import from ESM.
+const { configs: nextConfigs } = nextPlugin;
+export default function next() {
+    return raiseWarnings([
+        {
+            name: '@hypersolid-dev/next/ignores',
+            ignores: ['**/.next', '**/out'],
+        },
+        ...scopeToCode([
+            // Next.js rules, `recommended` plus the Core Web Vitals ones. Bad: `<img src={src} />` (use `next/image`), `<script src={url} />` without `async`.
+            nextConfigs['core-web-vitals'],
+        ]),
+    ]);
+}

package/dist/node.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export default function node(): Linter.Config[];

package/dist/node.js

@@ -0,0 +1,12 @@
+import globals from 'globals';
+import { CODE_FILES } from './shared.js';
+export default function node() {
+    return [
+        {
+            name: '@hypersolid-dev/node/globals',
+            files: CODE_FILES,
+            // Node's globals (`process`, `Buffer`, `__dirname`) for `no-undef` in JavaScript files; TypeScript files get them from `@types/node`.
+            languageOptions: { globals: globals.node },
+        },
+    ];
+}

package/dist/react-native.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export default function reactNative(): Linter.Config[];

package/dist/react-native.js

@@ -0,0 +1,54 @@
+import globals from 'globals';
+import { CODE_FILES, NUMBER_GLOBAL_RESTRICTIONS, raiseWarnings, reactConfigs } from './shared.js';
+// Derived instead of hardcoded: the frozen `confusing-browser-globals` list (last released 2021) misses `document`,
+// `localStorage` and `getComputedStyle`, and bans `self`, which React Native defines. `globals` is maintained,
+// so new browser APIs are picked up without editing this file.
+// Globals Hermes provides that `globals['react-native']` does not list yet; remove a name once `globals` adds it.
+const HERMES_GLOBALS = new Set(['atob', 'btoa', 'TextEncoder']);
+const BROWSER_GLOBALS = Object.keys(globals.browser).filter((name) => !(name in globals['react-native']) && !HERMES_GLOBALS.has(name));
+export default function reactNative() {
+    return raiseWarnings([
+        {
+            name: '@hypersolid-dev/react-native/ignores',
+            ignores: ['**/.expo', '**/android', '**/ios', '**/expo-env.d.ts'],
+        },
+        ...reactConfigs(),
+        {
+            name: '@hypersolid-dev/react-native',
+            files: CODE_FILES,
+            rules: {
+                // Browser globals React Native lacks, and the coercing number globals. Bad: `document.title`, `isNaN(value)`.
+                'no-restricted-globals': [
+                    'error',
+                    ...NUMBER_GLOBAL_RESTRICTIONS,
+                    ...BROWSER_GLOBALS.map((name) => ({
+                        name,
+                        message: `\`${name}\` is a browser global, undefined on React Native: a local of that name was meant, or the value comes from a React Native API.`,
+                    })),
+                ],
+                // Unicorn rules that push toward APIs the React Native runtime lacks (Hermes in RN 0.85 and RN's fetch/Blob/URL
+                // polyfills); the suggested fix crashes at runtime. Re-check when RN bumps Hermes.
+                // `toSorted` is missing from Hermes. Bad: `values.toSorted(compare)` suggested for `values.sort(compare)`.
+                'unicorn/no-array-sort': 'off',
+                // Iterator helpers are missing from Hermes. Bad: `map.values().map(double).toArray()`.
+                'unicorn/prefer-iterator-helpers': 'off',
+                // Iterator helpers are missing from Hermes. Bad: `iterator.map(double).toArray()` reordering.
+                'unicorn/prefer-iterator-to-array-at-end': 'off',
+                // `Promise.withResolvers` is missing from Hermes. Bad: `const { promise, resolve } = Promise.withResolvers()`.
+                'unicorn/prefer-promise-with-resolvers': 'off',
+                // `structuredClone` is not a React Native global. Bad: `structuredClone(value)`.
+                'unicorn/prefer-structured-clone': 'off',
+                // React Native's `URL` has no `canParse`. Bad: `URL.canParse(value)`.
+                'unicorn/prefer-url-can-parse': 'off',
+                // React Native's fetch polyfill has no static `Response.json`. Bad: `Response.json(data)`.
+                'unicorn/prefer-response-static-json': 'off',
+                // React Native's `Blob` has no `text()`/`arrayBuffer()`; `FileReader` is the way. Bad: `await blob.text()`.
+                'unicorn/prefer-blob-reading-methods': 'off',
+                // `EventTarget` is not a React Native global. Bad: `class Store extends EventTarget {}`.
+                'unicorn/prefer-event-target': 'off',
+                // Metro emits CommonJS, so top-level await does not bundle. Bad: `await init();` at module scope.
+                'unicorn/prefer-top-level-await': 'off',
+            },
+        },
+    ]);
+}

package/dist/react.d.ts

@@ -0,0 +1,2 @@
+import type { Linter } from 'eslint';
+export default function react(): Linter.Config[];

package/dist/react.js

@@ -0,0 +1,17 @@
+import jsxA11y from 'eslint-plugin-jsx-a11y';
+import globals from 'globals';
+import { CODE_FILES, raiseWarnings, reactConfigs, scopeToCode } from './shared.js';
+export default function react() {
+    return raiseWarnings([
+        ...reactConfigs(),
+        ...scopeToCode([
+            // Accessible markup. Bad: `<img src={src} />` without `alt`, `<div onClick={open}>` without a role.
+            jsxA11y.flatConfigs.recommended,
+        ]),
+        {
+            name: '@hypersolid-dev/react/globals',
+            files: CODE_FILES,
+            languageOptions: { globals: globals.browser },
+        },
+    ]);
+}

package/dist/shared.d.ts

@@ -0,0 +1,9 @@
+import type { Linter } from 'eslint';
+export declare const CODE_FILES: string[];
+export declare const NUMBER_GLOBAL_RESTRICTIONS: {
+    name: string;
+    message: string;
+}[];
+export declare function raiseWarnings(configs: Linter.Config[]): Linter.Config[];
+export declare function scopeToCode(configs: readonly Linter.Config[]): Linter.Config[];
+export declare function reactConfigs(): Linter.Config[];

package/dist/shared.js

@@ -0,0 +1,58 @@
+import eslintReact from '@eslint-react/eslint-plugin';
+import reactHooks from 'eslint-plugin-react-hooks';
+export const CODE_FILES = ['**/*.{js,mjs,cjs,jsx,ts,mts,cts,tsx}'];
+// Shared by every preset that sets `no-restricted-globals`: a later config replaces the rule's options, not merges them.
+export const NUMBER_GLOBAL_RESTRICTIONS = ['isFinite', 'isNaN'].map((name) => ({
+    name,
+    message: `Use Number.${name}; the global coerces its argument.`,
+}));
+// Every enabled rule is an error: a warning is either worth fixing or not worth reporting.
+export function raiseWarnings(configs) {
+    return configs.map((config) => {
+        if (!config.rules) {
+            return config;
+        }
+        const rules = {};
+        for (const [name, entry] of Object.entries(config.rules)) {
+            if (entry === undefined) {
+                continue;
+            }
+            const [severity, ...ruleOptions] = Array.isArray(entry) ? entry : [entry];
+            rules[name] = severity === 'warn' || severity === 1 ? ['error', ...ruleOptions] : entry;
+        }
+        return { ...config, rules };
+    });
+}
+export function scopeToCode(configs) {
+    return configs.map((config) => ({ files: CODE_FILES, ...config }));
+}
+// The React block shared by `react` and `react-native`.
+export function reactConfigs() {
+    return [
+        ...scopeToCode([
+            // React correctness for TypeScript projects. Bad: `this.state.count = 1`, `<li>` in a `.map()` without `key`.
+            eslintReact.configs['recommended-typescript'],
+            // Turns off @eslint-react's own hooks rules so react-hooks (below) is the one source for them.
+            eslintReact.configs['disable-conflict-eslint-plugin-react-hooks'],
+            // The official hooks rules plus the React Compiler checks. Bad: `if (isOpen) useEffect(…)`, a missing effect dependency.
+            reactHooks.configs.flat['recommended-latest'],
+        ]),
+        {
+            name: '@hypersolid-dev/react',
+            files: CODE_FILES,
+            languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+            rules: {
+                // A component defined inside another remounts on every render. Bad: `function List() { function Row() {…} return <Row />; }`.
+                '@eslint-react/no-nested-component-definitions': 'error',
+                // List items need a `key`. Bad: `items.map((item) => <Row item={item} />)`.
+                '@eslint-react/no-missing-key': 'error',
+                // Sibling keys are unique. Bad: `<Row key="a" /><Row key="a" />`.
+                '@eslint-react/no-duplicate-key': 'error',
+                // An index key breaks state when the list reorders. Bad: `items.map((item, index) => <Row key={index} />)`.
+                '@eslint-react/no-array-index-key': 'error',
+                // A new context value each render re-renders every consumer. Bad: `<Context value={{ user }}>`.
+                '@eslint-react/no-unstable-context-value': 'error',
+            },
+        },
+    ];
+}

package/package.json

@@ -1,6 +1,85 @@
 {
   "name": "@hypersolid-dev/eslint-config",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Shared ESLint flat config for Hypersolid TypeScript projects",
+  "license": "MIT",
+  "keywords": [
+    "eslint",
+    "eslint-config",
+    "eslintconfig",
+    "flat-config",
+    "typescript",
+    "react",
+    "react-native",
+    "next",
+    "node"
+  ],
+  "type": "module",
+  "exports": {
+    "./base": {
+      "types": "./dist/base.d.ts",
+      "default": "./dist/base.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
+    },
+    "./react-native": {
+      "types": "./dist/react-native.d.ts",
+      "default": "./dist/react-native.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "default": "./dist/next.js"
+    }
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@10.32.1",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "lint": "pnpm build && eslint .",
+    "test": "pnpm build && node --test 'test/*.test.ts'",
+    "prepublishOnly": "pnpm test"
+  },
+  "peerDependencies": {
+    "eslint": "^10.4.0",
+    "typescript": ">=5.8 <6.1"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^7.0.0",
+    "@semantic-release/git": "^11.0.1",
+    "@types/node": "^24.19.2",
+    "@types/react": "^19.3.0",
+    "conventional-changelog-conventionalcommits": "^9.3.1",
+    "eslint": "^10.14.0",
+    "semantic-release": "^25.0.9",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@eslint-react/eslint-plugin": "^5.28.8",
+    "@eslint/js": "^10.0.1",
+    "@eslint/json": "^2.1.1",
+    "@next/eslint-plugin-next": "^16.4.3",
+    "eslint-import-resolver-typescript": "^4.4.5",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
+    "eslint-plugin-no-secrets": "^2.3.3",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-unicorn": "^79.0.0",
+    "globals": "^17.13.0",
+    "typescript-eslint": "^8.72.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}