@ttsc/lint 0.13.0 → 0.14.0-dev.20250530.1

package/lib/structures/rules/ITtscLintPromiseRules.d.ts

@@ -0,0 +1,179 @@
+import type { TtscLintRuleSetting } from "../TtscLintRuleSetting";
+/**
+ * Promise correctness and style rules from `eslint-plugin-promise`.
+ *
+ * Checks the chain shape of Promise-using code: every chain ends with `catch`,
+ * no callback inside a `then`, no nested `.then().then()`, and so on.
+ *
+ * AST-local only — type-aware Promise checks belong with `typescript/*` checker
+ * rules.
+ *
+ * @reference https://github.com/eslint-community/eslint-plugin-promise
+ */
+export interface ITtscLintPromiseRules {
+    /**
+     * Require every `then()` callback to either `return` a value or `throw`.
+     *
+     * A callback that does neither breaks the chain by returning `undefined`.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/always-return.md
+     */
+    "promise/always-return"?: TtscLintRuleSetting;
+    /**
+     * Reject every `new Promise(...)` construction. Most modern code can use
+     * `async`/`await` or existing Promise-returning APIs.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/avoid-new.md
+     */
+    "promise/avoid-new"?: TtscLintRuleSetting;
+    /**
+     * Require unreturned promise chains to terminate with `catch()` so unhandled
+     * rejections cannot escape.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/catch-or-return.md
+     */
+    "promise/catch-or-return"?: TtscLintRuleSetting;
+    /**
+     * Reject direct invocation of an error-first callback inside a `then()` or
+     * `catch()` handler.
+     *
+     * Synchronously calling the callback from a promise handler can re-enter it
+     * on both the fulfilled and rejected paths. Upstream guidance: defer via
+     * `setImmediate`/`process.nextTick` if a callback bridge is genuinely
+     * required.
+     *
+     * Also flags `.then(callback)` / `.catch(callback)` calls whose handler
+     * argument is a bare callback-shaped identifier (`callback`, `cb`, `next`,
+     * `done`).
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-callback-in-promise.md
+     */
+    "promise/no-callback-in-promise"?: TtscLintRuleSetting;
+    /**
+     * Detect Promise executor bodies with more than one resolve/reject call. The
+     * native rule does not yet model branch exclusivity — bodies whose calls are
+     * split across mutually exclusive branches will be flagged too.
+     *
+     * The second call is silently ignored, but the surrounding logic almost
+     * always assumed short-circuit.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-multiple-resolved.md
+     */
+    "promise/no-multiple-resolved"?: TtscLintRuleSetting;
+    /**
+     * Require every file that uses `Promise` to import or require the
+     * implementation explicitly, instead of reaching the native global.
+     *
+     * Useful for projects that substitute Bluebird or another library and want
+     * the choice grep-visible per file.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-native.md
+     */
+    "promise/no-native"?: TtscLintRuleSetting;
+    /**
+     * Reject nested `then()`/`catch()` calls inside the body of a Promise
+     * callback. Use chained `.then()` instead.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-nesting.md
+     */
+    "promise/no-nesting"?: TtscLintRuleSetting;
+    /**
+     * Reject `new` applied to Promise statics such as `new Promise.resolve(x)`,
+     * `new Promise.all([...])`, or `new Promise.race([...])`.
+     *
+     * The statics are plain functions, so `new` throws a `TypeError` at runtime —
+     * caught here before the call ships.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-new-statics.md
+     */
+    "promise/no-new-statics"?: TtscLintRuleSetting;
+    /**
+     * Reject building a promise chain inside the body of an error-first callback.
+     *
+     * The callback already owns an error channel, so layering
+     * `.then()`/`.catch()` on top creates two incompatible failure pipelines.
+     * Upstream advice: promisify the outer API instead.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-promise-in-callback.md
+     */
+    "promise/no-promise-in-callback"?: TtscLintRuleSetting;
+    /**
+     * Reject `return` from inside a `finally()` callback.
+     *
+     * The chain's resolved value comes from the prior `then`/`catch`, so any
+     * value returned from `finally` is discarded — usually signals confusion
+     * about where the chain's value comes from.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-in-finally.md
+     */
+    "promise/no-return-in-finally"?: TtscLintRuleSetting;
+    /**
+     * Reject `return Promise.resolve(x)` and `return Promise.reject(x)` inside
+     * promise callbacks; return the bare value or `throw` instead.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-wrap.md
+     */
+    "promise/no-return-wrap"?: TtscLintRuleSetting;
+    /**
+     * Enforce canonical parameter names (`resolve`, `reject`) on Promise executor
+     * functions.
+     *
+     * Consistent names make executor bodies greppable and prevent accidental
+     * shadowing of the outer `resolve` symbol.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/param-names.md
+     */
+    "promise/param-names"?: TtscLintRuleSetting;
+    /**
+     * Flag continuation-passing callback shapes (last parameter is a function and
+     * an error-first invocation pattern is detected), suggesting an
+     * `async`/`await` rewrite.
+     *
+     * Intended for codebases that have already migrated their I/O surface to
+     * promises and want to keep callers consistent.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-callbacks.md
+     */
+    "promise/prefer-await-to-callbacks"?: TtscLintRuleSetting;
+    /**
+     * Prefer `await` over explicit `.then()`/`.catch()`/`.finally()` chains
+     * inside `async` functions.
+     *
+     * Sequential awaits compose more naturally with try/catch and avoid the
+     * indentation creep of deeply nested handlers.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-then.md
+     */
+    "promise/prefer-await-to-then"?: TtscLintRuleSetting;
+    /**
+     * Prefer `.catch(handler)` over the two-argument form `.then(onFulfilled,
+     * onRejected)`.
+     *
+     * The two-argument shape skips rejections raised inside `onFulfilled`, which
+     * surprises readers and hides errors from logging middleware.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-catch.md
+     */
+    "promise/prefer-catch"?: TtscLintRuleSetting;
+    /**
+     * Reject non-standard `Promise` statics such as `Promise.done`,
+     * `Promise.spread`, or library-specific extensions shimmed onto the global.
+     *
+     * Sticking to spec methods keeps code portable across Promise
+     * implementations.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/spec-only.md
+     */
+    "promise/spec-only"?: TtscLintRuleSetting;
+    /**
+     * Enforce the argument counts the Promise spec defines for each method —
+     * `Promise.all`/`Promise.race` take exactly one argument,
+     * `Promise.resolve`/`Promise.reject` take zero or one, `.then` takes one or
+     * two, `.catch`/`.finally` take exactly one.
+     *
+     * Extra or missing arguments usually indicate a misread of the API.
+     *
+     * @reference https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/valid-params.md
+     */
+    "promise/valid-params"?: TtscLintRuleSetting;
+}

