oxlint-plugin-react-doctor 0.8.1-dev.6fcd9c9 → 0.8.1-dev.7818922

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +256 -992
  2. package/dist/index.js +992 -5161
  3. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -100,7 +100,7 @@ interface RuleContext extends Omit<BaseRuleContext, "getFilename"> {
100
100
  //#region src/plugin/utils/capability.d.ts
101
101
  declare const FRAMEWORK_TOKENS: readonly ["nextjs", "vite", "cra", "remix", "gatsby", "expo", "react-native", "tanstack-start", "preact", "unknown"];
102
102
  type FrameworkToken = (typeof FRAMEWORK_TOKENS)[number];
103
- type Capability = FrameworkToken | "react" | "remotion" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "nextjs:static-export" | "nextjs:15" | "tailwind" | "tailwind:3.4" | "zod" | "zod:4" | "mobx" | "mobx-react" | "mobx-react-lite" | "mobx-react-binding" | "mobx-state-tree" | "mobx-react-observer" | "zustand" | "typescript" | "react-compiler" | "tanstack-query" | "valtio" | "pre-es2023" | `react:${number}` | `preact:${number}` | `remotion:${number}` | `valtio:${number}` | `mobx:${number}` | `zustand:${number}`;
103
+ type Capability = FrameworkToken | "react" | "pure-preact" | "react-native" | "server-actions" | "ssr" | "client-only" | "nextjs:static-export" | "nextjs:15" | "tailwind" | "tailwind:3.4" | "zod" | "zod:4" | "typescript" | "react-compiler" | "tanstack-query" | "pre-es2023" | `react:${number}` | `preact:${number}`;
104
104
  type CapabilityQuery = (capability: Capability) => boolean;
105
105
  //#endregion
106
106
  //#region src/plugin/utils/file-scan.d.ts
@@ -2421,6 +2421,29 @@ declare const REACT_DOCTOR_RULES: readonly [{
2421
2421
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2422
2422
  readonly create: (context: RuleContext) => RuleVisitors;
2423
2423
  };
2424
+ }, {
2425
+ readonly key: "react-doctor/jsx-no-target-blank";
2426
+ readonly id: "jsx-no-target-blank";
2427
+ readonly source: "react-doctor";
2428
+ readonly originallyExternal: true;
2429
+ readonly rule: {
2430
+ readonly framework: "global";
2431
+ readonly category: "Security";
2432
+ readonly requires: readonly Capability[];
2433
+ readonly id: string;
2434
+ readonly title?: string;
2435
+ readonly severity: RuleSeverity;
2436
+ readonly disabledWhen?: ReadonlyArray<Capability>;
2437
+ readonly tags?: ReadonlyArray<string>;
2438
+ readonly matchByOccurrence?: boolean;
2439
+ readonly defaultEnabled?: boolean;
2440
+ readonly lifecycle?: "retired";
2441
+ readonly scan?: FileScan;
2442
+ readonly committedFilesOnly?: boolean;
2443
+ readonly recommendation?: string;
2444
+ readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2445
+ readonly create: (context: RuleContext) => RuleVisitors;
2446
+ };
2424
2447
  }, {
2425
2448
  readonly key: "react-doctor/jsx-no-undef";
2426
2449
  readonly id: "jsx-no-undef";
@@ -2720,75 +2743,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
2720
2743
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2721
2744
  readonly create: (context: RuleContext) => RuleVisitors;
2722
2745
  };
2723
- }, {
2724
- readonly key: "react-doctor/mobx-no-make-auto-observable-in-inheritance";
2725
- readonly id: "mobx-no-make-auto-observable-in-inheritance";
2726
- readonly source: "react-doctor";
2727
- readonly originallyExternal: false;
2728
- readonly rule: {
2729
- readonly framework: "global";
2730
- readonly category: "Bugs";
2731
- readonly id: string;
2732
- readonly title?: string;
2733
- readonly severity: RuleSeverity;
2734
- readonly requires?: ReadonlyArray<Capability>;
2735
- readonly disabledWhen?: ReadonlyArray<Capability>;
2736
- readonly tags?: ReadonlyArray<string>;
2737
- readonly matchByOccurrence?: boolean;
2738
- readonly defaultEnabled?: boolean;
2739
- readonly lifecycle?: "retired";
2740
- readonly scan?: FileScan;
2741
- readonly committedFilesOnly?: boolean;
2742
- readonly recommendation?: string;
2743
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2744
- readonly create: (context: RuleContext) => RuleVisitors;
2745
- };
2746
- }, {
2747
- readonly key: "react-doctor/mobx-no-observer-wrapped-memo";
2748
- readonly id: "mobx-no-observer-wrapped-memo";
2749
- readonly source: "react-doctor";
2750
- readonly originallyExternal: false;
2751
- readonly rule: {
2752
- readonly framework: "global";
2753
- readonly category: "Bugs";
2754
- readonly id: string;
2755
- readonly title?: string;
2756
- readonly severity: RuleSeverity;
2757
- readonly requires?: ReadonlyArray<Capability>;
2758
- readonly disabledWhen?: ReadonlyArray<Capability>;
2759
- readonly tags?: ReadonlyArray<string>;
2760
- readonly matchByOccurrence?: boolean;
2761
- readonly defaultEnabled?: boolean;
2762
- readonly lifecycle?: "retired";
2763
- readonly scan?: FileScan;
2764
- readonly committedFilesOnly?: boolean;
2765
- readonly recommendation?: string;
2766
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2767
- readonly create: (context: RuleContext) => RuleVisitors;
2768
- };
2769
- }, {
2770
- readonly key: "react-doctor/mobx-reaction-disposer-discarded";
2771
- readonly id: "mobx-reaction-disposer-discarded";
2772
- readonly source: "react-doctor";
2773
- readonly originallyExternal: false;
2774
- readonly rule: {
2775
- readonly framework: "global";
2776
- readonly category: "Bugs";
2777
- readonly id: string;
2778
- readonly title?: string;
2779
- readonly severity: RuleSeverity;
2780
- readonly requires?: ReadonlyArray<Capability>;
2781
- readonly disabledWhen?: ReadonlyArray<Capability>;
2782
- readonly tags?: ReadonlyArray<string>;
2783
- readonly matchByOccurrence?: boolean;
2784
- readonly defaultEnabled?: boolean;
2785
- readonly lifecycle?: "retired";
2786
- readonly scan?: FileScan;
2787
- readonly committedFilesOnly?: boolean;
2788
- readonly recommendation?: string;
2789
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2790
- readonly create: (context: RuleContext) => RuleVisitors;
2791
- };
2792
2746
  }, {
2793
2747
  readonly key: "react-doctor/mouse-events-have-key-events";
2794
2748
  readonly id: "mouse-events-have-key-events";
@@ -7137,17 +7091,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7137
7091
  readonly create: (context: RuleContext) => RuleVisitors;
7138
7092
  };
