oxlint-plugin-react-doctor 0.8.1-dev.7eca0ee → 0.8.1-dev.82c4a12

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 +266 -956
  2. package/dist/index.js +899 -4568
  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,52 +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-whole-store-destructure";
9740
- readonly id: "zustand-no-whole-store-destructure";
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
9416
  }];
9762
9417
  declare const EXTERNAL_RULES: readonly [{
9763
9418
  readonly key: "react-hooks-js/set-state-in-render";
@@ -12078,6 +11733,29 @@ declare const RULES: readonly [{
12078
11733
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12079
11734
  readonly create: (context: RuleContext) => RuleVisitors;
12080
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
+ };
12081
11759
  }, {
12082
11760
  readonly key: "react-doctor/jsx-no-undef";
12083
11761
  readonly id: "jsx-no-undef";
@@ -12245,83 +11923,14 @@ declare const RULES: readonly [{
12245
11923
  readonly source: "react-doctor";
12246
11924
  readonly originallyExternal: true;
12247
11925
  readonly rule: {
12248
- readonly framework: "global";
12249
- readonly category: "Accessibility";
12250
- readonly requires: readonly Capability[];
12251
- readonly id: string;
12252
- readonly title?: string;
12253
- readonly severity: RuleSeverity;
12254
- readonly disabledWhen?: ReadonlyArray<Capability>;
12255
- readonly tags?: ReadonlyArray<string>;
12256
- readonly matchByOccurrence?: boolean;
12257
- readonly defaultEnabled?: boolean;
12258
- readonly lifecycle?: "retired";
12259
- readonly scan?: FileScan;
12260
- readonly committedFilesOnly?: boolean;
12261
- readonly recommendation?: string;
12262
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
12263
- readonly create: (context: RuleContext) => RuleVisitors;
12264
- };
12265
- }, {
12266
- readonly key: "react-doctor/lang";
12267
- readonly id: "lang";
12268
- readonly source: "react-doctor";
12269
- readonly originallyExternal: true;
12270
- readonly rule: {
12271
- readonly framework: "global";
12272
- 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/local-rpc-native-bridge-risk";
12290
- readonly id: "local-rpc-native-bridge-risk";
12291
- readonly source: "react-doctor";
12292
- readonly originallyExternal: false;
12293
- readonly rule: {
12294
- readonly framework: "global";
12295
- readonly category: "Security";
12296
- readonly tags: readonly string[];
12297
- readonly id: string;
12298
- readonly title?: string;
12299
- readonly severity: RuleSeverity;
12300
- readonly requires?: ReadonlyArray<Capability>;
12301
- readonly disabledWhen?: ReadonlyArray<Capability>;
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/mcp-tool-capability-risk";
12313
- readonly id: "mcp-tool-capability-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[];
11926
+ readonly framework: "global";
11927
+ readonly category: "Accessibility";
11928
+ readonly requires: readonly Capability[];
12320
11929
  readonly id: string;
12321
11930
  readonly title?: string;
12322
11931
  readonly severity: RuleSeverity;
12323
- readonly requires?: ReadonlyArray<Capability>;
12324
11932
  readonly disabledWhen?: ReadonlyArray<Capability>;
11933
+ readonly tags?: ReadonlyArray<string>;
12325
11934
  readonly matchByOccurrence?: boolean;
12326
11935
  readonly defaultEnabled?: boolean;
12327
11936
  readonly lifecycle?: "retired";
@@ -12332,19 +11941,19 @@ declare const RULES: readonly [{
12332
11941
  readonly create: (context: RuleContext) => RuleVisitors;
12333
11942
  };
12334
11943
  }, {
12335
- readonly key: "react-doctor/mdx-ssr-execution-risk";
12336
- readonly id: "mdx-ssr-execution-risk";
11944
+ readonly key: "react-doctor/lang";
11945
+ readonly id: "lang";
12337
11946
  readonly source: "react-doctor";
12338
- readonly originallyExternal: false;
11947
+ readonly originallyExternal: true;
12339
11948
  readonly rule: {
12340
11949
  readonly framework: "global";
12341
- readonly category: "Security";
12342
- readonly tags: readonly string[];
11950
+ readonly category: "Accessibility";
11951
+ readonly requires: readonly Capability[];
12343
11952
  readonly id: string;
12344
11953
  readonly title?: string;
12345
11954
  readonly severity: RuleSeverity;
12346
- readonly requires?: ReadonlyArray<Capability>;
12347
11955
  readonly disabledWhen?: ReadonlyArray<Capability>;
11956
+ readonly tags?: ReadonlyArray<string>;
12348
11957
  readonly matchByOccurrence?: boolean;
12349
11958
  readonly defaultEnabled?: boolean;
12350
11959
  readonly lifecycle?: "retired";
@@ -12355,19 +11964,19 @@ declare const RULES: readonly [{
12355
11964
  readonly create: (context: RuleContext) => RuleVisitors;
12356
11965
  };
12357
11966
  }, {
12358
- readonly key: "react-doctor/media-has-caption";
12359
- readonly id: "media-has-caption";
11967
+ readonly key: "react-doctor/local-rpc-native-bridge-risk";
11968
+ readonly id: "local-rpc-native-bridge-risk";
12360
11969
  readonly source: "react-doctor";
12361
- readonly originallyExternal: true;
11970
+ readonly originallyExternal: false;
12362
11971
  readonly rule: {
12363
11972
  readonly framework: "global";
12364
- readonly category: "Accessibility";
12365
- readonly requires: readonly Capability[];
11973
+ readonly category: "Security";
11974
+ readonly tags: readonly string[];
12366
11975
  readonly id: string;
12367
11976
  readonly title?: string;
12368
11977
  readonly severity: RuleSeverity;
11978
+ readonly requires?: ReadonlyArray<Capability>;
12369
11979
  readonly disabledWhen?: ReadonlyArray<Capability>;
12370
- readonly tags?: ReadonlyArray<string>;
12371
11980
  readonly matchByOccurrence?: boolean;
12372
11981
  readonly defaultEnabled?: boolean;
12373
11982
  readonly lifecycle?: "retired";
@@ -12378,19 +11987,19 @@ declare const RULES: readonly [{
12378
11987
  readonly create: (context: RuleContext) => RuleVisitors;
12379
11988
  };
12380
11989
  }, {
12381
- readonly key: "react-doctor/mobx-no-make-auto-observable-in-inheritance";
12382
- 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";
12383
11992
  readonly source: "react-doctor";
12384
11993
  readonly originallyExternal: false;
12385
11994
  readonly rule: {
12386
11995
  readonly framework: "global";
12387
- readonly category: "Bugs";
11996
+ readonly category: "Security";
11997
+ readonly tags: readonly string[];
12388
11998
  readonly id: string;
12389
11999
  readonly title?: string;
12390
12000
  readonly severity: RuleSeverity;
12391
12001
  readonly requires?: ReadonlyArray<Capability>;
12392
12002
  readonly disabledWhen?: ReadonlyArray<Capability>;
12393
- readonly tags?: ReadonlyArray<string>;
12394
12003
  readonly matchByOccurrence?: boolean;
12395
12004
  readonly defaultEnabled?: boolean;
12396
12005
  readonly lifecycle?: "retired";
@@ -12401,19 +12010,19 @@ declare const RULES: readonly [{
12401
12010
  readonly create: (context: RuleContext) => RuleVisitors;
12402
12011
  };
12403
12012
  }, {
12404
- readonly key: "react-doctor/mobx-no-observer-wrapped-memo";
12405
- readonly id: "mobx-no-observer-wrapped-memo";
12013
+ readonly key: "react-doctor/mdx-ssr-execution-risk";
12014
+ readonly id: "mdx-ssr-execution-risk";
12406
12015
  readonly source: "react-doctor";
12407
12016
  readonly originallyExternal: false;
12408
12017
  readonly rule: {
12409
12018
  readonly framework: "global";
12410
- readonly category: "Bugs";
12019
+ readonly category: "Security";
12020
+ readonly tags: readonly string[];
12411
12021
  readonly id: string;
12412
12022
  readonly title?: string;
12413
12023
  readonly severity: RuleSeverity;
12414
12024
  readonly requires?: ReadonlyArray<Capability>;
12415
12025
  readonly disabledWhen?: ReadonlyArray<Capability>;
12416
- readonly tags?: ReadonlyArray<string>;
12417
12026
  readonly matchByOccurrence?: boolean;
12418
12027
  readonly defaultEnabled?: boolean;
12419
12028
  readonly lifecycle?: "retired";
@@ -12424,17 +12033,17 @@ declare const RULES: readonly [{
12424
12033
  readonly create: (context: RuleContext) => RuleVisitors;
12425
12034
  };
12426
12035
  }, {
12427
- readonly key: "react-doctor/mobx-reaction-disposer-discarded";
12428
- readonly id: "mobx-reaction-disposer-discarded";
12036
+ readonly key: "react-doctor/media-has-caption";
12037
+ readonly id: "media-has-caption";
12429
12038
  readonly source: "react-doctor";
12430
- readonly originallyExternal: false;
12039
+ readonly originallyExternal: true;
12431
12040
  readonly rule: {
12432
12041
  readonly framework: "global";
12433
- readonly category: "Bugs";
12042
+ readonly category: "Accessibility";
12043
+ readonly requires: readonly Capability[];
12434
12044
  readonly id: string;
12435
12045
  readonly title?: string;
12436
12046
  readonly severity: RuleSeverity;
12437
- readonly requires?: ReadonlyArray<Capability>;
12438
12047
  readonly disabledWhen?: ReadonlyArray<Capability>;
12439
12048
  readonly tags?: ReadonlyArray<string>;
12440
12049
  readonly matchByOccurrence?: boolean;
@@ -16248,220 +15857,13 @@ declare const RULES: readonly [{
16248
15857
  readonly originallyExternal: true;
16249
15858
  readonly rule: {
16250
15859
  readonly framework: "global";
16251
- readonly category: "Maintainability";
16252
- readonly requires: readonly Capability[];
16253
- readonly id: string;
16254
- readonly title?: string;
16255
- readonly severity: RuleSeverity;
16256
- readonly disabledWhen?: ReadonlyArray<Capability>;
16257
- readonly tags?: ReadonlyArray<string>;
16258
- readonly matchByOccurrence?: boolean;
16259
- readonly defaultEnabled?: boolean;
16260
- readonly lifecycle?: "retired";
16261
- readonly scan?: FileScan;
16262
- readonly committedFilesOnly?: boolean;
16263
- readonly recommendation?: string;
16264
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16265
- readonly create: (context: RuleContext) => RuleVisitors;
16266
- };
16267
- }, {
16268
- readonly key: "react-doctor/prefer-html-dialog";
16269
- readonly id: "prefer-html-dialog";
16270
- readonly source: "react-doctor";
16271
- readonly originallyExternal: false;
16272
- readonly rule: {
16273
- readonly framework: "global";
16274
- readonly category: "Accessibility";
16275
- readonly requires: readonly Capability[];
16276
- readonly id: string;
16277
- readonly title?: string;
16278
- readonly severity: RuleSeverity;
16279
- readonly disabledWhen?: ReadonlyArray<Capability>;
16280
- readonly tags?: ReadonlyArray<string>;
16281
- readonly matchByOccurrence?: boolean;
16282
- readonly defaultEnabled?: boolean;
16283
- readonly lifecycle?: "retired";
16284
- readonly scan?: FileScan;
16285
- readonly committedFilesOnly?: boolean;
16286
- readonly recommendation?: string;
16287
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16288
- readonly create: (context: RuleContext) => RuleVisitors;
16289
- };
16290
- }, {
16291
- readonly key: "react-doctor/prefer-module-scope-pure-function";
16292
- readonly id: "prefer-module-scope-pure-function";
16293
- readonly source: "react-doctor";
16294
- readonly originallyExternal: false;
16295
- readonly rule: {
16296
- readonly framework: "global";
16297
- readonly category: "Maintainability";
16298
- readonly id: string;
16299
- readonly title?: string;
16300
- readonly severity: RuleSeverity;
16301
- readonly requires?: ReadonlyArray<Capability>;
16302
- readonly disabledWhen?: ReadonlyArray<Capability>;
16303
- readonly tags?: ReadonlyArray<string>;
16304
- readonly matchByOccurrence?: boolean;
16305
- readonly defaultEnabled?: boolean;
16306
- readonly lifecycle?: "retired";
16307
- readonly scan?: FileScan;
16308
- readonly committedFilesOnly?: boolean;
16309
- readonly recommendation?: string;
16310
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
16311
- readonly create: (context: RuleContext) => RuleVisitors;
16312
- };
16313
- }, {
16314
- readonly key: "react-doctor/prefer-module-scope-static-value";
16315
- readonly id: "prefer-module-scope-static-value";
16316
- readonly source: "react-doctor";
16317
- readonly originallyExternal: false;
16318
- 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-stable-empty-fallback";
16338
- readonly id: "prefer-stable-empty-fallback";
16339
- readonly source: "react-doctor";
16340
- readonly originallyExternal: false;
16341
- readonly rule: {
16342
- readonly framework: "global";
16343
- readonly category: "Performance";
16344
- readonly requires: readonly Capability[];
16345
- readonly id: string;
16346
- readonly title?: string;
16347
- readonly severity: RuleSeverity;
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-tag-over-role";
16361
- readonly id: "prefer-tag-over-role";
16362
- readonly source: "react-doctor";
16363
- readonly originallyExternal: true;
16364
- readonly rule: {
16365
- readonly framework: "global";
16366
- readonly category: "Accessibility";
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-use-effect-event";
16384
- readonly id: "prefer-use-effect-event";
16385
- readonly source: "react-doctor";
16386
- readonly originallyExternal: false;
16387
- readonly rule: {
16388
- readonly framework: "global";
16389
- readonly category: "Bugs";
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-sync-external-store";
16407
- readonly id: "prefer-use-sync-external-store";
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-useReducer";
16430
- readonly id: "prefer-useReducer";
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/public-debug-artifact";
16453
- readonly id: "public-debug-artifact";
16454
- readonly source: "react-doctor";
16455
- readonly originallyExternal: false;
16456
- readonly rule: {
16457
- readonly framework: "global";
16458
- readonly category: "Security";
16459
- readonly tags: readonly string[];
15860
+ readonly category: "Maintainability";
15861
+ readonly requires: readonly Capability[];
16460
15862
  readonly id: string;
16461
15863
  readonly title?: string;
16462
15864
  readonly severity: RuleSeverity;
16463
- readonly requires?: ReadonlyArray<Capability>;
16464
15865
  readonly disabledWhen?: ReadonlyArray<Capability>;
15866
+ readonly tags?: ReadonlyArray<string>;
16465
15867
  readonly matchByOccurrence?: boolean;
16466
15868
  readonly defaultEnabled?: boolean;
16467
15869
  readonly lifecycle?: "retired";
@@ -16472,19 +15874,19 @@ declare const RULES: readonly [{
16472
15874
  readonly create: (context: RuleContext) => RuleVisitors;
16473
15875
  };
16474
15876
  }, {
16475
- readonly key: "react-doctor/public-env-secret-name";
16476
- readonly id: "public-env-secret-name";
15877
+ readonly key: "react-doctor/prefer-html-dialog";
15878
+ readonly id: "prefer-html-dialog";
16477
15879
  readonly source: "react-doctor";
16478
15880
  readonly originallyExternal: false;
16479
15881
  readonly rule: {
16480
15882
  readonly framework: "global";
16481
- readonly category: "Security";
16482
- readonly tags: readonly string[];
15883
+ readonly category: "Accessibility";
15884
+ readonly requires: readonly Capability[];
16483
15885
  readonly id: string;
16484
15886
  readonly title?: string;
16485
15887
  readonly severity: RuleSeverity;
16486
- readonly requires?: ReadonlyArray<Capability>;
16487
15888
  readonly disabledWhen?: ReadonlyArray<Capability>;
15889
+ readonly tags?: ReadonlyArray<string>;
16488
15890
  readonly matchByOccurrence?: boolean;
16489
15891
  readonly defaultEnabled?: boolean;
16490
15892
  readonly lifecycle?: "retired";
@@ -16495,13 +15897,13 @@ declare const RULES: readonly [{
16495
15897
  readonly create: (context: RuleContext) => RuleVisitors;
16496
15898
  };
16497
15899
  }, {
16498
- readonly key: "react-doctor/query-destructure-result";
16499
- readonly id: "query-destructure-result";
15900
+ readonly key: "react-doctor/prefer-module-scope-pure-function";
15901
+ readonly id: "prefer-module-scope-pure-function";
16500
15902
  readonly source: "react-doctor";
16501
15903
  readonly originallyExternal: false;
16502
15904
  readonly rule: {
16503
- readonly framework: "tanstack-query";
16504
- readonly category: "Bugs";
15905
+ readonly framework: "global";
15906
+ readonly category: "Maintainability";
16505
15907
  readonly id: string;
16506
15908
  readonly title?: string;
16507
15909
  readonly severity: RuleSeverity;
@@ -16518,13 +15920,13 @@ declare const RULES: readonly [{
16518
15920
  readonly create: (context: RuleContext) => RuleVisitors;
16519
15921
  };
16520
15922
  }, {
16521
- readonly key: "react-doctor/query-mutation-missing-invalidation";
16522
- readonly id: "query-mutation-missing-invalidation";
15923
+ readonly key: "react-doctor/prefer-module-scope-static-value";
15924
+ readonly id: "prefer-module-scope-static-value";
16523
15925
  readonly source: "react-doctor";
16524
15926
  readonly originallyExternal: false;
16525
15927
  readonly rule: {
16526
- readonly framework: "tanstack-query";
16527
- readonly category: "Bugs";
15928
+ readonly framework: "global";
15929
+ readonly category: "Maintainability";
16528
15930
  readonly id: string;
16529
15931
  readonly title?: string;
16530
15932
  readonly severity: RuleSeverity;
@@ -16541,17 +15943,17 @@ declare const RULES: readonly [{
16541
15943
  readonly create: (context: RuleContext) => RuleVisitors;
16542
15944
  };
16543
15945
  }, {
16544
- readonly key: "react-doctor/query-no-query-in-effect";
16545
- readonly id: "query-no-query-in-effect";
15946
+ readonly key: "react-doctor/prefer-stable-empty-fallback";
15947
+ readonly id: "prefer-stable-empty-fallback";
16546
15948
  readonly source: "react-doctor";
16547
15949
  readonly originallyExternal: false;
16548
15950
  readonly rule: {
16549
- readonly framework: "tanstack-query";
16550
- readonly category: "Bugs";
15951
+ readonly framework: "global";
15952
+ readonly category: "Performance";
15953
+ readonly requires: readonly Capability[];
16551
15954
  readonly id: string;
16552
15955
  readonly title?: string;
16553
15956
  readonly severity: RuleSeverity;
16554
- readonly requires?: ReadonlyArray<Capability>;
16555
15957
  readonly disabledWhen?: ReadonlyArray<Capability>;
16556
15958
  readonly tags?: ReadonlyArray<string>;
16557
15959
  readonly matchByOccurrence?: boolean;
@@ -16564,17 +15966,17 @@ declare const RULES: readonly [{
16564
15966
  readonly create: (context: RuleContext) => RuleVisitors;
16565
15967
  };
16566
15968
  }, {
16567
- readonly key: "react-doctor/query-no-rest-destructuring";
16568
- readonly id: "query-no-rest-destructuring";
15969
+ readonly key: "react-doctor/prefer-tag-over-role";
15970
+ readonly id: "prefer-tag-over-role";
16569
15971
  readonly source: "react-doctor";
16570
- readonly originallyExternal: false;
15972
+ readonly originallyExternal: true;
16571
15973
  readonly rule: {
16572
- readonly framework: "tanstack-query";
16573
- readonly category: "Bugs";
15974
+ readonly framework: "global";
15975
+ readonly category: "Accessibility";
15976
+ readonly requires: readonly Capability[];
16574
15977
  readonly id: string;
16575
15978
  readonly title?: string;
16576
15979
  readonly severity: RuleSeverity;
16577
- readonly requires?: ReadonlyArray<Capability>;
16578
15980
  readonly disabledWhen?: ReadonlyArray<Capability>;
16579
15981
  readonly tags?: ReadonlyArray<string>;
16580
15982
  readonly matchByOccurrence?: boolean;
@@ -16587,17 +15989,17 @@ declare const RULES: readonly [{
16587
15989
  readonly create: (context: RuleContext) => RuleVisitors;
16588
15990
  };
16589
15991
  }, {
16590
- readonly key: "react-doctor/query-no-usequery-for-mutation";
16591
- readonly id: "query-no-usequery-for-mutation";
15992
+ readonly key: "react-doctor/prefer-use-effect-event";
15993
+ readonly id: "prefer-use-effect-event";
16592
15994
  readonly source: "react-doctor";
16593
15995
  readonly originallyExternal: false;
16594
15996
  readonly rule: {
16595
- readonly framework: "tanstack-query";
15997
+ readonly framework: "global";
16596
15998
  readonly category: "Bugs";
15999
+ readonly requires: readonly Capability[];
16597
16000
  readonly id: string;
16598
16001
  readonly title?: string;
16599
16002
  readonly severity: RuleSeverity;
16600
- readonly requires?: ReadonlyArray<Capability>;
16601
16003
  readonly disabledWhen?: ReadonlyArray<Capability>;
16602
16004
  readonly tags?: ReadonlyArray<string>;
16603
16005
  readonly matchByOccurrence?: boolean;
@@ -16610,17 +16012,17 @@ declare const RULES: readonly [{
16610
16012
  readonly create: (context: RuleContext) => RuleVisitors;
16611
16013
  };
16612
16014
  }, {
16613
- readonly key: "react-doctor/query-no-void-query-fn";
16614
- 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";
16615
16017
  readonly source: "react-doctor";
16616
16018
  readonly originallyExternal: false;
16617
16019
  readonly rule: {
16618
- readonly framework: "tanstack-query";
16020
+ readonly framework: "global";
16619
16021
  readonly category: "Bugs";
16022
+ readonly requires: readonly Capability[];
16620
16023
  readonly id: string;
16621
16024
  readonly title?: string;
16622
16025
  readonly severity: RuleSeverity;
16623
- readonly requires?: ReadonlyArray<Capability>;
16624
16026
  readonly disabledWhen?: ReadonlyArray<Capability>;
16625
16027
  readonly tags?: ReadonlyArray<string>;
16626
16028
  readonly matchByOccurrence?: boolean;
@@ -16633,17 +16035,17 @@ declare const RULES: readonly [{
16633
16035
  readonly create: (context: RuleContext) => RuleVisitors;
16634
16036
  };
16635
16037
  }, {
16636
- readonly key: "react-doctor/query-stable-query-client";
16637
- readonly id: "query-stable-query-client";
16038
+ readonly key: "react-doctor/prefer-useReducer";
16039
+ readonly id: "prefer-useReducer";
16638
16040
  readonly source: "react-doctor";
16639
16041
  readonly originallyExternal: false;
16640
16042
  readonly rule: {
16641
- readonly framework: "tanstack-query";
16043
+ readonly framework: "global";
16642
16044
  readonly category: "Bugs";
16045
+ readonly requires: readonly Capability[];
16643
16046
  readonly id: string;
16644
16047
  readonly title?: string;
16645
16048
  readonly severity: RuleSeverity;
16646
- readonly requires?: ReadonlyArray<Capability>;
16647
16049
  readonly disabledWhen?: ReadonlyArray<Capability>;
16648
16050
  readonly tags?: ReadonlyArray<string>;
16649
16051
  readonly matchByOccurrence?: boolean;
@@ -16656,8 +16058,8 @@ declare const RULES: readonly [{
16656
16058
  readonly create: (context: RuleContext) => RuleVisitors;
16657
16059
  };
16658
16060
  }, {
16659
- readonly key: "react-doctor/raw-sql-injection-risk";
16660
- readonly id: "raw-sql-injection-risk";
16061
+ readonly key: "react-doctor/public-debug-artifact";
16062
+ readonly id: "public-debug-artifact";
16661
16063
  readonly source: "react-doctor";
16662
16064
  readonly originallyExternal: false;
16663
16065
  readonly rule: {
@@ -16679,19 +16081,19 @@ declare const RULES: readonly [{
16679
16081
  readonly create: (context: RuleContext) => RuleVisitors;
16680
16082
  };
16681
16083
  }, {
16682
- readonly key: "react-doctor/react-compiler-no-manual-memoization";
16683
- readonly id: "react-compiler-no-manual-memoization";
16084
+ readonly key: "react-doctor/public-env-secret-name";
16085
+ readonly id: "public-env-secret-name";
16684
16086
  readonly source: "react-doctor";
16685
16087
  readonly originallyExternal: false;
16686
16088
  readonly rule: {
16687
16089
  readonly framework: "global";
16688
- readonly category: "Maintainability";
16090
+ readonly category: "Security";
16091
+ readonly tags: readonly string[];
16689
16092
  readonly id: string;
16690
16093
  readonly title?: string;
16691
16094
  readonly severity: RuleSeverity;
16692
16095
  readonly requires?: ReadonlyArray<Capability>;
16693
16096
  readonly disabledWhen?: ReadonlyArray<Capability>;
16694
- readonly tags?: ReadonlyArray<string>;
16695
16097
  readonly matchByOccurrence?: boolean;
16696
16098
  readonly defaultEnabled?: boolean;
16697
16099
  readonly lifecycle?: "retired";
@@ -16702,17 +16104,17 @@ declare const RULES: readonly [{
16702
16104
  readonly create: (context: RuleContext) => RuleVisitors;
16703
16105
  };
16704
16106
  }, {
16705
- readonly key: "react-doctor/react-in-jsx-scope";
16706
- readonly id: "react-in-jsx-scope";
16107
+ readonly key: "react-doctor/query-destructure-result";
16108
+ readonly id: "query-destructure-result";
16707
16109
  readonly source: "react-doctor";
16708
- readonly originallyExternal: true;
16110
+ readonly originallyExternal: false;
16709
16111
  readonly rule: {
16710
- readonly framework: "global";
16112
+ readonly framework: "tanstack-query";
16711
16113
  readonly category: "Bugs";
16712
- readonly requires: readonly Capability[];
16713
16114
  readonly id: string;
16714
16115
  readonly title?: string;
16715
16116
  readonly severity: RuleSeverity;
16117
+ readonly requires?: ReadonlyArray<Capability>;
16716
16118
  readonly disabledWhen?: ReadonlyArray<Capability>;
16717
16119
  readonly tags?: ReadonlyArray<string>;
16718
16120
  readonly matchByOccurrence?: boolean;
@@ -16725,13 +16127,13 @@ declare const RULES: readonly [{
16725
16127
  readonly create: (context: RuleContext) => RuleVisitors;
16726
16128
  };
16727
16129
  }, {
16728
- readonly key: "react-doctor/react-markdown-unsanitized-raw-html";
16729
- readonly id: "react-markdown-unsanitized-raw-html";
16130
+ readonly key: "react-doctor/query-mutation-missing-invalidation";
16131
+ readonly id: "query-mutation-missing-invalidation";
16730
16132
  readonly source: "react-doctor";
16731
16133
  readonly originallyExternal: false;
16732
16134
  readonly rule: {
16733
- readonly framework: "global";
16734
- readonly category: "Security";
16135
+ readonly framework: "tanstack-query";
16136
+ readonly category: "Bugs";
16735
16137
  readonly id: string;
16736
16138
  readonly title?: string;
16737
16139
  readonly severity: RuleSeverity;
@@ -16748,17 +16150,17 @@ declare const RULES: readonly [{
16748
16150
  readonly create: (context: RuleContext) => RuleVisitors;
16749
16151
  };
16750
16152
  }, {
16751
- readonly key: "react-doctor/redux-useselector-inline-derivation";
16752
- readonly id: "redux-useselector-inline-derivation";
16153
+ readonly key: "react-doctor/query-no-query-in-effect";
16154
+ readonly id: "query-no-query-in-effect";
16753
16155
  readonly source: "react-doctor";
16754
16156
  readonly originallyExternal: false;
16755
16157
  readonly rule: {
16756
- readonly framework: "global";
16757
- readonly category: "Performance";
16758
- readonly requires: readonly Capability[];
16158
+ readonly framework: "tanstack-query";
16159
+ readonly category: "Bugs";
16759
16160
  readonly id: string;
16760
16161
  readonly title?: string;
16761
16162
  readonly severity: RuleSeverity;
16163
+ readonly requires?: ReadonlyArray<Capability>;
16762
16164
  readonly disabledWhen?: ReadonlyArray<Capability>;
16763
16165
  readonly tags?: ReadonlyArray<string>;
16764
16166
  readonly matchByOccurrence?: boolean;
@@ -16771,17 +16173,17 @@ declare const RULES: readonly [{
16771
16173
  readonly create: (context: RuleContext) => RuleVisitors;
16772
16174
  };
16773
16175
  }, {
16774
- readonly key: "react-doctor/redux-useselector-returns-new-collection";
16775
- readonly id: "redux-useselector-returns-new-collection";
16176
+ readonly key: "react-doctor/query-no-rest-destructuring";
16177
+ readonly id: "query-no-rest-destructuring";
16776
16178
  readonly source: "react-doctor";
16777
16179
  readonly originallyExternal: false;
16778
16180
  readonly rule: {
16779
- readonly framework: "global";
16780
- readonly category: "Performance";
16781
- readonly requires: readonly Capability[];
16181
+ readonly framework: "tanstack-query";
16182
+ readonly category: "Bugs";
16782
16183
  readonly id: string;
16783
16184
  readonly title?: string;
16784
16185
  readonly severity: RuleSeverity;
16186
+ readonly requires?: ReadonlyArray<Capability>;
16785
16187
  readonly disabledWhen?: ReadonlyArray<Capability>;
16786
16188
  readonly tags?: ReadonlyArray<string>;
16787
16189
  readonly matchByOccurrence?: boolean;
@@ -16794,12 +16196,12 @@ declare const RULES: readonly [{
16794
16196
  readonly create: (context: RuleContext) => RuleVisitors;
16795
16197
  };
16796
16198
  }, {
16797
- readonly key: "react-doctor/remotion-calculate-metadata-fetch-signal";
16798
- 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";
16799
16201
  readonly source: "react-doctor";
16800
16202
  readonly originallyExternal: false;
16801
16203
  readonly rule: {
16802
- readonly framework: "global";
16204
+ readonly framework: "tanstack-query";
16803
16205
  readonly category: "Bugs";
16804
16206
  readonly id: string;
16805
16207
  readonly title?: string;
@@ -16817,12 +16219,12 @@ declare const RULES: readonly [{
16817
16219
  readonly create: (context: RuleContext) => RuleVisitors;
16818
16220
  };
16819
16221
  }, {
16820
- readonly key: "react-doctor/remotion-deterministic-randomness";
16821
- readonly id: "remotion-deterministic-randomness";
16222
+ readonly key: "react-doctor/query-no-void-query-fn";
16223
+ readonly id: "query-no-void-query-fn";
16822
16224
  readonly source: "react-doctor";
16823
16225
  readonly originallyExternal: false;
16824
16226
  readonly rule: {
16825
- readonly framework: "global";
16227
+ readonly framework: "tanstack-query";
16826
16228
  readonly category: "Bugs";
16827
16229
  readonly id: string;
16828
16230
  readonly title?: string;
@@ -16840,12 +16242,12 @@ declare const RULES: readonly [{
16840
16242
  readonly create: (context: RuleContext) => RuleVisitors;
16841
16243
  };
16842
16244
  }, {
16843
- readonly key: "react-doctor/remotion-no-css-animation";
16844
- readonly id: "remotion-no-css-animation";
16245
+ readonly key: "react-doctor/query-stable-query-client";
16246
+ readonly id: "query-stable-query-client";
16845
16247
  readonly source: "react-doctor";
16846
16248
  readonly originallyExternal: false;
16847
16249
  readonly rule: {
16848
- readonly framework: "global";
16250
+ readonly framework: "tanstack-query";
16849
16251
  readonly category: "Bugs";
16850
16252
  readonly id: string;
16851
16253
  readonly title?: string;
@@ -16863,19 +16265,19 @@ declare const RULES: readonly [{
16863
16265
  readonly create: (context: RuleContext) => RuleVisitors;
16864
16266
  };
16865
16267
  }, {
16866
- readonly key: "react-doctor/remotion-no-css-transition";
16867
- readonly id: "remotion-no-css-transition";
16268
+ readonly key: "react-doctor/raw-sql-injection-risk";
16269
+ readonly id: "raw-sql-injection-risk";
16868
16270
  readonly source: "react-doctor";
16869
16271
  readonly originallyExternal: false;
16870
16272
  readonly rule: {
16871
16273
  readonly framework: "global";
16872
- readonly category: "Bugs";
16274
+ readonly category: "Security";
16275
+ readonly tags: readonly string[];
16873
16276
  readonly id: string;
16874
16277
  readonly title?: string;
16875
16278
  readonly severity: RuleSeverity;
16876
16279
  readonly requires?: ReadonlyArray<Capability>;
16877
16280
  readonly disabledWhen?: ReadonlyArray<Capability>;
16878
- readonly tags?: ReadonlyArray<string>;
16879
16281
  readonly matchByOccurrence?: boolean;
16880
16282
  readonly defaultEnabled?: boolean;
16881
16283
  readonly lifecycle?: "retired";
@@ -16886,13 +16288,13 @@ declare const RULES: readonly [{
16886
16288
  readonly create: (context: RuleContext) => RuleVisitors;
16887
16289
  };
16888
16290
  }, {
16889
- readonly key: "react-doctor/remotion-no-css-url-assets";
16890
- 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";
16891
16293
  readonly source: "react-doctor";
16892
16294
  readonly originallyExternal: false;
16893
16295
  readonly rule: {
16894
16296
  readonly framework: "global";
16895
- readonly category: "Bugs";
16297
+ readonly category: "Maintainability";
16896
16298
  readonly id: string;
16897
16299
  readonly title?: string;
16898
16300
  readonly severity: RuleSeverity;
@@ -16909,17 +16311,17 @@ declare const RULES: readonly [{
16909
16311
  readonly create: (context: RuleContext) => RuleVisitors;
16910
16312
  };
16911
16313
  }, {
16912
- readonly key: "react-doctor/remotion-no-module-scope-delay-render";
16913
- readonly id: "remotion-no-module-scope-delay-render";
16314
+ readonly key: "react-doctor/react-in-jsx-scope";
16315
+ readonly id: "react-in-jsx-scope";
16914
16316
  readonly source: "react-doctor";
16915
- readonly originallyExternal: false;
16317
+ readonly originallyExternal: true;
16916
16318
  readonly rule: {
16917
16319
  readonly framework: "global";
16918
16320
  readonly category: "Bugs";
16321
+ readonly requires: readonly Capability[];
16919
16322
  readonly id: string;
16920
16323
  readonly title?: string;
16921
16324
  readonly severity: RuleSeverity;
16922
- readonly requires?: ReadonlyArray<Capability>;
16923
16325
  readonly disabledWhen?: ReadonlyArray<Capability>;
16924
16326
  readonly tags?: ReadonlyArray<string>;
16925
16327
  readonly matchByOccurrence?: boolean;
@@ -16932,13 +16334,13 @@ declare const RULES: readonly [{
16932
16334
  readonly create: (context: RuleContext) => RuleVisitors;
16933
16335
  };
16934
16336
  }, {
16935
- readonly key: "react-doctor/remotion-no-native-media-elements";
16936
- 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";
16937
16339
  readonly source: "react-doctor";
16938
16340
  readonly originallyExternal: false;
16939
16341
  readonly rule: {
16940
16342
  readonly framework: "global";
16941
- readonly category: "Bugs";
16343
+ readonly category: "Security";
16942
16344
  readonly id: string;
16943
16345
  readonly title?: string;
16944
16346
  readonly severity: RuleSeverity;
@@ -16955,17 +16357,17 @@ declare const RULES: readonly [{
16955
16357
  readonly create: (context: RuleContext) => RuleVisitors;
16956
16358
  };
16957
16359
  }, {
16958
- readonly key: "react-doctor/remotion-no-next-image";
16959
- readonly id: "remotion-no-next-image";
16360
+ readonly key: "react-doctor/redux-useselector-inline-derivation";
16361
+ readonly id: "redux-useselector-inline-derivation";
16960
16362
  readonly source: "react-doctor";
16961
16363
  readonly originallyExternal: false;
16962
16364
  readonly rule: {
16963
16365
  readonly framework: "global";
16964
- readonly category: "Bugs";
16366
+ readonly category: "Performance";
16367
+ readonly requires: readonly Capability[];
16965
16368
  readonly id: string;
16966
16369
  readonly title?: string;
16967
16370
  readonly severity: RuleSeverity;
16968
- readonly requires?: ReadonlyArray<Capability>;
16969
16371
  readonly disabledWhen?: ReadonlyArray<Capability>;
16970
16372
  readonly tags?: ReadonlyArray<string>;
16971
16373
  readonly matchByOccurrence?: boolean;
@@ -16978,17 +16380,17 @@ declare const RULES: readonly [{
16978
16380
  readonly create: (context: RuleContext) => RuleVisitors;
16979
16381
  };
16980
16382
  }, {
16981
- readonly key: "react-doctor/remotion-stable-delay-render-handle";
16982
- 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";
16983
16385
  readonly source: "react-doctor";
16984
16386
  readonly originallyExternal: false;
16985
16387
  readonly rule: {
16986
16388
  readonly framework: "global";
16987
- readonly category: "Bugs";
16389
+ readonly category: "Performance";
16390
+ readonly requires: readonly Capability[];
16988
16391
  readonly id: string;
16989
16392
  readonly title?: string;
16990
16393
  readonly severity: RuleSeverity;
16991
- readonly requires?: ReadonlyArray<Capability>;
16992
16394
  readonly disabledWhen?: ReadonlyArray<Capability>;
16993
16395
  readonly tags?: ReadonlyArray<string>;
16994
16396
  readonly matchByOccurrence?: boolean;
@@ -19185,52 +18587,6 @@ declare const RULES: readonly [{
19185
18587
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19186
18588
  readonly create: (context: RuleContext) => RuleVisitors;
19187
18589
  };
19188
- }, {
19189
- readonly key: "react-doctor/valtio-no-proxy-read-in-render";
19190
- readonly id: "valtio-no-proxy-read-in-render";
19191
- readonly source: "react-doctor";
19192
- readonly originallyExternal: false;
19193
- readonly rule: {
19194
- readonly framework: "global";
19195
- readonly category: "Bugs";
19196
- readonly requires: readonly Capability[];
19197
- readonly id: string;
19198
- readonly title?: string;
19199
- readonly severity: RuleSeverity;
19200
- readonly disabledWhen?: ReadonlyArray<Capability>;
19201
- readonly tags?: ReadonlyArray<string>;
19202
- readonly matchByOccurrence?: boolean;
19203
- readonly defaultEnabled?: boolean;
19204
- readonly lifecycle?: "retired";
19205
- readonly scan?: FileScan;
19206
- readonly committedFilesOnly?: boolean;
19207
- readonly recommendation?: string;
19208
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19209
- readonly create: (context: RuleContext) => RuleVisitors;
19210
- };
19211
- }, {
19212
- readonly key: "react-doctor/valtio-no-snapshot-in-callback";
19213
- readonly id: "valtio-no-snapshot-in-callback";
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
18590
  }, {
19235
18591
  readonly key: "react-doctor/void-dom-elements-no-children";
19236
18592
  readonly id: "void-dom-elements-no-children";
@@ -19369,52 +18725,6 @@ declare const RULES: readonly [{
19369
18725
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19370
18726
  readonly create: (context: RuleContext) => RuleVisitors;
19371
18727
  };
19372
- }, {
19373
- readonly key: "react-doctor/zustand-no-fresh-selector-result";
19374
- readonly id: "zustand-no-fresh-selector-result";
19375
- readonly source: "react-doctor";
19376
- readonly originallyExternal: false;
19377
- readonly rule: {
19378
- readonly framework: "global";
19379
- readonly category: "Performance";
19380
- readonly requires: readonly Capability[];
19381
- readonly id: string;
19382
- readonly title?: string;
19383
- readonly severity: RuleSeverity;
19384
- readonly disabledWhen?: ReadonlyArray<Capability>;
19385
- readonly tags?: ReadonlyArray<string>;
19386
- readonly matchByOccurrence?: boolean;
19387
- readonly defaultEnabled?: boolean;
19388
- readonly lifecycle?: "retired";
19389
- readonly scan?: FileScan;
19390
- readonly committedFilesOnly?: boolean;
19391
- readonly recommendation?: string;
19392
- readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
19393
- readonly create: (context: RuleContext) => RuleVisitors;
19394
- };
19395
- }, {
19396
- readonly key: "react-doctor/zustand-no-whole-store-destructure";
19397
- readonly id: "zustand-no-whole-store-destructure";
19398
- readonly source: "react-doctor";
19399
- readonly originallyExternal: false;
19400
- readonly rule: {
19401
- readonly framework: "global";
19402
- readonly category: "Bugs";
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
18728
  }, {
19419
18729
  readonly key: "react-hooks-js/set-state-in-render";
19420
18730
  readonly source: "react-compiler";