package/lib/structures/rules/ITtscLintPromiseRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintPromiseRules.js.map

package/lib/structures/rules/ITtscLintPromiseRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintPromiseRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintPromiseRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/ITtscLintReactPerfRuleOptions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared options shape for every rule in {@link ITtscLintReactPerfRules}.
+ *
+ * @reference https://github.com/cvazac/eslint-plugin-react-perf
+ */
+/** `react-perf/*` rule options. */
+export interface ITtscLintReactPerfRuleOptions {
+    /**
+     * Controls which intrinsic JSX element props are ignored.
+     *
+     * `"all"` ignores every prop on lowercase / native elements such as `div`. An
+     * array ignores only those prop names on native elements, for example
+     * `["style"]`. Custom components are still checked.
+     *
+     * @default [ ] (native props are checked)
+     */
+    nativeAllowList?: "all" | readonly string[];
+}

package/lib/structures/rules/ITtscLintReactPerfRuleOptions.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Shared options shape for every rule in {@link ITtscLintReactPerfRules}.
+ *
+ * @reference https://github.com/cvazac/eslint-plugin-react-perf
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintReactPerfRuleOptions.js.map

package/lib/structures/rules/ITtscLintReactPerfRuleOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintReactPerfRuleOptions.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintReactPerfRuleOptions.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/lib/structures/rules/ITtscLintReactPerfRules.d.ts