7139
7093
  }, {
7140
- readonly key: "react-doctor/remotion-calculate-metadata-fetch-signal";
7141
- readonly id: "remotion-calculate-metadata-fetch-signal";
7094
+ readonly key: "react-doctor/rendering-animate-svg-wrapper";
7095
+ readonly id: "rendering-animate-svg-wrapper";
7142
7096
  readonly source: "react-doctor";
7143
7097
  readonly originallyExternal: false;
7144
7098
  readonly rule: {
7145
7099
  readonly framework: "global";
7146
- readonly category: "Bugs";
7100
+ readonly category: "Performance";
7101
+ readonly requires: readonly Capability[];
7147
7102
  readonly id: string;
7148
7103
  readonly title?: string;
7149
7104
  readonly severity: RuleSeverity;
7150
- readonly requires?: ReadonlyArray<Capability>;
7151
7105
  readonly disabledWhen?: ReadonlyArray<Capability>;
7152
7106
  readonly tags?: ReadonlyArray<string>;
7153
7107
  readonly matchByOccurrence?: boolean;
@@ -7160,8 +7114,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7160
7114
  readonly create: (context: RuleContext) => RuleVisitors;
7161
7115
  };
7162
7116
  }, {
7163
- readonly key: "react-doctor/remotion-deterministic-randomness";
7164
- readonly id: "remotion-deterministic-randomness";
7117
+ readonly key: "react-doctor/rendering-conditional-render";
7118
+ readonly id: "rendering-conditional-render";
7165
7119
  readonly source: "react-doctor";
7166
7120
  readonly originallyExternal: false;
7167
7121
  readonly rule: {
@@ -7183,17 +7137,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7183
7137
  readonly create: (context: RuleContext) => RuleVisitors;
7184
7138
  };
7185
7139
  }, {
7186
- readonly key: "react-doctor/remotion-no-css-animation";
7187
- readonly id: "remotion-no-css-animation";
7140
+ readonly key: "react-doctor/rendering-hoist-jsx";
7141
+ readonly id: "rendering-hoist-jsx";
7188
7142
  readonly source: "react-doctor";
7189
7143
  readonly originallyExternal: false;
7190
7144
  readonly rule: {
7191
7145
  readonly framework: "global";
7192
- readonly category: "Bugs";
7146
+ readonly category: "Performance";
7147
+ readonly requires: readonly Capability[];
7193
7148
  readonly id: string;
7194
7149
  readonly title?: string;
7195
7150
  readonly severity: RuleSeverity;
7196
- readonly requires?: ReadonlyArray<Capability>;
7197
7151
  readonly disabledWhen?: ReadonlyArray<Capability>;
7198
7152
  readonly tags?: ReadonlyArray<string>;
7199
7153
  readonly matchByOccurrence?: boolean;
@@ -7206,17 +7160,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7206
7160
  readonly create: (context: RuleContext) => RuleVisitors;
7207
7161
  };
7208
7162
  }, {
7209
- readonly key: "react-doctor/remotion-no-css-transition";
7210
- readonly id: "remotion-no-css-transition";
7163
+ readonly key: "react-doctor/rendering-hydration-mismatch-time";
7164
+ readonly id: "rendering-hydration-mismatch-time";
7211
7165
  readonly source: "react-doctor";
7212
7166
  readonly originallyExternal: false;
7213
7167
  readonly rule: {
7214
7168
  readonly framework: "global";
7215
7169
  readonly category: "Bugs";
7170
+ readonly requires: readonly Capability[];
7216
7171
  readonly id: string;
7217
7172
  readonly title?: string;
7218
7173
  readonly severity: RuleSeverity;
7219
- readonly requires?: ReadonlyArray<Capability>;
7220
7174
  readonly disabledWhen?: ReadonlyArray<Capability>;
7221
7175
  readonly tags?: ReadonlyArray<string>;
7222
7176
  readonly matchByOccurrence?: boolean;
@@ -7229,17 +7183,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7229
7183
  readonly create: (context: RuleContext) => RuleVisitors;
7230
7184
  };
7231
7185
  }, {
7232
- readonly key: "react-doctor/remotion-no-css-url-assets";
7233
- readonly id: "remotion-no-css-url-assets";
7186
+ readonly key: "react-doctor/rendering-hydration-no-flicker";
7187
+ readonly id: "rendering-hydration-no-flicker";
7234
7188
  readonly source: "react-doctor";
7235
7189
  readonly originallyExternal: false;
7236
7190
  readonly rule: {
7237
7191
  readonly framework: "global";
7238
- readonly category: "Bugs";
7192
+ readonly category: "Performance";
7193
+ readonly requires: readonly Capability[];
7239
7194
  readonly id: string;
7240
7195
  readonly title?: string;
7241
7196
  readonly severity: RuleSeverity;
7242
- readonly requires?: ReadonlyArray<Capability>;
7243
7197
  readonly disabledWhen?: ReadonlyArray<Capability>;
7244
7198
  readonly tags?: ReadonlyArray<string>;
7245
7199
  readonly matchByOccurrence?: boolean;
@@ -7252,17 +7206,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7252
7206
  readonly create: (context: RuleContext) => RuleVisitors;
7253
7207
  };
7254
7208
  }, {
7255
- readonly key: "react-doctor/remotion-no-module-scope-delay-render";
7256
- readonly id: "remotion-no-module-scope-delay-render";
7209
+ readonly key: "react-doctor/rendering-script-defer-async";
7210
+ readonly id: "rendering-script-defer-async";
7257
7211
  readonly source: "react-doctor";
7258
7212
  readonly originallyExternal: false;
7259
7213
  readonly rule: {
7260
7214
  readonly framework: "global";
7261
- readonly category: "Bugs";
7215
+ readonly category: "Performance";
7216
+ readonly requires: readonly Capability[];
7262
7217
  readonly id: string;
7263
7218
  readonly title?: string;
7264
7219
  readonly severity: RuleSeverity;
7265
- readonly requires?: ReadonlyArray<Capability>;
7266
7220
  readonly disabledWhen?: ReadonlyArray<Capability>;
7267
7221
  readonly tags?: ReadonlyArray<string>;
7268
7222
  readonly matchByOccurrence?: boolean;
@@ -7275,13 +7229,13 @@ declare const REACT_DOCTOR_RULES: readonly [{
7275
7229
  readonly create: (context: RuleContext) => RuleVisitors;
7276
7230
  };
7277
7231
  }, {
7278
- readonly key: "react-doctor/remotion-no-native-media-elements";
7279
- readonly id: "remotion-no-native-media-elements";
7232
+ readonly key: "react-doctor/rendering-svg-precision";
7233
+ readonly id: "rendering-svg-precision";
7280
7234
  readonly source: "react-doctor";
7281
7235
  readonly originallyExternal: false;
7282
7236
  readonly rule: {
7283
7237
  readonly framework: "global";
7284
- readonly category: "Bugs";
7238
+ readonly category: "Performance";
7285
7239
  readonly id: string;
7286
7240
  readonly title?: string;
7287
7241
  readonly severity: RuleSeverity;
@@ -7298,17 +7252,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7298
7252
  readonly create: (context: RuleContext) => RuleVisitors;
7299
7253
  };
7300
7254
  }, {
7301
- readonly key: "react-doctor/remotion-no-next-image";
7302
- readonly id: "remotion-no-next-image";
7255
+ readonly key: "react-doctor/rendering-usetransition-loading";
7256
+ readonly id: "rendering-usetransition-loading";
7303
7257
  readonly source: "react-doctor";
7304
7258
  readonly originallyExternal: false;
7305
7259
  readonly rule: {
7306
7260
  readonly framework: "global";
7307
- readonly category: "Bugs";
7261
+ readonly category: "Performance";
7262
+ readonly requires: readonly Capability[];
7308
7263
  readonly id: string;
7309
7264
  readonly title?: string;
7310
7265
  readonly severity: RuleSeverity;
7311
- readonly requires?: ReadonlyArray<Capability>;
7312
7266
  readonly disabledWhen?: ReadonlyArray<Capability>;
7313
7267
  readonly tags?: ReadonlyArray<string>;
7314
7268
  readonly matchByOccurrence?: boolean;
@@ -7321,19 +7275,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7321
7275
  readonly create: (context: RuleContext) => RuleVisitors;
7322
7276
  };
7323
7277
  }, {
7324
- readonly key: "react-doctor/remotion-stable-delay-render-handle";
7325
- readonly id: "remotion-stable-delay-render-handle";
7278
+ readonly key: "react-doctor/repository-secret-file";
7279
+ readonly id: "repository-secret-file";
7326
7280
  readonly source: "react-doctor";
7327
7281
  readonly originallyExternal: false;
7328
7282
  readonly rule: {
7329
7283
  readonly framework: "global";
7330
- readonly category: "Bugs";
7284
+ readonly category: "Security";
7285
+ readonly tags: readonly string[];
7331
7286
  readonly id: string;
7332
7287
  readonly title?: string;
7333
7288
  readonly severity: RuleSeverity;
7334
7289
  readonly requires?: ReadonlyArray<Capability>;
7335
7290
  readonly disabledWhen?: ReadonlyArray<Capability>;
7336
- readonly tags?: ReadonlyArray<string>;
7337
7291
  readonly matchByOccurrence?: boolean;
7338
7292
  readonly defaultEnabled?: boolean;
7339
7293
  readonly lifecycle?: "retired";
@@ -7344,19 +7298,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7344
7298
  readonly create: (context: RuleContext) => RuleVisitors;
7345
7299
  };
7346
7300
  }, {
7347
- readonly key: "react-doctor/rendering-animate-svg-wrapper";
7348
- readonly id: "rendering-animate-svg-wrapper";
7301
+ readonly key: "react-doctor/request-body-mass-assignment";
7302
+ readonly id: "request-body-mass-assignment";
7349
7303
  readonly source: "react-doctor";
7350
7304
  readonly originallyExternal: false;
7351
7305
  readonly rule: {
7352
7306
  readonly framework: "global";
7353
- readonly category: "Performance";
7354
- readonly requires: readonly Capability[];
7307
+ readonly category: "Security";
7308
+ readonly tags: readonly string[];
7355
7309
  readonly id: string;
7356
7310
  readonly title?: string;
7357
7311
  readonly severity: RuleSeverity;
7312
+ readonly requires?: ReadonlyArray<Capability>;
7358
7313
  readonly disabledWhen?: ReadonlyArray<Capability>;
7359
- readonly tags?: ReadonlyArray<string>;
7360
7314
  readonly matchByOccurrence?: boolean;
7361
7315
  readonly defaultEnabled?: boolean;
7362
7316
  readonly lifecycle?: "retired";
@@ -7367,17 +7321,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7367
7321
  readonly create: (context: RuleContext) => RuleVisitors;
7368
7322
  };
7369
7323
  }, {
7370
- readonly key: "react-doctor/rendering-conditional-render";
7371
- readonly id: "rendering-conditional-render";
7324
+ readonly key: "react-doctor/require-render-return";
7325
+ readonly id: "require-render-return";
7372
7326
  readonly source: "react-doctor";
7373
- readonly originallyExternal: false;
7327
+ readonly originallyExternal: true;
7374
7328
  readonly rule: {
7375
7329
  readonly framework: "global";
7376
7330
  readonly category: "Bugs";
7331
+ readonly requires: readonly Capability[];
7377
7332
  readonly id: string;
7378
7333
  readonly title?: string;
7379
7334
  readonly severity: RuleSeverity;
7380
- readonly requires?: ReadonlyArray<Capability>;
7381
7335
  readonly disabledWhen?: ReadonlyArray<Capability>;
7382
7336
  readonly tags?: ReadonlyArray<string>;
7383
7337
  readonly matchByOccurrence?: boolean;
@@ -7390,8 +7344,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7390
7344
  readonly create: (context: RuleContext) => RuleVisitors;
7391
7345
  };
7392
7346
  }, {
7393
- readonly key: "react-doctor/rendering-hoist-jsx";
7394
- readonly id: "rendering-hoist-jsx";
7347
+ readonly key: "react-doctor/rerender-defer-reads-hook";
7348
+ readonly id: "rerender-defer-reads-hook";
7395
7349
  readonly source: "react-doctor";
7396
7350
  readonly originallyExternal: false;
7397
7351
  readonly rule: {
@@ -7413,8 +7367,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7413
7367
  readonly create: (context: RuleContext) => RuleVisitors;
7414
7368
  };
7415
7369
  }, {
7416
- readonly key: "react-doctor/rendering-hydration-mismatch-time";
7417
- readonly id: "rendering-hydration-mismatch-time";
7370
+ readonly key: "react-doctor/rerender-dependencies";
7371
+ readonly id: "rerender-dependencies";
7418
7372
  readonly source: "react-doctor";
7419
7373
  readonly originallyExternal: false;
7420
7374
  readonly rule: {
@@ -7436,8 +7390,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7436
7390
  readonly create: (context: RuleContext) => RuleVisitors;
7437
7391
  };
7438
7392
  }, {
7439
- readonly key: "react-doctor/rendering-hydration-no-flicker";
7440
- readonly id: "rendering-hydration-no-flicker";
7393
+ readonly key: "react-doctor/rerender-derived-state-from-hook";
7394
+ readonly id: "rerender-derived-state-from-hook";
7441
7395
  readonly source: "react-doctor";
7442
7396
  readonly originallyExternal: false;
7443
7397
  readonly rule: {
@@ -7459,8 +7413,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7459
7413
  readonly create: (context: RuleContext) => RuleVisitors;
7460
7414
  };
7461
7415
  }, {
7462
- readonly key: "react-doctor/rendering-script-defer-async";
7463
- readonly id: "rendering-script-defer-async";
7416
+ readonly key: "react-doctor/rerender-functional-setstate";
7417
+ readonly id: "rerender-functional-setstate";
7464
7418
  readonly source: "react-doctor";
7465
7419
  readonly originallyExternal: false;
7466
7420
  readonly rule: {
@@ -7482,17 +7436,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7482
7436
  readonly create: (context: RuleContext) => RuleVisitors;
7483
7437
  };
7484
7438
  }, {
7485
- readonly key: "react-doctor/rendering-svg-precision";
7486
- readonly id: "rendering-svg-precision";
7439
+ readonly key: "react-doctor/rerender-lazy-ref-init";
7440
+ readonly id: "rerender-lazy-ref-init";
7487
7441
  readonly source: "react-doctor";
7488
7442
  readonly originallyExternal: false;
7489
7443
  readonly rule: {
7490
7444
  readonly framework: "global";
7491
7445
  readonly category: "Performance";
7446
+ readonly requires: readonly Capability[];
7492
7447
  readonly id: string;
7493
7448
  readonly title?: string;
7494
7449
  readonly severity: RuleSeverity;
7495
- readonly requires?: ReadonlyArray<Capability>;
7496
7450
  readonly disabledWhen?: ReadonlyArray<Capability>;
7497
7451
  readonly tags?: ReadonlyArray<string>;
7498
7452
  readonly matchByOccurrence?: boolean;
@@ -7505,8 +7459,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7505
7459
  readonly create: (context: RuleContext) => RuleVisitors;
7506
7460
  };
7507
7461
  }, {
7508
- readonly key: "react-doctor/rendering-usetransition-loading";
7509
- readonly id: "rendering-usetransition-loading";
7462
+ readonly key: "react-doctor/rerender-lazy-state-init";
7463
+ readonly id: "rerender-lazy-state-init";
7510
7464
  readonly source: "react-doctor";
7511
7465
  readonly originallyExternal: false;
7512
7466
  readonly rule: {
@@ -7528,19 +7482,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7528
7482
  readonly create: (context: RuleContext) => RuleVisitors;
7529
7483
  };
7530
7484
  }, {
7531
- readonly key: "react-doctor/repository-secret-file";
7532
- readonly id: "repository-secret-file";
7485
+ readonly key: "react-doctor/rerender-memo-before-early-return";
7486
+ readonly id: "rerender-memo-before-early-return";
7533
7487
  readonly source: "react-doctor";
7534
7488
  readonly originallyExternal: false;
7535
7489
  readonly rule: {
7536
7490
  readonly framework: "global";
7537
- readonly category: "Security";
7538
- readonly tags: readonly string[];
7491
+ readonly category: "Performance";
7492
+ readonly requires: readonly Capability[];
7539
7493
  readonly id: string;
7540
7494
  readonly title?: string;
7541
7495
  readonly severity: RuleSeverity;
7542
- readonly requires?: ReadonlyArray<Capability>;
7543
7496
  readonly disabledWhen?: ReadonlyArray<Capability>;
7497
+ readonly tags?: ReadonlyArray<string>;
7544
7498
  readonly matchByOccurrence?: boolean;
7545
7499
  readonly defaultEnabled?: boolean;
7546
7500
  readonly lifecycle?: "retired";
@@ -7551,19 +7505,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7551
7505
  readonly create: (context: RuleContext) => RuleVisitors;
7552
7506
  };
7553
7507
  }, {
7554
- readonly key: "react-doctor/request-body-mass-assignment";
7555
- readonly id: "request-body-mass-assignment";
7508
+ readonly key: "react-doctor/rerender-memo-with-default-value";
7509
+ readonly id: "rerender-memo-with-default-value";
7556
7510
  readonly source: "react-doctor";
7557
7511
  readonly originallyExternal: false;
7558
7512
  readonly rule: {
7559
7513
  readonly framework: "global";
7560
- readonly category: "Security";
7561
- readonly tags: readonly string[];
7514
+ readonly category: "Performance";
7515
+ readonly requires: readonly Capability[];
7562
7516
  readonly id: string;
7563
7517
  readonly title?: string;
7564
7518
  readonly severity: RuleSeverity;
7565
- readonly requires?: ReadonlyArray<Capability>;
7566
7519
  readonly disabledWhen?: ReadonlyArray<Capability>;
7520
+ readonly tags?: ReadonlyArray<string>;
7567
7521
  readonly matchByOccurrence?: boolean;
7568
7522
  readonly defaultEnabled?: boolean;
7569
7523
  readonly lifecycle?: "retired";
@@ -7574,13 +7528,13 @@ declare const REACT_DOCTOR_RULES: readonly [{
7574
7528
  readonly create: (context: RuleContext) => RuleVisitors;
7575
7529
  };
7576
7530
  }, {
7577
- readonly key: "react-doctor/require-render-return";
7578
- readonly id: "require-render-return";
7531
+ readonly key: "react-doctor/rerender-state-only-in-handlers";
7532
+ readonly id: "rerender-state-only-in-handlers";
7579
7533
  readonly source: "react-doctor";
7580
- readonly originallyExternal: true;
7534
+ readonly originallyExternal: false;
7581
7535
  readonly rule: {
7582
7536
  readonly framework: "global";
7583
- readonly category: "Bugs";
7537
+ readonly category: "Performance";
7584
7538
  readonly requires: readonly Capability[];
7585
7539
  readonly id: string;
7586
7540
  readonly title?: string;
@@ -7597,8 +7551,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7597
7551
  readonly create: (context: RuleContext) => RuleVisitors;
7598
7552
  };
7599
7553
  }, {
7600
- readonly key: "react-doctor/rerender-defer-reads-hook";
7601
- readonly id: "rerender-defer-reads-hook";
7554
+ readonly key: "react-doctor/rerender-transitions-scroll";
7555
+ readonly id: "rerender-transitions-scroll";
7602
7556
  readonly source: "react-doctor";
7603
7557
  readonly originallyExternal: false;
7604
7558
  readonly rule: {
@@ -7620,19 +7574,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7620
7574
  readonly create: (context: RuleContext) => RuleVisitors;
7621
7575
  };
7622
7576
  }, {
7623
- readonly key: "react-doctor/rerender-dependencies";
7624
- readonly id: "rerender-dependencies";
7577
+ readonly key: "react-doctor/rn-animate-layout-property";
7578
+ readonly id: "rn-animate-layout-property";
7625
7579
  readonly source: "react-doctor";
7626
7580
  readonly originallyExternal: false;
7627
7581
  readonly rule: {
7628
- readonly framework: "global";
7582
+ readonly framework: "react-native";
7629
7583
  readonly category: "Bugs";
7630
- readonly requires: readonly Capability[];
7584
+ readonly tags: readonly string[];
7631
7585
  readonly id: string;
7632
7586
  readonly title?: string;
7633
7587
  readonly severity: RuleSeverity;
7588
+ readonly requires?: ReadonlyArray<Capability>;
7634
7589
  readonly disabledWhen?: ReadonlyArray<Capability>;
7635
- readonly tags?: ReadonlyArray<string>;
7636
7590
  readonly matchByOccurrence?: boolean;
7637
7591
  readonly defaultEnabled?: boolean;
7638
7592
  readonly lifecycle?: "retired";
@@ -7643,19 +7597,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7643
7597
  readonly create: (context: RuleContext) => RuleVisitors;
7644
7598
  };
7645
7599
  }, {
7646
- readonly key: "react-doctor/rerender-derived-state-from-hook";
7647
- readonly id: "rerender-derived-state-from-hook";
7600
+ readonly key: "react-doctor/rn-animation-reaction-as-derived";
7601
+ readonly id: "rn-animation-reaction-as-derived";
7648
7602
  readonly source: "react-doctor";
7649
7603
  readonly originallyExternal: false;
7650
7604
  readonly rule: {
7651
- readonly framework: "global";
7652
- readonly category: "Performance";
7653
- readonly requires: readonly Capability[];
7605
+ readonly framework: "react-native";
7606
+ readonly category: "Bugs";
7607
+ readonly tags: readonly string[];
7654
7608
  readonly id: string;
7655
7609
  readonly title?: string;
7656
7610
  readonly severity: RuleSeverity;
7611
+ readonly requires?: ReadonlyArray<Capability>;
7657
7612
  readonly disabledWhen?: ReadonlyArray<Capability>;
7658
- readonly tags?: ReadonlyArray<string>;
7659
7613
  readonly matchByOccurrence?: boolean;
7660
7614
  readonly defaultEnabled?: boolean;
7661
7615
  readonly lifecycle?: "retired";
@@ -7666,19 +7620,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7666
7620
  readonly create: (context: RuleContext) => RuleVisitors;
7667
7621
  };
7668
7622
  }, {
7669
- readonly key: "react-doctor/rerender-functional-setstate";
7670
- readonly id: "rerender-functional-setstate";
7623
+ readonly key: "react-doctor/rn-bottom-sheet-prefer-native";
7624
+ readonly id: "rn-bottom-sheet-prefer-native";
7671
7625
  readonly source: "react-doctor";
7672
7626
  readonly originallyExternal: false;
7673
7627
  readonly rule: {
7674
- readonly framework: "global";
7675
- readonly category: "Performance";
7676
- readonly requires: readonly Capability[];
7628
+ readonly framework: "react-native";
7629
+ readonly category: "Bugs";
7630
+ readonly tags: readonly string[];
7677
7631
  readonly id: string;
7678
7632
  readonly title?: string;
7679
7633
  readonly severity: RuleSeverity;
7634
+ readonly requires?: ReadonlyArray<Capability>;
7680
7635
  readonly disabledWhen?: ReadonlyArray<Capability>;
7681
- readonly tags?: ReadonlyArray<string>;
7682
7636
  readonly matchByOccurrence?: boolean;
7683
7637
  readonly defaultEnabled?: boolean;
7684
7638
  readonly lifecycle?: "retired";
@@ -7689,19 +7643,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7689
7643
  readonly create: (context: RuleContext) => RuleVisitors;
7690
7644
  };
7691
7645
  }, {
7692
- readonly key: "react-doctor/rerender-lazy-ref-init";
7693
- readonly id: "rerender-lazy-ref-init";
7646
+ readonly key: "react-doctor/rn-detox-missing-await";
7647
+ readonly id: "rn-detox-missing-await";
7694
7648
  readonly source: "react-doctor";
7695
7649
  readonly originallyExternal: false;
7696
7650
  readonly rule: {
7697
- readonly framework: "global";
7698
- readonly category: "Performance";
7699
- readonly requires: readonly Capability[];
7651
+ readonly framework: "react-native";
7652
+ readonly category: "Bugs";
7653
+ readonly tags: readonly string[];
7700
7654
  readonly id: string;
7701
7655
  readonly title?: string;
7702
7656
  readonly severity: RuleSeverity;
7657
+ readonly requires?: ReadonlyArray<Capability>;
7703
7658
  readonly disabledWhen?: ReadonlyArray<Capability>;
7704
- readonly tags?: ReadonlyArray<string>;
7705
7659
  readonly matchByOccurrence?: boolean;
7706
7660
  readonly defaultEnabled?: boolean;
7707
7661
  readonly lifecycle?: "retired";
@@ -7712,215 +7666,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7712
7666
  readonly create: (context: RuleContext) => RuleVisitors;
7713
7667
  };
7714
7668
  }, {
7715
- readonly key: "react-doctor/rerender-lazy-state-init";
7716
- readonly id: "rerender-lazy-state-init";
7717
- readonly source: "react-doctor";
7718
- readonly originallyExternal: false;
7719
- readonly rule: {
7720
- readonly framework: "global";
7721
- readonly category: "Performance";
7722
- readonly requires: readonly Capability[];
7723
- readonly id: string;
7724
- readonly title?: string;
7725
- readonly severity: RuleSeverity;
7726
- readonly disabledWhen?: ReadonlyArray<Capability>;
7727
- readonly tags?: ReadonlyArray<string>;
7728
- readonly matchByOccurrence?: boolean;
7729
- readonly defaultEnabled?: boolean;
7730
- readonly lifecycle?: "retired";
7731
- readonly scan?: FileScan;
7732
- readonly committedFilesOnly?: boolean;
7733
- readonly recommendation?: string;
7734
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7735
- readonly create: (context: RuleContext) => RuleVisitors;
7736
- };
7737
- }, {
7738
- readonly key: "react-doctor/rerender-memo-before-early-return";
7739
- readonly id: "rerender-memo-before-early-return";
7740
- readonly source: "react-doctor";
7741
- readonly originallyExternal: false;
7742
- readonly rule: {
7743
- readonly framework: "global";
7744
- readonly category: "Performance";
7745
- readonly requires: readonly Capability[];
7746
- readonly id: string;
7747
- readonly title?: string;
7748
- readonly severity: RuleSeverity;
7749
- readonly disabledWhen?: ReadonlyArray<Capability>;
7750
- readonly tags?: ReadonlyArray<string>;
7751
- readonly matchByOccurrence?: boolean;
7752
- readonly defaultEnabled?: boolean;
7753
- readonly lifecycle?: "retired";
7754
- readonly scan?: FileScan;
7755
- readonly committedFilesOnly?: boolean;
7756
- readonly recommendation?: string;
7757
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7758
- readonly create: (context: RuleContext) => RuleVisitors;
7759
- };
7760
- }, {
7761
- readonly key: "react-doctor/rerender-memo-with-default-value";
7762
- readonly id: "rerender-memo-with-default-value";
7763
- readonly source: "react-doctor";
7764
- readonly originallyExternal: false;
7765
- readonly rule: {
7766
- readonly framework: "global";
7767
- readonly category: "Performance";
7768
- readonly requires: readonly Capability[];
7769
- readonly id: string;
7770
- readonly title?: string;
7771
- readonly severity: RuleSeverity;
7772
- readonly disabledWhen?: ReadonlyArray<Capability>;
7773
- readonly tags?: ReadonlyArray<string>;
7774
- readonly matchByOccurrence?: boolean;
7775
- readonly defaultEnabled?: boolean;
7776
- readonly lifecycle?: "retired";
7777
- readonly scan?: FileScan;
7778
- readonly committedFilesOnly?: boolean;
7779
- readonly recommendation?: string;
7780
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7781
- readonly create: (context: RuleContext) => RuleVisitors;
7782
- };
7783
- }, {
7784
- readonly key: "react-doctor/rerender-state-only-in-handlers";
7785
- readonly id: "rerender-state-only-in-handlers";
7786
- readonly source: "react-doctor";
7787
- readonly originallyExternal: false;
7788
- readonly rule: {
7789
- readonly framework: "global";
7790
- readonly category: "Performance";
7791
- readonly requires: readonly Capability[];
7792
- readonly id: string;
7793
- readonly title?: string;
7794
- readonly severity: RuleSeverity;
7795
- readonly disabledWhen?: ReadonlyArray<Capability>;
7796
- readonly tags?: ReadonlyArray<string>;
7797
- readonly matchByOccurrence?: boolean;
7798
- readonly defaultEnabled?: boolean;
7799
- readonly lifecycle?: "retired";
7800
- readonly scan?: FileScan;
7801
- readonly committedFilesOnly?: boolean;
7802
- readonly recommendation?: string;
7803
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7804
- readonly create: (context: RuleContext) => RuleVisitors;
7805
- };
7806
- }, {
7807
- readonly key: "react-doctor/rerender-transitions-scroll";
7808
- readonly id: "rerender-transitions-scroll";
7809
- readonly source: "react-doctor";
7810
- readonly originallyExternal: false;
7811
- readonly rule: {
7812
- readonly framework: "global";
7813
- readonly category: "Performance";
7814
- readonly requires: readonly Capability[];
7815
- readonly id: string;
7816
- readonly title?: string;
7817
- readonly severity: RuleSeverity;
7818
- readonly disabledWhen?: ReadonlyArray<Capability>;
7819
- readonly tags?: ReadonlyArray<string>;
7820
- readonly matchByOccurrence?: boolean;
7821
- readonly defaultEnabled?: boolean;
7822
- readonly lifecycle?: "retired";
7823
- readonly scan?: FileScan;
7824
- readonly committedFilesOnly?: boolean;
7825
- readonly recommendation?: string;
7826
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7827
- readonly create: (context: RuleContext) => RuleVisitors;
7828
- };
7829
- }, {
7830
- readonly key: "react-doctor/rn-animate-layout-property";
7831
- readonly id: "rn-animate-layout-property";
7832
- readonly source: "react-doctor";
7833
- readonly originallyExternal: false;
7834
- readonly rule: {
7835
- readonly framework: "react-native";
7836
- readonly category: "Bugs";
7837
- readonly tags: readonly string[];
7838
- readonly id: string;
7839
- readonly title?: string;
7840
- readonly severity: RuleSeverity;
7841
- readonly requires?: ReadonlyArray<Capability>;
7842
- readonly disabledWhen?: ReadonlyArray<Capability>;
7843
- readonly matchByOccurrence?: boolean;
7844
- readonly defaultEnabled?: boolean;
7845
- readonly lifecycle?: "retired";
7846
- readonly scan?: FileScan;
7847
- readonly committedFilesOnly?: boolean;
7848
- readonly recommendation?: string;
7849
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7850
- readonly create: (context: RuleContext) => RuleVisitors;
7851
- };
7852
- }, {
7853
- readonly key: "react-doctor/rn-animation-reaction-as-derived";
7854
- readonly id: "rn-animation-reaction-as-derived";
7855
- readonly source: "react-doctor";
7856
- readonly originallyExternal: false;
7857
- readonly rule: {
7858
- readonly framework: "react-native";
7859
- readonly category: "Bugs";
7860
- readonly tags: readonly string[];
7861
- readonly id: string;
7862
- readonly title?: string;
7863
- readonly severity: RuleSeverity;
7864
- readonly requires?: ReadonlyArray<Capability>;
7865
- readonly disabledWhen?: ReadonlyArray<Capability>;
7866
- readonly matchByOccurrence?: boolean;
7867
- readonly defaultEnabled?: boolean;
7868
- readonly lifecycle?: "retired";
7869
- readonly scan?: FileScan;
7870
- readonly committedFilesOnly?: boolean;
7871
- readonly recommendation?: string;
7872
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7873
- readonly create: (context: RuleContext) => RuleVisitors;
7874
- };
7875
- }, {
7876
- readonly key: "react-doctor/rn-bottom-sheet-prefer-native";
7877
- readonly id: "rn-bottom-sheet-prefer-native";
7878
- readonly source: "react-doctor";
7879
- readonly originallyExternal: false;
7880
- readonly rule: {
7881
- readonly framework: "react-native";
7882
- readonly category: "Bugs";
7883
- readonly tags: readonly string[];
7884
- readonly id: string;
7885
- readonly title?: string;
7886
- readonly severity: RuleSeverity;
7887
- readonly requires?: ReadonlyArray<Capability>;
7888
- readonly disabledWhen?: ReadonlyArray<Capability>;
7889
- readonly matchByOccurrence?: boolean;
7890
- readonly defaultEnabled?: boolean;
7891
- readonly lifecycle?: "retired";
7892
- readonly scan?: FileScan;
7893
- readonly committedFilesOnly?: boolean;
7894
- readonly recommendation?: string;
7895
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7896
- readonly create: (context: RuleContext) => RuleVisitors;
7897
- };
7898
- }, {
7899
- readonly key: "react-doctor/rn-detox-missing-await";
7900
- readonly id: "rn-detox-missing-await";
7901
- readonly source: "react-doctor";
7902
- readonly originallyExternal: false;
7903
- readonly rule: {
7904
- readonly framework: "react-native";
7905
- readonly category: "Bugs";
7906
- readonly tags: readonly string[];
7907
- readonly id: string;
7908
- readonly title?: string;
7909
- readonly severity: RuleSeverity;
7910
- readonly requires?: ReadonlyArray<Capability>;
7911
- readonly disabledWhen?: ReadonlyArray<Capability>;
7912
- readonly matchByOccurrence?: boolean;
7913
- readonly defaultEnabled?: boolean;
7914
- readonly lifecycle?: "retired";
7915
- readonly scan?: FileScan;
7916
- readonly committedFilesOnly?: boolean;
7917
- readonly recommendation?: string;
7918
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
7919
- readonly create: (context: RuleContext) => RuleVisitors;
7920
- };
7921
- }, {
7922
- readonly key: "react-doctor/rn-list-callback-per-row";
7923
- readonly id: "rn-list-callback-per-row";
7669
+ readonly key: "react-doctor/rn-list-callback-per-row";
7670
+ readonly id: "rn-list-callback-per-row";
7924
7671
  readonly source: "react-doctor";
7925
7672
  readonly originallyExternal: false;
7926
7673
  readonly rule: {
@@ -9528,52 +9275,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
9528
9275
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9529
9276
  readonly create: (context: RuleContext) => RuleVisitors;
9530
9277
  };
9531
- }, {
9532
- readonly key: "react-doctor/valtio-no-proxy-read-in-render";
9533
- readonly id: "valtio-no-proxy-read-in-render";
9534
- readonly source: "react-doctor";
9535
- readonly originallyExternal: false;
9536
- readonly rule: {
9537
- readonly framework: "global";
9538
- readonly category: "Bugs";
9539
- readonly requires: readonly Capability[];
9540
- readonly id: string;
9541
- readonly title?: string;
9542
- readonly severity: RuleSeverity;
9543
- readonly disabledWhen?: ReadonlyArray<Capability>;
9544
- readonly tags?: ReadonlyArray<string>;
9545
- readonly matchByOccurrence?: boolean;
9546
- readonly defaultEnabled?: boolean;
9547
- readonly lifecycle?: "retired";
9548
- readonly scan?: FileScan;
9549
- readonly committedFilesOnly?: boolean;
9550
- readonly recommendation?: string;
9551
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9552
- readonly create: (context: RuleContext) => RuleVisitors;
9553
- };
9554
- }, {
9555
- readonly key: "react-doctor/valtio-no-snapshot-in-callback";
9556
- readonly id: "valtio-no-snapshot-in-callback";
9557
- readonly source: "react-doctor";
9558
- readonly originallyExternal: false;
9559
- readonly rule: {
9560
- readonly framework: "global";
9561
- readonly category: "Bugs";
9562
- readonly requires: readonly Capability[];
9563
- readonly id: string;
9564
- readonly title?: string;
9565
- readonly severity: RuleSeverity;
9566
- readonly disabledWhen?: ReadonlyArray<Capability>;
9567
- readonly tags?: ReadonlyArray<string>;
9568
- readonly matchByOccurrence?: boolean;
9569
- readonly defaultEnabled?: boolean;
9570
- readonly lifecycle?: "retired";
9571
- readonly scan?: FileScan;
9572
- readonly committedFilesOnly?: boolean;
9573
- readonly recommendation?: string;
9574
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9575
- readonly create: (context: RuleContext) => RuleVisitors;
9576
- };
9577
9278
  }, {
9578
9279
  readonly key: "react-doctor/void-dom-elements-no-children";
9579
9280
  readonly id: "void-dom-elements-no-children";
@@ -9712,75 +9413,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
9712
9413
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9713
9414
  readonly create: (context: RuleContext) => RuleVisitors;
9714
9415
  };
9715
- }, {
9716
- readonly key: "react-doctor/zustand-no-fresh-selector-result";
9717
- readonly id: "zustand-no-fresh-selector-result";
9718
- readonly source: "react-doctor";
9719
- readonly originallyExternal: false;
9720
- readonly rule: {
9721
- readonly framework: "global";
9722
- readonly category: "Performance";
9723
- readonly requires: readonly Capability[];
9724
- readonly id: string;
9725
- readonly title?: string;
9726
- readonly severity: RuleSeverity;
9727
- readonly disabledWhen?: ReadonlyArray<Capability>;
9728
- readonly tags?: ReadonlyArray<string>;
9729
- readonly matchByOccurrence?: boolean;
9730
- readonly defaultEnabled?: boolean;
9731
- readonly lifecycle?: "retired";
9732
- readonly scan?: FileScan;
9733
- readonly committedFilesOnly?: boolean;
9734
- readonly recommendation?: string;
9735
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9736
- readonly create: (context: RuleContext) => RuleVisitors;
9737
- };
9738
- }, {
9739
- readonly key: "react-doctor/zustand-no-get-during-initialization";
9740
- readonly id: "zustand-no-get-during-initialization";
9741
- readonly source: "react-doctor";
9742
- readonly originallyExternal: false;
9743
- readonly rule: {
9744
- readonly framework: "global";
9745
- readonly category: "Bugs";
9746
- readonly requires: readonly Capability[];
9747
- readonly id: string;
9748
- readonly title?: string;
9749
- readonly severity: RuleSeverity;
9750
- readonly disabledWhen?: ReadonlyArray<Capability>;
9751
- readonly tags?: ReadonlyArray<string>;
9752
- readonly matchByOccurrence?: boolean;
9753
- readonly defaultEnabled?: boolean;
9754
- readonly lifecycle?: "retired";
9755
- readonly scan?: FileScan;
9756
- readonly committedFilesOnly?: boolean;
9757
- readonly recommendation?: string;
9758
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9759
- readonly create: (context: RuleContext) => RuleVisitors;
9760
- };
9761
- }, {
9762
- readonly key: "react-doctor/zustand-no-whole-store-destructure";
9763
- readonly id: "zustand-no-whole-store-destructure";
9764
- readonly source: "react-doctor";
9765
- readonly originallyExternal: false;
9766
- readonly rule: {
9767
- readonly framework: "global";
9768
- readonly category: "Bugs";
9769
- readonly requires: readonly Capability[];
9770
- readonly id: string;
9771
- readonly title?: string;
9772
- readonly severity: RuleSeverity;
9773
- readonly disabledWhen?: ReadonlyArray<Capability>;
9774
- readonly tags?: ReadonlyArray<string>;
9775
- readonly matchByOccurrence?: boolean;
9776
- readonly defaultEnabled?: boolean;
9777
- readonly lifecycle?: "retired";
9778
- readonly scan?: FileScan;
9779
- readonly committedFilesOnly?: boolean;
9780
- readonly recommendation?: string;
9781
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9782
- readonly create: (context: RuleContext) => RuleVisitors;
9783
- };
9784
9416
  }];
9785
9417
  declare const EXTERNAL_RULES: readonly [{
9786
9418
  readonly key: "react-hooks-js/set-state-in-render";
@@ -9805,7 +9437,7 @@ declare const EXTERNAL_RULES: readonly [{
9805
9437
  }, {
9806
9438
  readonly key: "react-hooks-js/set-state-in-effect";
9807
9439
  readonly source: "react-compiler";
9808
- readonly severity: "warn";
9440
+ readonly severity: "error";
9809
9441
  }, {
9810
9442
  readonly key: "react-hooks-js/globals";
9811
9443
  readonly source: "react-compiler";
@@ -12101,6 +11733,29 @@ declare const RULES: readonly [{
12101
11733
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12102
11734
  readonly create: (context: RuleContext) => RuleVisitors;
12103
11735
  };
11736
+ }, {
11737
+ readonly key: "react-doctor/jsx-no-target-blank";
11738
+ readonly id: "jsx-no-target-blank";
11739
+ readonly source: "react-doctor";
11740
+ readonly originallyExternal: true;
11741
+ readonly rule: {
11742
+ readonly framework: "global";
11743
+ readonly category: "Security";
11744
+ readonly requires: readonly Capability[];
11745
+ readonly id: string;
11746
+ readonly title?: string;
11747
+ readonly severity: RuleSeverity;
11748
+ readonly disabledWhen?: ReadonlyArray<Capability>;
11749
+ readonly tags?: ReadonlyArray<string>;
11750
+ readonly matchByOccurrence?: boolean;
11751
+ readonly defaultEnabled?: boolean;
11752
+ readonly lifecycle?: "retired";
11753
+ readonly scan?: FileScan;
11754
+ readonly committedFilesOnly?: boolean;
11755
+ readonly recommendation?: string;
11756
+ readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
11757
+ readonly create: (context: RuleContext) => RuleVisitors;
11758
+ };
12104
11759
  }, {
12105
11760
  readonly key: "react-doctor/jsx-no-undef";
12106
11761
  readonly id: "jsx-no-undef";
@@ -12270,81 +11925,12 @@ declare const RULES: readonly [{
12270
11925
  readonly rule: {
12271
11926
  readonly framework: "global";
12272
11927
  readonly category: "Accessibility";
12273
- readonly requires: readonly Capability[];
12274
- readonly id: string;
12275
- readonly title?: string;
12276
- readonly severity: RuleSeverity;
12277
- readonly disabledWhen?: ReadonlyArray<Capability>;
12278
- readonly tags?: ReadonlyArray<string>;
12279
- readonly matchByOccurrence?: boolean;
12280
- readonly defaultEnabled?: boolean;
12281
- readonly lifecycle?: "retired";
12282
- readonly scan?: FileScan;
12283
- readonly committedFilesOnly?: boolean;
12284
- readonly recommendation?: string;
12285
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12286
- readonly create: (context: RuleContext) => RuleVisitors;
12287
- };
12288
- }, {
12289
- readonly key: "react-doctor/lang";
12290
- readonly id: "lang";
12291
- readonly source: "react-doctor";
12292
- readonly originallyExternal: true;
12293
- readonly rule: {
12294
- readonly framework: "global";
12295
- readonly category: "Accessibility";
12296
- readonly requires: readonly Capability[];
12297
- readonly id: string;
12298
- readonly title?: string;
12299
- readonly severity: RuleSeverity;
12300
- readonly disabledWhen?: ReadonlyArray<Capability>;
12301
- readonly tags?: ReadonlyArray<string>;
12302
- readonly matchByOccurrence?: boolean;
12303
- readonly defaultEnabled?: boolean;
12304
- readonly lifecycle?: "retired";
12305
- readonly scan?: FileScan;
12306
- readonly committedFilesOnly?: boolean;
12307
- readonly recommendation?: string;
12308
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12309
- readonly create: (context: RuleContext) => RuleVisitors;
12310
- };
12311
- }, {
12312
- readonly key: "react-doctor/local-rpc-native-bridge-risk";
12313
- readonly id: "local-rpc-native-bridge-risk";
12314
- readonly source: "react-doctor";
12315
- readonly originallyExternal: false;
12316
- readonly rule: {
12317
- readonly framework: "global";
12318
- readonly category: "Security";
12319
- readonly tags: readonly string[];
12320
- readonly id: string;
12321
- readonly title?: string;
12322
- readonly severity: RuleSeverity;
12323
- readonly requires?: ReadonlyArray<Capability>;
12324
- readonly disabledWhen?: ReadonlyArray<Capability>;
12325
- readonly matchByOccurrence?: boolean;
12326
- readonly defaultEnabled?: boolean;
12327
- readonly lifecycle?: "retired";
12328
- readonly scan?: FileScan;
12329
- readonly committedFilesOnly?: boolean;
12330
- readonly recommendation?: string;
12331
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12332
- readonly create: (context: RuleContext) => RuleVisitors;
12333
- };
12334
- }, {
12335
- readonly key: "react-doctor/mcp-tool-capability-risk";
12336
- readonly id: "mcp-tool-capability-risk";
12337
- readonly source: "react-doctor";
12338
- readonly originallyExternal: false;
12339
- readonly rule: {
12340
- readonly framework: "global";
12341
- readonly category: "Security";
12342
- readonly tags: readonly string[];
11928
+ readonly requires: readonly Capability[];
12343
11929
  readonly id: string;
12344
11930
  readonly title?: string;
12345
11931
  readonly severity: RuleSeverity;
12346
- readonly requires?: ReadonlyArray<Capability>;
12347
11932
  readonly disabledWhen?: ReadonlyArray<Capability>;
11933
+ readonly tags?: ReadonlyArray<string>;
12348
11934
  readonly matchByOccurrence?: boolean;
12349
11935
  readonly defaultEnabled?: boolean;
12350
11936
  readonly lifecycle?: "retired";
@@ -12355,19 +11941,19 @@ declare const RULES: readonly [{
12355
11941
  readonly create: (context: RuleContext) => RuleVisitors;
12356
11942
  };
12357
11943
  }, {
12358
- readonly key: "react-doctor/mdx-ssr-execution-risk";
12359
- readonly id: "mdx-ssr-execution-risk";
11944
+ readonly key: "react-doctor/lang";
11945
+ readonly id: "lang";
12360
11946
  readonly source: "react-doctor";
12361
- readonly originallyExternal: false;
11947
+ readonly originallyExternal: true;
12362
11948
  readonly rule: {
12363
11949
  readonly framework: "global";
12364
- readonly category: "Security";
12365
- readonly tags: readonly string[];
11950
+ readonly category: "Accessibility";
11951
+ readonly requires: readonly Capability[];
12366
11952
  readonly id: string;
12367
11953
  readonly title?: string;
12368
11954
  readonly severity: RuleSeverity;
12369
- readonly requires?: ReadonlyArray<Capability>;
12370
11955
  readonly disabledWhen?: ReadonlyArray<Capability>;
11956
+ readonly tags?: ReadonlyArray<string>;
12371
11957
  readonly matchByOccurrence?: boolean;
12372
11958
  readonly defaultEnabled?: boolean;
12373
11959
  readonly lifecycle?: "retired";
@@ -12378,19 +11964,19 @@ declare const RULES: readonly [{
12378
11964
  readonly create: (context: RuleContext) => RuleVisitors;
12379
11965
  };
12380
11966
  }, {
12381
- readonly key: "react-doctor/media-has-caption";
12382
- readonly id: "media-has-caption";
11967
+ readonly key: "react-doctor/local-rpc-native-bridge-risk";
11968
+ readonly id: "local-rpc-native-bridge-risk";
12383
11969
  readonly source: "react-doctor";
12384
- readonly originallyExternal: true;
11970
+ readonly originallyExternal: false;
12385
11971
  readonly rule: {
12386
11972
  readonly framework: "global";
12387
- readonly category: "Accessibility";
12388
- readonly requires: readonly Capability[];
11973
+ readonly category: "Security";
11974
+ readonly tags: readonly string[];
12389
11975
  readonly id: string;
12390
11976
  readonly title?: string;
12391
11977
  readonly severity: RuleSeverity;
11978
+ readonly requires?: ReadonlyArray<Capability>;
12392
11979
  readonly disabledWhen?: ReadonlyArray<Capability>;
12393
- readonly tags?: ReadonlyArray<string>;
12394
11980
  readonly matchByOccurrence?: boolean;
12395
11981
  readonly defaultEnabled?: boolean;
12396
11982
  readonly lifecycle?: "retired";
@@ -12401,19 +11987,19 @@ declare const RULES: readonly [{
12401
11987
  readonly create: (context: RuleContext) => RuleVisitors;
12402
11988
  };
12403
11989
  }, {
12404
- readonly key: "react-doctor/mobx-no-make-auto-observable-in-inheritance";
12405
- readonly id: "mobx-no-make-auto-observable-in-inheritance";
11990
+ readonly key: "react-doctor/mcp-tool-capability-risk";
11991
+ readonly id: "mcp-tool-capability-risk";
12406
11992
  readonly source: "react-doctor";
12407
11993
  readonly originallyExternal: false;
12408
11994
  readonly rule: {
12409
11995
  readonly framework: "global";
12410
- readonly category: "Bugs";
11996
+ readonly category: "Security";
11997
+ readonly tags: readonly string[];
12411
11998
  readonly id: string;
12412
11999
  readonly title?: string;
12413
12000
  readonly severity: RuleSeverity;
12414
12001
  readonly requires?: ReadonlyArray<Capability>;
12415
12002
  readonly disabledWhen?: ReadonlyArray<Capability>;
12416
- readonly tags?: ReadonlyArray<string>;
12417
12003
  readonly matchByOccurrence?: boolean;
12418
12004
  readonly defaultEnabled?: boolean;
12419
12005
  readonly lifecycle?: "retired";
@@ -12424,19 +12010,19 @@ declare const RULES: readonly [{
12424
12010
  readonly create: (context: RuleContext) => RuleVisitors;
12425
12011
  };
12426
12012
  }, {
12427
- readonly key: "react-doctor/mobx-no-observer-wrapped-memo";
12428
- readonly id: "mobx-no-observer-wrapped-memo";
12013
+ readonly key: "react-doctor/mdx-ssr-execution-risk";
12014
+ readonly id: "mdx-ssr-execution-risk";
12429
12015
  readonly source: "react-doctor";
12430
12016
  readonly originallyExternal: false;
12431
12017
  readonly rule: {
12432
12018
  readonly framework: "global";
12433
- readonly category: "Bugs";
12019
+ readonly category: "Security";
12020
+ readonly tags: readonly string[];
12434
12021
  readonly id: string;
12435
12022
  readonly title?: string;
12436
12023
  readonly severity: RuleSeverity;
12437
12024
  readonly requires?: ReadonlyArray<Capability>;
12438
12025
  readonly disabledWhen?: ReadonlyArray<Capability>;
12439
- readonly tags?: ReadonlyArray<string>;
12440
12026
  readonly matchByOccurrence?: boolean;
12441
12027
  readonly defaultEnabled?: boolean;
12442
12028
  readonly lifecycle?: "retired";
@@ -12447,17 +12033,17 @@ declare const RULES: readonly [{
12447
12033
  readonly create: (context: RuleContext) => RuleVisitors;
12448
12034
  };
12449
12035
  }, {
12450
- readonly key: "react-doctor/mobx-reaction-disposer-discarded";
12451
- readonly id: "mobx-reaction-disposer-discarded";
12036
+ readonly key: "react-doctor/media-has-caption";
12037
+ readonly id: "media-has-caption";
12452
12038
  readonly source: "react-doctor";
12453
- readonly originallyExternal: false;
12039
+ readonly originallyExternal: true;
12454
12040
  readonly rule: {
12455
12041
  readonly framework: "global";
12456
- readonly category: "Bugs";
12042
+ readonly category: "Accessibility";
12043
+ readonly requires: readonly Capability[];
12457
12044
  readonly id: string;
12458
12045
  readonly title?: string;
12459
12046
  readonly severity: RuleSeverity;
12460
- readonly requires?: ReadonlyArray<Capability>;
12461
12047
  readonly disabledWhen?: ReadonlyArray<Capability>;
12462
12048
  readonly tags?: ReadonlyArray<string>;
12463
12049
  readonly matchByOccurrence?: boolean;
@@ -16316,215 +15902,8 @@ declare const RULES: readonly [{
16316
15902
  readonly source: "react-doctor";
16317
15903
  readonly originallyExternal: false;
16318
15904
  readonly rule: {
16319
- readonly framework: "global";
16320
- readonly category: "Maintainability";
16321
- readonly id: string;
16322
- readonly title?: string;
16323
- readonly severity: RuleSeverity;
16324
- readonly requires?: ReadonlyArray<Capability>;
16325
- readonly disabledWhen?: ReadonlyArray<Capability>;
16326
- readonly tags?: ReadonlyArray<string>;
16327
- readonly matchByOccurrence?: boolean;
16328
- readonly defaultEnabled?: boolean;
16329
- readonly lifecycle?: "retired";
16330
- readonly scan?: FileScan;
16331
- readonly committedFilesOnly?: boolean;
16332
- readonly recommendation?: string;
16333
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16334
- readonly create: (context: RuleContext) => RuleVisitors;
16335
- };
16336
- }, {
16337
- readonly key: "react-doctor/prefer-module-scope-static-value";
16338
- readonly id: "prefer-module-scope-static-value";
16339
- readonly source: "react-doctor";
16340
- readonly originallyExternal: false;
16341
- readonly rule: {
16342
- readonly framework: "global";
16343
- readonly category: "Maintainability";
16344
- readonly id: string;
16345
- readonly title?: string;
16346
- readonly severity: RuleSeverity;
16347
- readonly requires?: ReadonlyArray<Capability>;
16348
- readonly disabledWhen?: ReadonlyArray<Capability>;
16349
- readonly tags?: ReadonlyArray<string>;
16350
- readonly matchByOccurrence?: boolean;
16351
- readonly defaultEnabled?: boolean;
16352
- readonly lifecycle?: "retired";
16353
- readonly scan?: FileScan;
16354
- readonly committedFilesOnly?: boolean;
16355
- readonly recommendation?: string;
16356
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16357
- readonly create: (context: RuleContext) => RuleVisitors;
16358
- };
16359
- }, {
16360
- readonly key: "react-doctor/prefer-stable-empty-fallback";
16361
- readonly id: "prefer-stable-empty-fallback";
16362
- readonly source: "react-doctor";
16363
- readonly originallyExternal: false;
16364
- readonly rule: {
16365
- readonly framework: "global";
16366
- readonly category: "Performance";
16367
- readonly requires: readonly Capability[];
16368
- readonly id: string;
16369
- readonly title?: string;
16370
- readonly severity: RuleSeverity;
16371
- readonly disabledWhen?: ReadonlyArray<Capability>;
16372
- readonly tags?: ReadonlyArray<string>;
16373
- readonly matchByOccurrence?: boolean;
16374
- readonly defaultEnabled?: boolean;
16375
- readonly lifecycle?: "retired";
16376
- readonly scan?: FileScan;
16377
- readonly committedFilesOnly?: boolean;
16378
- readonly recommendation?: string;
16379
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16380
- readonly create: (context: RuleContext) => RuleVisitors;
16381
- };
16382
- }, {
16383
- readonly key: "react-doctor/prefer-tag-over-role";
16384
- readonly id: "prefer-tag-over-role";
16385
- readonly source: "react-doctor";
16386
- readonly originallyExternal: true;
16387
- readonly rule: {
16388
- readonly framework: "global";
16389
- readonly category: "Accessibility";
16390
- readonly requires: readonly Capability[];
16391
- readonly id: string;
16392
- readonly title?: string;
16393
- readonly severity: RuleSeverity;
16394
- readonly disabledWhen?: ReadonlyArray<Capability>;
16395
- readonly tags?: ReadonlyArray<string>;
16396
- readonly matchByOccurrence?: boolean;
16397
- readonly defaultEnabled?: boolean;
16398
- readonly lifecycle?: "retired";
16399
- readonly scan?: FileScan;
16400
- readonly committedFilesOnly?: boolean;
16401
- readonly recommendation?: string;
16402
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16403
- readonly create: (context: RuleContext) => RuleVisitors;
16404
- };
16405
- }, {
16406
- readonly key: "react-doctor/prefer-use-effect-event";
16407
- readonly id: "prefer-use-effect-event";
16408
- readonly source: "react-doctor";
16409
- readonly originallyExternal: false;
16410
- readonly rule: {
16411
- readonly framework: "global";
16412
- readonly category: "Bugs";
16413
- readonly requires: readonly Capability[];
16414
- readonly id: string;
16415
- readonly title?: string;
16416
- readonly severity: RuleSeverity;
16417
- readonly disabledWhen?: ReadonlyArray<Capability>;
16418
- readonly tags?: ReadonlyArray<string>;
16419
- readonly matchByOccurrence?: boolean;
16420
- readonly defaultEnabled?: boolean;
16421
- readonly lifecycle?: "retired";
16422
- readonly scan?: FileScan;
16423
- readonly committedFilesOnly?: boolean;
16424
- readonly recommendation?: string;
16425
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16426
- readonly create: (context: RuleContext) => RuleVisitors;
16427
- };
16428
- }, {
16429
- readonly key: "react-doctor/prefer-use-sync-external-store";
16430
- readonly id: "prefer-use-sync-external-store";
16431
- readonly source: "react-doctor";
16432
- readonly originallyExternal: false;
16433
- readonly rule: {
16434
- readonly framework: "global";
16435
- readonly category: "Bugs";
16436
- readonly requires: readonly Capability[];
16437
- readonly id: string;
16438
- readonly title?: string;
16439
- readonly severity: RuleSeverity;
16440
- readonly disabledWhen?: ReadonlyArray<Capability>;
16441
- readonly tags?: ReadonlyArray<string>;
16442
- readonly matchByOccurrence?: boolean;
16443
- readonly defaultEnabled?: boolean;
16444
- readonly lifecycle?: "retired";
16445
- readonly scan?: FileScan;
16446
- readonly committedFilesOnly?: boolean;
16447
- readonly recommendation?: string;
16448
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16449
- readonly create: (context: RuleContext) => RuleVisitors;
16450
- };
16451
- }, {
16452
- readonly key: "react-doctor/prefer-useReducer";
16453
- readonly id: "prefer-useReducer";
16454
- readonly source: "react-doctor";
16455
- readonly originallyExternal: false;
16456
- readonly rule: {
16457
- readonly framework: "global";
16458
- readonly category: "Bugs";
16459
- readonly requires: readonly Capability[];
16460
- readonly id: string;
16461
- readonly title?: string;
16462
- readonly severity: RuleSeverity;
16463
- readonly disabledWhen?: ReadonlyArray<Capability>;
16464
- readonly tags?: ReadonlyArray<string>;
16465
- readonly matchByOccurrence?: boolean;
16466
- readonly defaultEnabled?: boolean;
16467
- readonly lifecycle?: "retired";
16468
- readonly scan?: FileScan;
16469
- readonly committedFilesOnly?: boolean;
16470
- readonly recommendation?: string;
16471
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16472
- readonly create: (context: RuleContext) => RuleVisitors;
16473
- };
16474
- }, {
16475
- readonly key: "react-doctor/public-debug-artifact";
16476
- readonly id: "public-debug-artifact";
16477
- readonly source: "react-doctor";
16478
- readonly originallyExternal: false;
16479
- readonly rule: {
16480
- readonly framework: "global";
16481
- readonly category: "Security";
16482
- readonly tags: readonly string[];
16483
- readonly id: string;
16484
- readonly title?: string;
16485
- readonly severity: RuleSeverity;
16486
- readonly requires?: ReadonlyArray<Capability>;
16487
- readonly disabledWhen?: ReadonlyArray<Capability>;
16488
- readonly matchByOccurrence?: boolean;
16489
- readonly defaultEnabled?: boolean;
16490
- readonly lifecycle?: "retired";
16491
- readonly scan?: FileScan;
16492
- readonly committedFilesOnly?: boolean;
16493
- readonly recommendation?: string;
16494
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16495
- readonly create: (context: RuleContext) => RuleVisitors;
16496
- };
16497
- }, {
16498
- readonly key: "react-doctor/public-env-secret-name";
16499
- readonly id: "public-env-secret-name";
16500
- readonly source: "react-doctor";
16501
- readonly originallyExternal: false;
16502
- readonly rule: {
16503
- readonly framework: "global";
16504
- readonly category: "Security";
16505
- readonly tags: readonly string[];
16506
- readonly id: string;
16507
- readonly title?: string;
16508
- readonly severity: RuleSeverity;
16509
- readonly requires?: ReadonlyArray<Capability>;
16510
- readonly disabledWhen?: ReadonlyArray<Capability>;
16511
- readonly matchByOccurrence?: boolean;
16512
- readonly defaultEnabled?: boolean;
16513
- readonly lifecycle?: "retired";
16514
- readonly scan?: FileScan;
16515
- readonly committedFilesOnly?: boolean;
16516
- readonly recommendation?: string;
16517
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16518
- readonly create: (context: RuleContext) => RuleVisitors;
16519
- };
16520
- }, {
16521
- readonly key: "react-doctor/query-destructure-result";
16522
- readonly id: "query-destructure-result";
16523
- readonly source: "react-doctor";
16524
- readonly originallyExternal: false;
16525
- readonly rule: {
16526
- readonly framework: "tanstack-query";
16527
- readonly category: "Bugs";
15905
+ readonly framework: "global";
15906
+ readonly category: "Maintainability";
16528
15907
  readonly id: string;
16529
15908
  readonly title?: string;
16530
15909
  readonly severity: RuleSeverity;
@@ -16541,13 +15920,13 @@ declare const RULES: readonly [{
16541
15920
  readonly create: (context: RuleContext) => RuleVisitors;
16542
15921
  };
16543
15922
  }, {
16544
- readonly key: "react-doctor/query-mutation-missing-invalidation";
16545
- readonly id: "query-mutation-missing-invalidation";
15923
+ readonly key: "react-doctor/prefer-module-scope-static-value";
15924
+ readonly id: "prefer-module-scope-static-value";
16546
15925
  readonly source: "react-doctor";
16547
15926
  readonly originallyExternal: false;
16548
15927
  readonly rule: {
16549
- readonly framework: "tanstack-query";
16550
- readonly category: "Bugs";
15928
+ readonly framework: "global";
15929
+ readonly category: "Maintainability";
16551
15930
  readonly id: string;
16552
15931
  readonly title?: string;
16553
15932
  readonly severity: RuleSeverity;
@@ -16564,17 +15943,17 @@ declare const RULES: readonly [{
16564
15943
  readonly create: (context: RuleContext) => RuleVisitors;
16565
15944
  };
16566
15945
  }, {
16567
- readonly key: "react-doctor/query-no-query-in-effect";
16568
- readonly id: "query-no-query-in-effect";
15946
+ readonly key: "react-doctor/prefer-stable-empty-fallback";
15947
+ readonly id: "prefer-stable-empty-fallback";
16569
15948
  readonly source: "react-doctor";
16570
15949
  readonly originallyExternal: false;
16571
15950
  readonly rule: {
16572
- readonly framework: "tanstack-query";
16573
- readonly category: "Bugs";
15951
+ readonly framework: "global";
15952
+ readonly category: "Performance";
15953
+ readonly requires: readonly Capability[];
16574
15954
  readonly id: string;
16575
15955
  readonly title?: string;
16576
15956
  readonly severity: RuleSeverity;
16577
- readonly requires?: ReadonlyArray<Capability>;
16578
15957
  readonly disabledWhen?: ReadonlyArray<Capability>;
16579
15958
  readonly tags?: ReadonlyArray<string>;
16580
15959
  readonly matchByOccurrence?: boolean;
@@ -16587,17 +15966,17 @@ declare const RULES: readonly [{
16587
15966
  readonly create: (context: RuleContext) => RuleVisitors;
16588
15967
  };
16589
15968
  }, {
16590
- readonly key: "react-doctor/query-no-rest-destructuring";
16591
- readonly id: "query-no-rest-destructuring";
15969
+ readonly key: "react-doctor/prefer-tag-over-role";
15970
+ readonly id: "prefer-tag-over-role";
16592
15971
  readonly source: "react-doctor";
16593
- readonly originallyExternal: false;
15972
+ readonly originallyExternal: true;
16594
15973
  readonly rule: {
16595
- readonly framework: "tanstack-query";
16596
- readonly category: "Bugs";
15974
+ readonly framework: "global";
15975
+ readonly category: "Accessibility";
15976
+ readonly requires: readonly Capability[];
16597
15977
  readonly id: string;
16598
15978
  readonly title?: string;
16599
15979
  readonly severity: RuleSeverity;
16600
- readonly requires?: ReadonlyArray<Capability>;
16601
15980
  readonly disabledWhen?: ReadonlyArray<Capability>;
16602
15981
  readonly tags?: ReadonlyArray<string>;
16603
15982
  readonly matchByOccurrence?: boolean;
@@ -16610,17 +15989,17 @@ declare const RULES: readonly [{
16610
15989
  readonly create: (context: RuleContext) => RuleVisitors;
16611
15990
  };
16612
15991
  }, {
16613
- readonly key: "react-doctor/query-no-usequery-for-mutation";
16614
- readonly id: "query-no-usequery-for-mutation";
15992
+ readonly key: "react-doctor/prefer-use-effect-event";
15993
+ readonly id: "prefer-use-effect-event";
16615
15994
  readonly source: "react-doctor";
16616
15995
  readonly originallyExternal: false;
16617
15996
  readonly rule: {
16618
- readonly framework: "tanstack-query";
15997
+ readonly framework: "global";
16619
15998
  readonly category: "Bugs";
15999
+ readonly requires: readonly Capability[];
16620
16000
  readonly id: string;
16621
16001
  readonly title?: string;
16622
16002
  readonly severity: RuleSeverity;
16623
- readonly requires?: ReadonlyArray<Capability>;
16624
16003
  readonly disabledWhen?: ReadonlyArray<Capability>;
16625
16004
  readonly tags?: ReadonlyArray<string>;
16626
16005
  readonly matchByOccurrence?: boolean;
@@ -16633,17 +16012,17 @@ declare const RULES: readonly [{
16633
16012
  readonly create: (context: RuleContext) => RuleVisitors;
16634
16013
  };
16635
16014
  }, {
16636
- readonly key: "react-doctor/query-no-void-query-fn";
16637
- readonly id: "query-no-void-query-fn";
16015
+ readonly key: "react-doctor/prefer-use-sync-external-store";
16016
+ readonly id: "prefer-use-sync-external-store";
16638
16017
  readonly source: "react-doctor";
16639
16018
  readonly originallyExternal: false;
16640
16019
  readonly rule: {
16641
- readonly framework: "tanstack-query";
16020
+ readonly framework: "global";
16642
16021
  readonly category: "Bugs";
16022
+ readonly requires: readonly Capability[];
16643
16023
  readonly id: string;
16644
16024
  readonly title?: string;
16645
16025
  readonly severity: RuleSeverity;
16646
- readonly requires?: ReadonlyArray<Capability>;
16647
16026
  readonly disabledWhen?: ReadonlyArray<Capability>;
16648
16027
  readonly tags?: ReadonlyArray<string>;
16649
16028
  readonly matchByOccurrence?: boolean;
@@ -16656,17 +16035,17 @@ declare const RULES: readonly [{
16656
16035
  readonly create: (context: RuleContext) => RuleVisitors;
16657
16036
  };
16658
16037
  }, {
16659
- readonly key: "react-doctor/query-stable-query-client";
16660
- readonly id: "query-stable-query-client";
16038
+ readonly key: "react-doctor/prefer-useReducer";
16039
+ readonly id: "prefer-useReducer";
16661
16040
  readonly source: "react-doctor";
16662
16041
  readonly originallyExternal: false;
16663
16042
  readonly rule: {
16664
- readonly framework: "tanstack-query";
16043
+ readonly framework: "global";
16665
16044
  readonly category: "Bugs";
16045
+ readonly requires: readonly Capability[];
16666
16046
  readonly id: string;
16667
16047
  readonly title?: string;
16668
16048
  readonly severity: RuleSeverity;
16669
- readonly requires?: ReadonlyArray<Capability>;
16670
16049
  readonly disabledWhen?: ReadonlyArray<Capability>;
16671
16050
  readonly tags?: ReadonlyArray<string>;
16672
16051
  readonly matchByOccurrence?: boolean;
@@ -16679,8 +16058,8 @@ declare const RULES: readonly [{
16679
16058
  readonly create: (context: RuleContext) => RuleVisitors;
16680
16059
  };
16681
16060
  }, {
16682
- readonly key: "react-doctor/raw-sql-injection-risk";
16683
- readonly id: "raw-sql-injection-risk";
16061
+ readonly key: "react-doctor/public-debug-artifact";
16062
+ readonly id: "public-debug-artifact";
16684
16063
  readonly source: "react-doctor";
16685
16064
  readonly originallyExternal: false;
16686
16065
  readonly rule: {
@@ -16702,19 +16081,19 @@ declare const RULES: readonly [{
16702
16081
  readonly create: (context: RuleContext) => RuleVisitors;
16703
16082
  };
16704
16083
  }, {
16705
- readonly key: "react-doctor/react-compiler-no-manual-memoization";
16706
- readonly id: "react-compiler-no-manual-memoization";
16084
+ readonly key: "react-doctor/public-env-secret-name";
16085
+ readonly id: "public-env-secret-name";
16707
16086
  readonly source: "react-doctor";
16708
16087
  readonly originallyExternal: false;
16709
16088
  readonly rule: {
16710
16089
  readonly framework: "global";
16711
- readonly category: "Maintainability";
16090
+ readonly category: "Security";
16091
+ readonly tags: readonly string[];
16712
16092
  readonly id: string;
16713
16093
  readonly title?: string;
16714
16094
  readonly severity: RuleSeverity;
16715
16095
  readonly requires?: ReadonlyArray<Capability>;
16716
16096
  readonly disabledWhen?: ReadonlyArray<Capability>;
16717
- readonly tags?: ReadonlyArray<string>;
16718
16097
  readonly matchByOccurrence?: boolean;
16719
16098
  readonly defaultEnabled?: boolean;
16720
16099
  readonly lifecycle?: "retired";
@@ -16725,17 +16104,17 @@ declare const RULES: readonly [{
16725
16104
  readonly create: (context: RuleContext) => RuleVisitors;
16726
16105
  };
16727
16106
  }, {
16728
- readonly key: "react-doctor/react-in-jsx-scope";
16729
- readonly id: "react-in-jsx-scope";
16107
+ readonly key: "react-doctor/query-destructure-result";
16108
+ readonly id: "query-destructure-result";
16730
16109
  readonly source: "react-doctor";
16731
- readonly originallyExternal: true;
16110
+ readonly originallyExternal: false;
16732
16111
  readonly rule: {
16733
- readonly framework: "global";
16112
+ readonly framework: "tanstack-query";
16734
16113
  readonly category: "Bugs";
16735
- readonly requires: readonly Capability[];
16736
16114
  readonly id: string;
16737
16115
  readonly title?: string;
16738
16116
  readonly severity: RuleSeverity;
16117
+ readonly requires?: ReadonlyArray<Capability>;
16739
16118
  readonly disabledWhen?: ReadonlyArray<Capability>;
16740
16119
  readonly tags?: ReadonlyArray<string>;
16741
16120
  readonly matchByOccurrence?: boolean;
@@ -16748,13 +16127,13 @@ declare const RULES: readonly [{
16748
16127
  readonly create: (context: RuleContext) => RuleVisitors;
16749
16128
  };
16750
16129
  }, {
16751
- readonly key: "react-doctor/react-markdown-unsanitized-raw-html";
16752
- readonly id: "react-markdown-unsanitized-raw-html";
16130
+ readonly key: "react-doctor/query-mutation-missing-invalidation";
16131
+ readonly id: "query-mutation-missing-invalidation";
16753
16132
  readonly source: "react-doctor";
16754
16133
  readonly originallyExternal: false;
16755
16134
  readonly rule: {
16756
- readonly framework: "global";
16757
- readonly category: "Security";
16135
+ readonly framework: "tanstack-query";
16136
+ readonly category: "Bugs";
16758
16137
  readonly id: string;
16759
16138
  readonly title?: string;
16760
16139
  readonly severity: RuleSeverity;
@@ -16771,17 +16150,17 @@ declare const RULES: readonly [{
16771
16150
  readonly create: (context: RuleContext) => RuleVisitors;
16772
16151
  };
16773
16152
  }, {
16774
- readonly key: "react-doctor/redux-useselector-inline-derivation";
16775
- readonly id: "redux-useselector-inline-derivation";
16153
+ readonly key: "react-doctor/query-no-query-in-effect";
16154
+ readonly id: "query-no-query-in-effect";
16776
16155
  readonly source: "react-doctor";
16777
16156
  readonly originallyExternal: false;
16778
16157
  readonly rule: {
16779
- readonly framework: "global";
16780
- readonly category: "Performance";
16781
- readonly requires: readonly Capability[];
16158
+ readonly framework: "tanstack-query";
16159
+ readonly category: "Bugs";
16782
16160
  readonly id: string;
16783
16161
  readonly title?: string;
16784
16162
  readonly severity: RuleSeverity;
16163
+ readonly requires?: ReadonlyArray<Capability>;
16785
16164
  readonly disabledWhen?: ReadonlyArray<Capability>;
16786
16165
  readonly tags?: ReadonlyArray<string>;
16787
16166
  readonly matchByOccurrence?: boolean;
@@ -16794,17 +16173,17 @@ declare const RULES: readonly [{
16794
16173
  readonly create: (context: RuleContext) => RuleVisitors;
16795
16174
  };
16796
16175
  }, {
16797
- readonly key: "react-doctor/redux-useselector-returns-new-collection";
16798
- readonly id: "redux-useselector-returns-new-collection";
16176
+ readonly key: "react-doctor/query-no-rest-destructuring";
16177
+ readonly id: "query-no-rest-destructuring";
16799
16178
  readonly source: "react-doctor";
16800
16179
  readonly originallyExternal: false;
16801
16180
  readonly rule: {
16802
- readonly framework: "global";
16803
- readonly category: "Performance";
16804
- readonly requires: readonly Capability[];
16181
+ readonly framework: "tanstack-query";
16182
+ readonly category: "Bugs";
16805
16183
  readonly id: string;
16806
16184
  readonly title?: string;
16807
16185
  readonly severity: RuleSeverity;
16186
+ readonly requires?: ReadonlyArray<Capability>;
16808
16187
  readonly disabledWhen?: ReadonlyArray<Capability>;
16809
16188
  readonly tags?: ReadonlyArray<string>;
16810
16189
  readonly matchByOccurrence?: boolean;
@@ -16817,12 +16196,12 @@ declare const RULES: readonly [{
16817
16196
  readonly create: (context: RuleContext) => RuleVisitors;
16818
16197
  };
16819
16198
  }, {
16820
- readonly key: "react-doctor/remotion-calculate-metadata-fetch-signal";
16821
- readonly id: "remotion-calculate-metadata-fetch-signal";
16199
+ readonly key: "react-doctor/query-no-usequery-for-mutation";
16200
+ readonly id: "query-no-usequery-for-mutation";
16822
16201
  readonly source: "react-doctor";
16823
16202
  readonly originallyExternal: false;
16824
16203
  readonly rule: {
16825
- readonly framework: "global";
16204
+ readonly framework: "tanstack-query";
16826
16205
  readonly category: "Bugs";
16827
16206
  readonly id: string;
16828
16207
  readonly title?: string;
@@ -16840,12 +16219,12 @@ declare const RULES: readonly [{
16840
16219
  readonly create: (context: RuleContext) => RuleVisitors;
16841
16220
  };
16842
16221
  }, {
16843
- readonly key: "react-doctor/remotion-deterministic-randomness";
16844
- readonly id: "remotion-deterministic-randomness";
16222
+ readonly key: "react-doctor/query-no-void-query-fn";
16223
+ readonly id: "query-no-void-query-fn";
16845
16224
  readonly source: "react-doctor";
16846
16225
  readonly originallyExternal: false;
16847
16226
  readonly rule: {
16848
- readonly framework: "global";
16227
+ readonly framework: "tanstack-query";
16849
16228
  readonly category: "Bugs";
16850
16229
  readonly id: string;
16851
16230
  readonly title?: string;
@@ -16863,12 +16242,12 @@ declare const RULES: readonly [{
16863
16242
  readonly create: (context: RuleContext) => RuleVisitors;
16864
16243
  };
16865
16244
  }, {
16866
- readonly key: "react-doctor/remotion-no-css-animation";
16867
- readonly id: "remotion-no-css-animation";
16245
+ readonly key: "react-doctor/query-stable-query-client";
16246
+ readonly id: "query-stable-query-client";
16868
16247
  readonly source: "react-doctor";
16869
16248
  readonly originallyExternal: false;
16870
16249
  readonly rule: {
16871
- readonly framework: "global";
16250
+ readonly framework: "tanstack-query";
16872
16251
  readonly category: "Bugs";
16873
16252
  readonly id: string;
16874
16253
  readonly title?: string;
@@ -16886,19 +16265,19 @@ declare const RULES: readonly [{
16886
16265
  readonly create: (context: RuleContext) => RuleVisitors;
16887
16266
  };
16888
16267
  }, {
16889
- readonly key: "react-doctor/remotion-no-css-transition";
16890
- readonly id: "remotion-no-css-transition";
16268
+ readonly key: "react-doctor/raw-sql-injection-risk";
16269
+ readonly id: "raw-sql-injection-risk";
16891
16270
  readonly source: "react-doctor";
16892
16271
  readonly originallyExternal: false;
16893
16272
  readonly rule: {
16894
16273
  readonly framework: "global";
16895
- readonly category: "Bugs";
16274
+ readonly category: "Security";
16275
+ readonly tags: readonly string[];
16896
16276
  readonly id: string;
16897
16277
  readonly title?: string;
16898
16278
  readonly severity: RuleSeverity;
16899
16279
  readonly requires?: ReadonlyArray<Capability>;
16900
16280
  readonly disabledWhen?: ReadonlyArray<Capability>;
16901
- readonly tags?: ReadonlyArray<string>;
16902
16281
  readonly matchByOccurrence?: boolean;
16903
16282
  readonly defaultEnabled?: boolean;
16904
16283
  readonly lifecycle?: "retired";
@@ -16909,13 +16288,13 @@ declare const RULES: readonly [{
16909
16288
  readonly create: (context: RuleContext) => RuleVisitors;
16910
16289
  };
16911
16290
  }, {
16912
- readonly key: "react-doctor/remotion-no-css-url-assets";
16913
- readonly id: "remotion-no-css-url-assets";
16291
+ readonly key: "react-doctor/react-compiler-no-manual-memoization";
16292
+ readonly id: "react-compiler-no-manual-memoization";
16914
16293
  readonly source: "react-doctor";
16915
16294
  readonly originallyExternal: false;
16916
16295
  readonly rule: {
16917
16296
  readonly framework: "global";
16918
- readonly category: "Bugs";
16297
+ readonly category: "Maintainability";
16919
16298
  readonly id: string;
16920
16299
  readonly title?: string;
16921
16300
  readonly severity: RuleSeverity;
@@ -16932,17 +16311,17 @@ declare const RULES: readonly [{
16932
16311
  readonly create: (context: RuleContext) => RuleVisitors;
16933
16312
  };
16934
16313
  }, {
16935
- readonly key: "react-doctor/remotion-no-module-scope-delay-render";
16936
- readonly id: "remotion-no-module-scope-delay-render";
16314
+ readonly key: "react-doctor/react-in-jsx-scope";
16315
+ readonly id: "react-in-jsx-scope";
16937
16316
  readonly source: "react-doctor";
16938
- readonly originallyExternal: false;
16317
+ readonly originallyExternal: true;
16939
16318
  readonly rule: {
16940
16319
  readonly framework: "global";
16941
16320
  readonly category: "Bugs";
16321
+ readonly requires: readonly Capability[];
16942
16322
  readonly id: string;
16943
16323
  readonly title?: string;
16944
16324
  readonly severity: RuleSeverity;
16945
- readonly requires?: ReadonlyArray<Capability>;
16946
16325
  readonly disabledWhen?: ReadonlyArray<Capability>;
16947
16326
  readonly tags?: ReadonlyArray<string>;
16948
16327
  readonly matchByOccurrence?: boolean;
@@ -16955,13 +16334,13 @@ declare const RULES: readonly [{
16955
16334
  readonly create: (context: RuleContext) => RuleVisitors;
16956
16335
  };
16957
16336
  }, {
16958
- readonly key: "react-doctor/remotion-no-native-media-elements";
16959
- readonly id: "remotion-no-native-media-elements";
16337
+ readonly key: "react-doctor/react-markdown-unsanitized-raw-html";
16338
+ readonly id: "react-markdown-unsanitized-raw-html";
16960
16339
  readonly source: "react-doctor";
16961
16340
  readonly originallyExternal: false;
16962
16341
  readonly rule: {
16963
16342
  readonly framework: "global";
16964
- readonly category: "Bugs";
16343
+ readonly category: "Security";
16965
16344
  readonly id: string;
16966
16345
  readonly title?: string;
16967
16346
  readonly severity: RuleSeverity;
@@ -16978,17 +16357,17 @@ declare const RULES: readonly [{
16978
16357
  readonly create: (context: RuleContext) => RuleVisitors;
16979
16358
  };
16980
16359
  }, {
16981
- readonly key: "react-doctor/remotion-no-next-image";
16982
- readonly id: "remotion-no-next-image";
16360
+ readonly key: "react-doctor/redux-useselector-inline-derivation";
16361
+ readonly id: "redux-useselector-inline-derivation";
16983
16362
  readonly source: "react-doctor";
16984
16363
  readonly originallyExternal: false;
16985
16364
  readonly rule: {
16986
16365
  readonly framework: "global";
16987
- readonly category: "Bugs";
16366
+ readonly category: "Performance";
16367
+ readonly requires: readonly Capability[];
16988
16368
  readonly id: string;
16989
16369
  readonly title?: string;
16990
16370
  readonly severity: RuleSeverity;
16991
- readonly requires?: ReadonlyArray<Capability>;
16992
16371
  readonly disabledWhen?: ReadonlyArray<Capability>;
16993
16372
  readonly tags?: ReadonlyArray<string>;
16994
16373
  readonly matchByOccurrence?: boolean;
@@ -17001,17 +16380,17 @@ declare const RULES: readonly [{
17001
16380
  readonly create: (context: RuleContext) => RuleVisitors;
17002
16381
  };
17003
16382
  }, {
17004
- readonly key: "react-doctor/remotion-stable-delay-render-handle";
17005
- readonly id: "remotion-stable-delay-render-handle";
16383
+ readonly key: "react-doctor/redux-useselector-returns-new-collection";
16384
+ readonly id: "redux-useselector-returns-new-collection";
17006
16385
  readonly source: "react-doctor";
17007
16386
  readonly originallyExternal: false;
17008
16387
  readonly rule: {
17009
16388
  readonly framework: "global";
17010
- readonly category: "Bugs";
16389
+ readonly category: "Performance";
16390
+ readonly requires: readonly Capability[];
17011
16391
  readonly id: string;
17012
16392
  readonly title?: string;
17013
16393
  readonly severity: RuleSeverity;
17014
- readonly requires?: ReadonlyArray<Capability>;
17015
16394
  readonly disabledWhen?: ReadonlyArray<Capability>;
17016
16395
  readonly tags?: ReadonlyArray<string>;
17017
16396
  readonly matchByOccurrence?: boolean;
@@ -19208,52 +18587,6 @@ declare const RULES: readonly [{
19208
18587
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19209
18588
  readonly create: (context: RuleContext) => RuleVisitors;
19210
18589
  };
19211
- }, {
19212
- readonly key: "react-doctor/valtio-no-proxy-read-in-render";
19213
- readonly id: "valtio-no-proxy-read-in-render";
19214
- readonly source: "react-doctor";
19215
- readonly originallyExternal: false;
19216
- readonly rule: {
19217
- readonly framework: "global";
19218
- readonly category: "Bugs";
19219
- readonly requires: readonly Capability[];
19220
- readonly id: string;
19221
- readonly title?: string;
19222
- readonly severity: RuleSeverity;
19223
- readonly disabledWhen?: ReadonlyArray<Capability>;
19224
- readonly tags?: ReadonlyArray<string>;
19225
- readonly matchByOccurrence?: boolean;
19226
- readonly defaultEnabled?: boolean;
19227
- readonly lifecycle?: "retired";
19228
- readonly scan?: FileScan;
19229
- readonly committedFilesOnly?: boolean;
19230
- readonly recommendation?: string;
19231
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19232
- readonly create: (context: RuleContext) => RuleVisitors;
19233
- };
19234
- }, {
19235
- readonly key: "react-doctor/valtio-no-snapshot-in-callback";
19236
- readonly id: "valtio-no-snapshot-in-callback";
19237
- readonly source: "react-doctor";
19238
- readonly originallyExternal: false;
19239
- readonly rule: {
19240
- readonly framework: "global";
19241
- readonly category: "Bugs";
19242
- readonly requires: readonly Capability[];
19243
- readonly id: string;
19244
- readonly title?: string;
19245
- readonly severity: RuleSeverity;
19246
- readonly disabledWhen?: ReadonlyArray<Capability>;
19247
- readonly tags?: ReadonlyArray<string>;
19248
- readonly matchByOccurrence?: boolean;
19249
- readonly defaultEnabled?: boolean;
19250
- readonly lifecycle?: "retired";
19251
- readonly scan?: FileScan;
19252
- readonly committedFilesOnly?: boolean;
19253
- readonly recommendation?: string;
19254
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19255
- readonly create: (context: RuleContext) => RuleVisitors;
19256
- };
19257
18590
  }, {
19258
18591
  readonly key: "react-doctor/void-dom-elements-no-children";
19259
18592
  readonly id: "void-dom-elements-no-children";
@@ -19392,75 +18725,6 @@ declare const RULES: readonly [{
19392
18725
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19393
18726
  readonly create: (context: RuleContext) => RuleVisitors;
19394
18727
  };
19395
- }, {
19396
- readonly key: "react-doctor/zustand-no-fresh-selector-result";
19397
- readonly id: "zustand-no-fresh-selector-result";
19398
- readonly source: "react-doctor";
19399
- readonly originallyExternal: false;
19400
- readonly rule: {
19401
- readonly framework: "global";
19402
- readonly category: "Performance";
19403
- readonly requires: readonly Capability[];
19404
- readonly id: string;
19405
- readonly title?: string;
19406
- readonly severity: RuleSeverity;
19407
- readonly disabledWhen?: ReadonlyArray<Capability>;
19408
- readonly tags?: ReadonlyArray<string>;
19409
- readonly matchByOccurrence?: boolean;
19410
- readonly defaultEnabled?: boolean;
19411
- readonly lifecycle?: "retired";
19412
- readonly scan?: FileScan;
19413
- readonly committedFilesOnly?: boolean;
19414
- readonly recommendation?: string;
19415
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19416
- readonly create: (context: RuleContext) => RuleVisitors;
19417
- };
19418
- }, {
19419
- readonly key: "react-doctor/zustand-no-get-during-initialization";
19420
- readonly id: "zustand-no-get-during-initialization";
19421
- readonly source: "react-doctor";
19422
- readonly originallyExternal: false;
19423
- readonly rule: {
19424
- readonly framework: "global";
19425
- readonly category: "Bugs";
19426
- readonly requires: readonly Capability[];
19427
- readonly id: string;
19428
- readonly title?: string;
19429
- readonly severity: RuleSeverity;
19430
- readonly disabledWhen?: ReadonlyArray<Capability>;
19431
- readonly tags?: ReadonlyArray<string>;
19432
- readonly matchByOccurrence?: boolean;
19433
- readonly defaultEnabled?: boolean;
19434
- readonly lifecycle?: "retired";
19435
- readonly scan?: FileScan;
19436
- readonly committedFilesOnly?: boolean;
19437
- readonly recommendation?: string;
19438
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19439
- readonly create: (context: RuleContext) => RuleVisitors;
19440
- };
19441
- }, {
19442
- readonly key: "react-doctor/zustand-no-whole-store-destructure";
19443
- readonly id: "zustand-no-whole-store-destructure";
19444
- readonly source: "react-doctor";
19445
- readonly originallyExternal: false;
19446
- readonly rule: {
19447
- readonly framework: "global";
19448
- readonly category: "Bugs";
19449
- readonly requires: readonly Capability[];
19450
- readonly id: string;
19451
- readonly title?: string;
19452
- readonly severity: RuleSeverity;
19453
- readonly disabledWhen?: ReadonlyArray<Capability>;
19454
- readonly tags?: ReadonlyArray<string>;
19455
- readonly matchByOccurrence?: boolean;
19456
- readonly defaultEnabled?: boolean;
19457
- readonly lifecycle?: "retired";
19458
- readonly scan?: FileScan;
19459
- readonly committedFilesOnly?: boolean;
19460
- readonly recommendation?: string;
19461
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19462
- readonly create: (context: RuleContext) => RuleVisitors;
19463
- };
19464
18728
  }, {
19465
18729
  readonly key: "react-hooks-js/set-state-in-render";
19466
18730
  readonly source: "react-compiler";
@@ -19484,7 +18748,7 @@ declare const RULES: readonly [{
19484
18748
  }, {
19485
18749
  readonly key: "react-hooks-js/set-state-in-effect";
19486
18750
  readonly source: "react-compiler";
19487
- readonly severity: "warn";
18751
+ readonly severity: "error";
19488
18752
  }, {
19489
18753
  readonly key: "react-hooks-js/globals";
19490
18754
  readonly source: "react-compiler";