@ttsc/lint 0.13.1 → 0.14.0-dev.20260528.1

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

@@ -0,0 +1,188 @@
+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,51 @@
+import type { ITtscLintReactPerfRuleOptions } from "./ITtscLintReactPerfRuleOptions";
+import type { TtscLintRuleOptionsSetting } from "../TtscLintRuleSetting";
+/**
+ * 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,39 @@
+/**
+ * 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,12 @@
+"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;;;;;;;;GAQG"}

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

@@ -0,0 +1,289 @@
+import type { ITtscLintReactOnlyExportComponentsRuleOptions } from "./ITtscLintReactRuleOptions";
+import type { TtscLintRuleOptionsSetting, TtscLintRuleSetting } from "../TtscLintRuleSetting";
+/**
+ * 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":""}