@@ -0,0 +1,49 @@
+import type { TtscLintRuleOptionsSetting } from "../TtscLintRuleSetting";
+import type { ITtscLintReactPerfRuleOptions } from "./ITtscLintReactPerfRuleOptions";
+/**
+ * React JSX performance rules from `eslint-plugin-react-perf`.
+ *
+ * Detects freshly-allocated reference values (arrays, objects, functions, JSX
+ * elements) passed as JSX props. A new reference invalidates `React.memo` /
+ * `useMemo` shallow checks on every render. Useful for performance-critical
+ * render paths; usually unnecessary for top-level pages.
+ *
+ * Diagnostics only fire on `.tsx` source files — JSX heuristics rely on the
+ * file extension, so `.ts` files are skipped even when they contain JSX-like
+ * syntax.
+ *
+ * @reference https://github.com/cvazac/eslint-plugin-react-perf
+ */
+export interface ITtscLintReactPerfRules {
+    /**
+     * Reject array literals (`[...]`) passed inline as a JSX prop. Hoist the
+     * array outside the render or stabilize it with `useMemo`.
+     *
+     * @reference https://github.com/cvazac/eslint-plugin-react-perf/blob/master/docs/rules/jsx-no-new-array-as-prop.md
+     */
+    "react-perf/jsx-no-new-array-as-prop"?: TtscLintRuleOptionsSetting<ITtscLintReactPerfRuleOptions>;
+    /**
+     * Reject inline `function` expressions / arrow functions passed as a JSX
+     * prop. Stabilize with `useCallback`.
+     *
+     * @reference https://github.com/cvazac/eslint-plugin-react-perf/blob/master/docs/rules/jsx-no-new-function-as-prop.md
+     */
+    "react-perf/jsx-no-new-function-as-prop"?: TtscLintRuleOptionsSetting<ITtscLintReactPerfRuleOptions>;
+    /**
+     * Reject inline object literals (`{...}`) passed as a JSX prop.
+     *
+     * A fresh object on every render invalidates the shallow-equal check used by
+     * `React.memo` and `useMemo` consumers, so any downstream memoization keyed
+     * on that prop is wasted.
+     *
+     * @reference https://github.com/cvazac/eslint-plugin-react-perf/blob/master/docs/rules/jsx-no-new-object-as-prop.md
+     */
+    "react-perf/jsx-no-new-object-as-prop"?: TtscLintRuleOptionsSetting<ITtscLintReactPerfRuleOptions>;
+    /**
+     * Reject JSX expressions and fragments passed as a JSX prop — each evaluation
+     * creates a new React element.
+     *
+     * @reference https://github.com/cvazac/eslint-plugin-react-perf/blob/master/docs/rules/jsx-no-jsx-as-prop.md
+     */
+    "react-perf/jsx-no-jsx-as-prop"?: TtscLintRuleOptionsSetting<ITtscLintReactPerfRuleOptions>;
+}

package/lib/structures/rules/ITtscLintReactPerfRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintReactPerfRules.js.map

package/lib/structures/rules/ITtscLintReactPerfRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintReactPerfRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintReactPerfRules.ts"],"names":[],"mappings":""}

package/lib/structures/rules/ITtscLintReactRuleOptions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Options shapes for the configurable rules in {@link ITtscLintReactRules}.
+ *
+ * Currently only `react/only-export-components` (from
+ * `eslint-plugin-react-refresh`) accepts options.
+ *
+ * @reference https://github.com/ArnaudBarre/eslint-plugin-react-refresh
+ */
+/** `react/only-export-components` rule options. */
+export interface ITtscLintReactOnlyExportComponentsRuleOptions {
+    /**
+     * Extra higher-order component names that wrap component exports.
+     *
+     * @default [ ]
+     */
+    extraHOCs?: readonly string[];
+    /**
+     * Export names the active framework handles during refresh, such as route
+     * metadata exports.
+     *
+     * @default [ ]
+     */
+    allowExportNames?: readonly string[];
+    /**
+     * Permit literal / string / boolean / template / binary constant exports
+     * alongside component exports.
+     *
+     * @default false
+     */
+    allowConstantExport?: boolean;
+    /**
+     * Also scan JavaScript files that import React. TSX files are always scanned.
+     *
+     * @default false
+     */
+    checkJS?: boolean;
+}

package/lib/structures/rules/ITtscLintReactRuleOptions.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Options shapes for the configurable rules in {@link ITtscLintReactRules}.
+ *
+ * Currently only `react/only-export-components` (from
+ * `eslint-plugin-react-refresh`) accepts options.
+ *
+ * @reference https://github.com/ArnaudBarre/eslint-plugin-react-refresh
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintReactRuleOptions.js.map

package/lib/structures/rules/ITtscLintReactRuleOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintReactRuleOptions.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintReactRuleOptions.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG"}

package/lib/structures/rules/ITtscLintReactRules.d.ts

@@ -0,0 +1,276 @@
+import type { TtscLintRuleOptionsSetting, TtscLintRuleSetting } from "../TtscLintRuleSetting";
+import type { ITtscLintReactOnlyExportComponentsRuleOptions } from "./ITtscLintReactRuleOptions";
+/**
+ * React TSX rules.
+ *
+ * Bundles rules from `eslint-plugin-react`, `eslint-plugin-react-hooks`, and
+ * `eslint-plugin-react-refresh` under one namespace, matching Oxlint's
+ * `react/*` plugin layout. Performance-only rules live in a separate
+ * {@link ITtscLintReactPerfRules} family because they are opt-in toggles rather
+ * than correctness checks.
+ *
+ * @reference https://github.com/jsx-eslint/eslint-plugin-react
+ */
+export interface ITtscLintReactRules {
+    /**
+     * Require explicit, valid `type` values on JSX `<button>` elements
+     * (`"button"`, `"submit"`, `"reset"`) — the HTML default of `"submit"` causes
+     * accidental form submissions.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/button-has-type.md
+     */
+    "react/button-has-type"?: TtscLintRuleSetting;
+    /**
+     * Require components wrapped in `React.memo(...)` or `React.forwardRef(...)`
+     * to be named — either by passing a named function, assigning the call to a
+     * named binding, or setting an explicit `displayName`.
+     *
+     * Anonymous wrappers leave the resulting component nameless in React DevTools
+     * and runtime stack frames.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/display-name.md
+     */
+    "react/display-name"?: TtscLintRuleSetting;
+    /**
+     * Detect high-confidence missing identifiers in React Hook dependency arrays
+     * (`useEffect`, `useLayoutEffect`, `useInsertionEffect`, `useMemo`,
+     * `useCallback`).
+     *
+     * @reference https://react.dev/reference/react/useEffect#specifying-reactive-dependencies
+     */
+    "react/exhaustive-deps"?: TtscLintRuleSetting;
+    /**
+     * Reject declaring a component or custom Hook inside another component or
+     * Hook body.
+     *
+     * Each render rebuilds the inner function, giving it a new identity that
+     * discards its state and breaks memoization.
+     *
+     * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+     */
+    "react/component-hook-factories"?: TtscLintRuleSetting;
+    /**
+     * Require JSX `<iframe>` elements to declare a `sandbox` attribute, which
+     * restricts what embedded content can do (scripts, forms, navigation).
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/iframe-missing-sandbox.md
+     */
+    "react/iframe-missing-sandbox"?: TtscLintRuleSetting;
+    /**
+     * Reject mutating props, state, or Hook return values inside a component or
+     * Hook.
+     *
+     * React treats these as read-only; mutating a memoized value can desync
+     * renders from the dependencies React tracked it under.
+     *
+     * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+     */
+    "react/immutability"?: TtscLintRuleSetting;
+    /**
+     * Require `key` props on JSX elements produced from arrays or `.map(...)`
+     * calls — React uses the key to track list identity across renders.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-key.md
+     */
+    "react/jsx-key"?: TtscLintRuleSetting;
+    /**
+     * Reject duplicate JSX prop names on the same element — later occurrences
+     * silently overwrite earlier ones.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-duplicate-props.md
+     */
+    "react/jsx-no-duplicate-props"?: TtscLintRuleSetting;
+    /**
+     * Reject `javascript:` URLs in JSX URL-like props such as `href` and `src`.
+     *
+     * Such URLs evaluate the URL body as script — the same code-execution surface
+     * as `eval`, and a common XSS vector when the value is user-controlled.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-script-url.md
+     */
+    "react/jsx-no-script-url"?: TtscLintRuleSetting;
+    /**
+     * Reject `<a target="_blank">` (or any JSX element with `target="_blank"`)
+     * that does not also carry `rel="noreferrer"` (or `rel="noopener
+     * noreferrer"`).
+     *
+     * Without those tokens the opened page can navigate the originating window
+     * through `window.opener`, a phishing and tab-nabbing vector.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-target-blank.md
+     */
+    "react/jsx-no-target-blank"?: TtscLintRuleSetting;
+    /**
+     * Reject JSX elements whose tag is an uppercase identifier with no
+     * value-level declaration anywhere in the source file.
+     *
+     * Lowercase tags are intrinsic HTML; qualified `<Foo.Bar>` forms are skipped
+     * because resolving the outer name requires module-level information that
+     * belongs to the type checker.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-undef.md
+     */
+    "react/jsx-no-undef"?: TtscLintRuleSetting;
+    /**
+     * Reject JSX fragments that wrap exactly one element child or have no
+     * meaningful content — the child (or nothing) can be returned directly.
+     *
+     * Covers both the short `<>...</>` form and explicit `<Fragment>` /
+     * `<React.Fragment>` elements.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/jsx-no-useless-fragment.md
+     */
+    "react/jsx-no-useless-fragment"?: TtscLintRuleSetting;
+    /**
+     * Reject `key={index}` patterns inside JSX lists — array index keys reorder
+     * incorrectly on insertion.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-array-index-key.md
+     */
+    "react/no-array-index-key"?: TtscLintRuleSetting;
+    /**
+     * Reject passing children through an explicit `children` JSX prop.
+     *
+     * The nested-tag form is shorter, mirrors HTML, and avoids the
+     * double-children footgun where a `children` prop and nested JSX both target
+     * the same slot.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-children-prop.md
+     */
+    "react/no-children-prop"?: TtscLintRuleSetting;
+    /**
+     * Reject `dangerouslySetInnerHTML` altogether.
+     *
+     * The prop bypasses React's escaping and injects raw HTML into the DOM — a
+     * common XSS vector when the input is not sanitized upstream.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-danger.md
+     */
+    "react/no-danger"?: TtscLintRuleSetting;
+    /**
+     * Reject combining `dangerouslySetInnerHTML` with JSX children — React throws
+     * at runtime in this case.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-danger-with-children.md
+     */
+    "react/no-danger-with-children"?: TtscLintRuleSetting;
+    /**
+     * Reject direct writes to `this.state` outside constructor initialization.
+     * Use `this.setState(...)` instead.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-direct-mutation-state.md
+     */
+    "react/no-direct-mutation-state"?: TtscLintRuleSetting;
+    /**
+     * Reject `findDOMNode(...)` calls.
+     *
+     * The API is deprecated, blocks future React internals work, and breaks
+     * component abstraction by reaching across composition boundaries; attach a
+     * `ref` to the target element instead.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-find-dom-node.md
+     */
+    "react/no-find-dom-node"?: TtscLintRuleSetting;
+    /**
+     * Reject `this.isMounted()` calls on class components.
+     *
+     * The API is deprecated, and anti-patterns around it usually hide a memory
+     * leak in async callbacks; cancel the work in `componentWillUnmount`
+     * instead.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-is-mounted.md
+     */
+    "react/no-is-mounted"?: TtscLintRuleSetting;
+    /**
+     * Reject string-form JSX refs (`ref="myInput"`).
+     *
+     * The API is legacy, slated for removal, and has well-known issues with
+     * static typing, owner tracking, and stale references; use `useRef` or a
+     * callback ref instead.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-string-refs.md
+     */
+    "react/no-string-refs"?: TtscLintRuleSetting;
+    /**
+     * Reject unescaped `>`, `"`, `'`, and `}` characters in JSX text content —
+     * they render literally and almost always come from forgotten HTML escaping.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/no-unescaped-entities.md
+     */
+    "react/no-unescaped-entities"?: TtscLintRuleSetting;
+    /**
+     * Keep React Fast Refresh component modules from exporting non-component
+     * values. Mixing a component export with a constant or hook in the same file
+     * invalidates HMR.
+     *
+     * @reference https://github.com/ArnaudBarre/eslint-plugin-react-refresh/blob/main/README.md
+     */
+    "react/only-export-components"?: TtscLintRuleOptionsSetting<ITtscLintReactOnlyExportComponentsRuleOptions>;
+    /**
+     * Reject reading or writing `ref.current` during render.
+     *
+     * Refs persist mutably across renders without re-rendering, so touching them
+     * in render breaks the pure-render contract and produces inconsistent output
+     * between render passes.
+     *
+     * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+     */
+    "react/refs"?: TtscLintRuleSetting;
+    /**
+     * Enforce the Rules of Hooks: only call Hooks at the top level of a component
+     * or custom Hook, never inside conditionals, loops, or nested functions.
+     *
+     * @reference https://react.dev/reference/rules/rules-of-hooks
+     */
+    "react/rules-of-hooks"?: TtscLintRuleSetting;
+    /**
+     * Reject unconditional `setState` calls in `useEffect` bodies.
+     *
+     * The state update schedules another render and re-runs the effect, which
+     * usually loops forever; the value almost always belongs in `useMemo` or
+     * derived state instead.
+     *
+     * @reference https://react.dev/learn/you-might-not-need-an-effect
+     */
+    "react/set-state-in-effect"?: TtscLintRuleSetting;
+    /**
+     * Reject calling `setState` during render.
+     *
+     * Render must stay pure; queuing an update from the render body schedules
+     * another render that queues another update, producing an infinite render
+     * loop unless guarded by an explicit equality check.
+     *
+     * @reference https://react.dev/reference/rules/components-and-hooks-must-be-pure
+     */
+    "react/set-state-in-render"?: TtscLintRuleSetting;
+    /**
+     * Reject string-form `style` values such as `style="color: red"` or
+     * `style={\`...`}`.
+     *
+     * React expects a `{ camelCaseProp: value }` object, not the HTML-style CSS
+     * string, and the latter is silently coerced and never applied.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/style-prop-object.md
+     */
+    "react/style-prop-object"?: TtscLintRuleSetting;
+    /**
+     * Reject `useMemo` calculation callbacks that do not return a value.
+     *
+     * A block-bodied callback without `return` memoizes `undefined`, silently
+     * discarding the intended computation — a common mistake when wrapping an
+     * object literal in `{ ... }` instead of `({ ... })`.
+     *
+     * @reference https://react.dev/reference/react/useMemo
+     */
+    "react/use-memo"?: TtscLintRuleSetting;
+    /**
+     * Reject `children` or `dangerouslySetInnerHTML` on void DOM elements
+     * (`<img>`, `<br>`, `<input>`, etc.).
+     *
+     * Void elements have no content model, so React throws at render time when
+     * you try to give them any.
+     *
+     * @reference https://github.com/jsx-eslint/eslint-plugin-react/blob/master/docs/rules/void-dom-elements-no-children.md
+     */
+    "react/void-dom-elements-no-children"?: TtscLintRuleSetting;
+}

package/lib/structures/rules/ITtscLintReactRules.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ITtscLintReactRules.js.map

package/lib/structures/rules/ITtscLintReactRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITtscLintReactRules.js","sourceRoot":"","sources":["../../../src/structures/rules/ITtscLintReactRules.ts"],"names":[],"mappings":""}