oxlint-plugin-react-doctor 0.8.1-dev.7818922 → 0.8.1-dev.7eca0ee

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 +956 -266
  2. package/dist/index.js +5041 -989
  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" | "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}`;
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}`;
104
104
  type CapabilityQuery = (capability: Capability) => boolean;
105
105
  //#endregion
106
106
  //#region src/plugin/utils/file-scan.d.ts
@@ -2421,29 +2421,6 @@ 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
- };
2447
2424
  }, {
2448
2425
  readonly key: "react-doctor/jsx-no-undef";
2449
2426
  readonly id: "jsx-no-undef";
@@ -2743,6 +2720,75 @@ declare const REACT_DOCTOR_RULES: readonly [{
2743
2720
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
2744
2721
  readonly create: (context: RuleContext) => RuleVisitors;
2745
2722
  };
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
+ };
2746
2792
  }, {
2747
2793
  readonly key: "react-doctor/mouse-events-have-key-events";
2748
2794
  readonly id: "mouse-events-have-key-events";
@@ -7091,17 +7137,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7091
7137
  readonly create: (context: RuleContext) => RuleVisitors;
7092
7138
  };
7093
7139
  }, {
7094
- readonly key: "react-doctor/rendering-animate-svg-wrapper";
7095
- readonly id: "rendering-animate-svg-wrapper";
7140
+ readonly key: "react-doctor/remotion-calculate-metadata-fetch-signal";
7141
+ readonly id: "remotion-calculate-metadata-fetch-signal";
7096
7142
  readonly source: "react-doctor";
7097
7143
  readonly originallyExternal: false;
7098
7144
  readonly rule: {
7099
7145
  readonly framework: "global";
7100
- readonly category: "Performance";
7101
- readonly requires: readonly Capability[];
7146
+ readonly category: "Bugs";
7102
7147
  readonly id: string;
7103
7148
  readonly title?: string;
7104
7149
  readonly severity: RuleSeverity;
7150
+ readonly requires?: ReadonlyArray<Capability>;
7105
7151
  readonly disabledWhen?: ReadonlyArray<Capability>;
7106
7152
  readonly tags?: ReadonlyArray<string>;
7107
7153
  readonly matchByOccurrence?: boolean;
@@ -7114,8 +7160,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7114
7160
  readonly create: (context: RuleContext) => RuleVisitors;
7115
7161
  };
7116
7162
  }, {
7117
- readonly key: "react-doctor/rendering-conditional-render";
7118
- readonly id: "rendering-conditional-render";
7163
+ readonly key: "react-doctor/remotion-deterministic-randomness";
7164
+ readonly id: "remotion-deterministic-randomness";
7119
7165
  readonly source: "react-doctor";
7120
7166
  readonly originallyExternal: false;
7121
7167
  readonly rule: {
@@ -7137,17 +7183,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7137
7183
  readonly create: (context: RuleContext) => RuleVisitors;
7138
7184
  };
7139
7185
  }, {
7140
- readonly key: "react-doctor/rendering-hoist-jsx";
7141
- readonly id: "rendering-hoist-jsx";
7186
+ readonly key: "react-doctor/remotion-no-css-animation";
7187
+ readonly id: "remotion-no-css-animation";
7142
7188
  readonly source: "react-doctor";
7143
7189
  readonly originallyExternal: false;
7144
7190
  readonly rule: {
7145
7191
  readonly framework: "global";
7146
- readonly category: "Performance";
7147
- readonly requires: readonly Capability[];
7192
+ readonly category: "Bugs";
7148
7193
  readonly id: string;
7149
7194
  readonly title?: string;
7150
7195
  readonly severity: RuleSeverity;
7196
+ readonly requires?: ReadonlyArray<Capability>;
7151
7197
  readonly disabledWhen?: ReadonlyArray<Capability>;
7152
7198
  readonly tags?: ReadonlyArray<string>;
7153
7199
  readonly matchByOccurrence?: boolean;
@@ -7160,17 +7206,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7160
7206
  readonly create: (context: RuleContext) => RuleVisitors;
7161
7207
  };
7162
7208
  }, {
7163
- readonly key: "react-doctor/rendering-hydration-mismatch-time";
7164
- readonly id: "rendering-hydration-mismatch-time";
7209
+ readonly key: "react-doctor/remotion-no-css-transition";
7210
+ readonly id: "remotion-no-css-transition";
7165
7211
  readonly source: "react-doctor";
7166
7212
  readonly originallyExternal: false;
7167
7213
  readonly rule: {
7168
7214
  readonly framework: "global";
7169
7215
  readonly category: "Bugs";
7170
- readonly requires: readonly Capability[];
7171
7216
  readonly id: string;
7172
7217
  readonly title?: string;
7173
7218
  readonly severity: RuleSeverity;
7219
+ readonly requires?: ReadonlyArray<Capability>;
7174
7220
  readonly disabledWhen?: ReadonlyArray<Capability>;
7175
7221
  readonly tags?: ReadonlyArray<string>;
7176
7222
  readonly matchByOccurrence?: boolean;
@@ -7183,17 +7229,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7183
7229
  readonly create: (context: RuleContext) => RuleVisitors;
7184
7230
  };
7185
7231
  }, {
7186
- readonly key: "react-doctor/rendering-hydration-no-flicker";
7187
- readonly id: "rendering-hydration-no-flicker";
7232
+ readonly key: "react-doctor/remotion-no-css-url-assets";
7233
+ readonly id: "remotion-no-css-url-assets";
7188
7234
  readonly source: "react-doctor";
7189
7235
  readonly originallyExternal: false;
7190
7236
  readonly rule: {
7191
7237
  readonly framework: "global";
7192
- readonly category: "Performance";
7193
- readonly requires: readonly Capability[];
7238
+ readonly category: "Bugs";
7194
7239
  readonly id: string;
7195
7240
  readonly title?: string;
7196
7241
  readonly severity: RuleSeverity;
7242
+ readonly requires?: ReadonlyArray<Capability>;
7197
7243
  readonly disabledWhen?: ReadonlyArray<Capability>;
7198
7244
  readonly tags?: ReadonlyArray<string>;
7199
7245
  readonly matchByOccurrence?: boolean;
@@ -7206,17 +7252,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7206
7252
  readonly create: (context: RuleContext) => RuleVisitors;
7207
7253
  };
7208
7254
  }, {
7209
- readonly key: "react-doctor/rendering-script-defer-async";
7210
- readonly id: "rendering-script-defer-async";
7255
+ readonly key: "react-doctor/remotion-no-module-scope-delay-render";
7256
+ readonly id: "remotion-no-module-scope-delay-render";
7211
7257
  readonly source: "react-doctor";
7212
7258
  readonly originallyExternal: false;
7213
7259
  readonly rule: {
7214
7260
  readonly framework: "global";
7215
- readonly category: "Performance";
7216
- readonly requires: readonly Capability[];
7261
+ readonly category: "Bugs";
7217
7262
  readonly id: string;
7218
7263
  readonly title?: string;
7219
7264
  readonly severity: RuleSeverity;
7265
+ readonly requires?: ReadonlyArray<Capability>;
7220
7266
  readonly disabledWhen?: ReadonlyArray<Capability>;
7221
7267
  readonly tags?: ReadonlyArray<string>;
7222
7268
  readonly matchByOccurrence?: boolean;
@@ -7229,13 +7275,13 @@ declare const REACT_DOCTOR_RULES: readonly [{
7229
7275
  readonly create: (context: RuleContext) => RuleVisitors;
7230
7276
  };
7231
7277
  }, {
7232
- readonly key: "react-doctor/rendering-svg-precision";
7233
- readonly id: "rendering-svg-precision";
7278
+ readonly key: "react-doctor/remotion-no-native-media-elements";
7279
+ readonly id: "remotion-no-native-media-elements";
7234
7280
  readonly source: "react-doctor";
7235
7281
  readonly originallyExternal: false;
7236
7282
  readonly rule: {
7237
7283
  readonly framework: "global";
7238
- readonly category: "Performance";
7284
+ readonly category: "Bugs";
7239
7285
  readonly id: string;
7240
7286
  readonly title?: string;
7241
7287
  readonly severity: RuleSeverity;
@@ -7252,17 +7298,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7252
7298
  readonly create: (context: RuleContext) => RuleVisitors;
7253
7299
  };
7254
7300
  }, {
7255
- readonly key: "react-doctor/rendering-usetransition-loading";
7256
- readonly id: "rendering-usetransition-loading";
7301
+ readonly key: "react-doctor/remotion-no-next-image";
7302
+ readonly id: "remotion-no-next-image";
7257
7303
  readonly source: "react-doctor";
7258
7304
  readonly originallyExternal: false;
7259
7305
  readonly rule: {
7260
7306
  readonly framework: "global";
7261
- readonly category: "Performance";
7262
- readonly requires: readonly Capability[];
7307
+ readonly category: "Bugs";
7263
7308
  readonly id: string;
7264
7309
  readonly title?: string;
7265
7310
  readonly severity: RuleSeverity;
7311
+ readonly requires?: ReadonlyArray<Capability>;
7266
7312
  readonly disabledWhen?: ReadonlyArray<Capability>;
7267
7313
  readonly tags?: ReadonlyArray<string>;
7268
7314
  readonly matchByOccurrence?: boolean;
@@ -7275,19 +7321,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7275
7321
  readonly create: (context: RuleContext) => RuleVisitors;
7276
7322
  };
7277
7323
  }, {
7278
- readonly key: "react-doctor/repository-secret-file";
7279
- readonly id: "repository-secret-file";
7324
+ readonly key: "react-doctor/remotion-stable-delay-render-handle";
7325
+ readonly id: "remotion-stable-delay-render-handle";
7280
7326
  readonly source: "react-doctor";
7281
7327
  readonly originallyExternal: false;
7282
7328
  readonly rule: {
7283
7329
  readonly framework: "global";
7284
- readonly category: "Security";
7285
- readonly tags: readonly string[];
7330
+ readonly category: "Bugs";
7286
7331
  readonly id: string;
7287
7332
  readonly title?: string;
7288
7333
  readonly severity: RuleSeverity;
7289
7334
  readonly requires?: ReadonlyArray<Capability>;
7290
7335
  readonly disabledWhen?: ReadonlyArray<Capability>;
7336
+ readonly tags?: ReadonlyArray<string>;
7291
7337
  readonly matchByOccurrence?: boolean;
7292
7338
  readonly defaultEnabled?: boolean;
7293
7339
  readonly lifecycle?: "retired";
@@ -7298,19 +7344,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7298
7344
  readonly create: (context: RuleContext) => RuleVisitors;
7299
7345
  };
7300
7346
  }, {
7301
- readonly key: "react-doctor/request-body-mass-assignment";
7302
- readonly id: "request-body-mass-assignment";
7347
+ readonly key: "react-doctor/rendering-animate-svg-wrapper";
7348
+ readonly id: "rendering-animate-svg-wrapper";
7303
7349
  readonly source: "react-doctor";
7304
7350
  readonly originallyExternal: false;
7305
7351
  readonly rule: {
7306
7352
  readonly framework: "global";
7307
- readonly category: "Security";
7308
- readonly tags: readonly string[];
7353
+ readonly category: "Performance";
7354
+ readonly requires: readonly Capability[];
7309
7355
  readonly id: string;
7310
7356
  readonly title?: string;
7311
7357
  readonly severity: RuleSeverity;
7312
- readonly requires?: ReadonlyArray<Capability>;
7313
7358
  readonly disabledWhen?: ReadonlyArray<Capability>;
7359
+ readonly tags?: ReadonlyArray<string>;
7314
7360
  readonly matchByOccurrence?: boolean;
7315
7361
  readonly defaultEnabled?: boolean;
7316
7362
  readonly lifecycle?: "retired";
@@ -7321,17 +7367,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7321
7367
  readonly create: (context: RuleContext) => RuleVisitors;
7322
7368
  };
7323
7369
  }, {
7324
- readonly key: "react-doctor/require-render-return";
7325
- readonly id: "require-render-return";
7370
+ readonly key: "react-doctor/rendering-conditional-render";
7371
+ readonly id: "rendering-conditional-render";
7326
7372
  readonly source: "react-doctor";
7327
- readonly originallyExternal: true;
7373
+ readonly originallyExternal: false;
7328
7374
  readonly rule: {
7329
7375
  readonly framework: "global";
7330
7376
  readonly category: "Bugs";
7331
- readonly requires: readonly Capability[];
7332
7377
  readonly id: string;
7333
7378
  readonly title?: string;
7334
7379
  readonly severity: RuleSeverity;
7380
+ readonly requires?: ReadonlyArray<Capability>;
7335
7381
  readonly disabledWhen?: ReadonlyArray<Capability>;
7336
7382
  readonly tags?: ReadonlyArray<string>;
7337
7383
  readonly matchByOccurrence?: boolean;
@@ -7344,8 +7390,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7344
7390
  readonly create: (context: RuleContext) => RuleVisitors;
7345
7391
  };
7346
7392
  }, {
7347
- readonly key: "react-doctor/rerender-defer-reads-hook";
7348
- readonly id: "rerender-defer-reads-hook";
7393
+ readonly key: "react-doctor/rendering-hoist-jsx";
7394
+ readonly id: "rendering-hoist-jsx";
7349
7395
  readonly source: "react-doctor";
7350
7396
  readonly originallyExternal: false;
7351
7397
  readonly rule: {
@@ -7367,8 +7413,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7367
7413
  readonly create: (context: RuleContext) => RuleVisitors;
7368
7414
  };
7369
7415
  }, {
7370
- readonly key: "react-doctor/rerender-dependencies";
7371
- readonly id: "rerender-dependencies";
7416
+ readonly key: "react-doctor/rendering-hydration-mismatch-time";
7417
+ readonly id: "rendering-hydration-mismatch-time";
7372
7418
  readonly source: "react-doctor";
7373
7419
  readonly originallyExternal: false;
7374
7420
  readonly rule: {
@@ -7390,8 +7436,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7390
7436
  readonly create: (context: RuleContext) => RuleVisitors;
7391
7437
  };
7392
7438
  }, {
7393
- readonly key: "react-doctor/rerender-derived-state-from-hook";
7394
- readonly id: "rerender-derived-state-from-hook";
7439
+ readonly key: "react-doctor/rendering-hydration-no-flicker";
7440
+ readonly id: "rendering-hydration-no-flicker";
7395
7441
  readonly source: "react-doctor";
7396
7442
  readonly originallyExternal: false;
7397
7443
  readonly rule: {
@@ -7413,8 +7459,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7413
7459
  readonly create: (context: RuleContext) => RuleVisitors;
7414
7460
  };
7415
7461
  }, {
7416
- readonly key: "react-doctor/rerender-functional-setstate";
7417
- readonly id: "rerender-functional-setstate";
7462
+ readonly key: "react-doctor/rendering-script-defer-async";
7463
+ readonly id: "rendering-script-defer-async";
7418
7464
  readonly source: "react-doctor";
7419
7465
  readonly originallyExternal: false;
7420
7466
  readonly rule: {
@@ -7436,17 +7482,17 @@ declare const REACT_DOCTOR_RULES: readonly [{
7436
7482
  readonly create: (context: RuleContext) => RuleVisitors;
7437
7483
  };
7438
7484
  }, {
7439
- readonly key: "react-doctor/rerender-lazy-ref-init";
7440
- readonly id: "rerender-lazy-ref-init";
7485
+ readonly key: "react-doctor/rendering-svg-precision";
7486
+ readonly id: "rendering-svg-precision";
7441
7487
  readonly source: "react-doctor";
7442
7488
  readonly originallyExternal: false;
7443
7489
  readonly rule: {
7444
7490
  readonly framework: "global";
7445
7491
  readonly category: "Performance";
7446
- readonly requires: readonly Capability[];
7447
7492
  readonly id: string;
7448
7493
  readonly title?: string;
7449
7494
  readonly severity: RuleSeverity;
7495
+ readonly requires?: ReadonlyArray<Capability>;
7450
7496
  readonly disabledWhen?: ReadonlyArray<Capability>;
7451
7497
  readonly tags?: ReadonlyArray<string>;
7452
7498
  readonly matchByOccurrence?: boolean;
@@ -7459,8 +7505,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7459
7505
  readonly create: (context: RuleContext) => RuleVisitors;
7460
7506
  };
7461
7507
  }, {
7462
- readonly key: "react-doctor/rerender-lazy-state-init";
7463
- readonly id: "rerender-lazy-state-init";
7508
+ readonly key: "react-doctor/rendering-usetransition-loading";
7509
+ readonly id: "rendering-usetransition-loading";
7464
7510
  readonly source: "react-doctor";
7465
7511
  readonly originallyExternal: false;
7466
7512
  readonly rule: {
@@ -7482,19 +7528,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7482
7528
  readonly create: (context: RuleContext) => RuleVisitors;
7483
7529
  };
7484
7530
  }, {
7485
- readonly key: "react-doctor/rerender-memo-before-early-return";
7486
- readonly id: "rerender-memo-before-early-return";
7531
+ readonly key: "react-doctor/repository-secret-file";
7532
+ readonly id: "repository-secret-file";
7487
7533
  readonly source: "react-doctor";
7488
7534
  readonly originallyExternal: false;
7489
7535
  readonly rule: {
7490
7536
  readonly framework: "global";
7491
- readonly category: "Performance";
7492
- readonly requires: readonly Capability[];
7537
+ readonly category: "Security";
7538
+ readonly tags: readonly string[];
7493
7539
  readonly id: string;
7494
7540
  readonly title?: string;
7495
7541
  readonly severity: RuleSeverity;
7542
+ readonly requires?: ReadonlyArray<Capability>;
7496
7543
  readonly disabledWhen?: ReadonlyArray<Capability>;
7497
- readonly tags?: ReadonlyArray<string>;
7498
7544
  readonly matchByOccurrence?: boolean;
7499
7545
  readonly defaultEnabled?: boolean;
7500
7546
  readonly lifecycle?: "retired";
@@ -7505,19 +7551,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7505
7551
  readonly create: (context: RuleContext) => RuleVisitors;
7506
7552
  };
7507
7553
  }, {
7508
- readonly key: "react-doctor/rerender-memo-with-default-value";
7509
- readonly id: "rerender-memo-with-default-value";
7554
+ readonly key: "react-doctor/request-body-mass-assignment";
7555
+ readonly id: "request-body-mass-assignment";
7510
7556
  readonly source: "react-doctor";
7511
7557
  readonly originallyExternal: false;
7512
7558
  readonly rule: {
7513
7559
  readonly framework: "global";
7514
- readonly category: "Performance";
7515
- readonly requires: readonly Capability[];
7560
+ readonly category: "Security";
7561
+ readonly tags: readonly string[];
7516
7562
  readonly id: string;
7517
7563
  readonly title?: string;
7518
7564
  readonly severity: RuleSeverity;
7565
+ readonly requires?: ReadonlyArray<Capability>;
7519
7566
  readonly disabledWhen?: ReadonlyArray<Capability>;
7520
- readonly tags?: ReadonlyArray<string>;
7521
7567
  readonly matchByOccurrence?: boolean;
7522
7568
  readonly defaultEnabled?: boolean;
7523
7569
  readonly lifecycle?: "retired";
@@ -7528,13 +7574,13 @@ declare const REACT_DOCTOR_RULES: readonly [{
7528
7574
  readonly create: (context: RuleContext) => RuleVisitors;
7529
7575
  };
7530
7576
  }, {
7531
- readonly key: "react-doctor/rerender-state-only-in-handlers";
7532
- readonly id: "rerender-state-only-in-handlers";
7577
+ readonly key: "react-doctor/require-render-return";
7578
+ readonly id: "require-render-return";
7533
7579
  readonly source: "react-doctor";
7534
- readonly originallyExternal: false;
7580
+ readonly originallyExternal: true;
7535
7581
  readonly rule: {
7536
7582
  readonly framework: "global";
7537
- readonly category: "Performance";
7583
+ readonly category: "Bugs";
7538
7584
  readonly requires: readonly Capability[];
7539
7585
  readonly id: string;
7540
7586
  readonly title?: string;
@@ -7551,8 +7597,8 @@ declare const REACT_DOCTOR_RULES: readonly [{
7551
7597
  readonly create: (context: RuleContext) => RuleVisitors;
7552
7598
  };
7553
7599
  }, {
7554
- readonly key: "react-doctor/rerender-transitions-scroll";
7555
- readonly id: "rerender-transitions-scroll";
7600
+ readonly key: "react-doctor/rerender-defer-reads-hook";
7601
+ readonly id: "rerender-defer-reads-hook";
7556
7602
  readonly source: "react-doctor";
7557
7603
  readonly originallyExternal: false;
7558
7604
  readonly rule: {
@@ -7574,19 +7620,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7574
7620
  readonly create: (context: RuleContext) => RuleVisitors;
7575
7621
  };
7576
7622
  }, {
7577
- readonly key: "react-doctor/rn-animate-layout-property";
7578
- readonly id: "rn-animate-layout-property";
7623
+ readonly key: "react-doctor/rerender-dependencies";
7624
+ readonly id: "rerender-dependencies";
7579
7625
  readonly source: "react-doctor";
7580
7626
  readonly originallyExternal: false;
7581
7627
  readonly rule: {
7582
- readonly framework: "react-native";
7628
+ readonly framework: "global";
7583
7629
  readonly category: "Bugs";
7584
- readonly tags: readonly string[];
7630
+ readonly requires: readonly Capability[];
7585
7631
  readonly id: string;
7586
7632
  readonly title?: string;
7587
7633
  readonly severity: RuleSeverity;
7588
- readonly requires?: ReadonlyArray<Capability>;
7589
7634
  readonly disabledWhen?: ReadonlyArray<Capability>;
7635
+ readonly tags?: ReadonlyArray<string>;
7590
7636
  readonly matchByOccurrence?: boolean;
7591
7637
  readonly defaultEnabled?: boolean;
7592
7638
  readonly lifecycle?: "retired";
@@ -7597,19 +7643,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7597
7643
  readonly create: (context: RuleContext) => RuleVisitors;
7598
7644
  };
7599
7645
  }, {
7600
- readonly key: "react-doctor/rn-animation-reaction-as-derived";
7601
- readonly id: "rn-animation-reaction-as-derived";
7646
+ readonly key: "react-doctor/rerender-derived-state-from-hook";
7647
+ readonly id: "rerender-derived-state-from-hook";
7602
7648
  readonly source: "react-doctor";
7603
7649
  readonly originallyExternal: false;
7604
7650
  readonly rule: {
7605
- readonly framework: "react-native";
7606
- readonly category: "Bugs";
7607
- readonly tags: readonly string[];
7651
+ readonly framework: "global";
7652
+ readonly category: "Performance";
7653
+ readonly requires: readonly Capability[];
7608
7654
  readonly id: string;
7609
7655
  readonly title?: string;
7610
7656
  readonly severity: RuleSeverity;
7611
- readonly requires?: ReadonlyArray<Capability>;
7612
7657
  readonly disabledWhen?: ReadonlyArray<Capability>;
7658
+ readonly tags?: ReadonlyArray<string>;
7613
7659
  readonly matchByOccurrence?: boolean;
7614
7660
  readonly defaultEnabled?: boolean;
7615
7661
  readonly lifecycle?: "retired";
@@ -7620,19 +7666,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7620
7666
  readonly create: (context: RuleContext) => RuleVisitors;
7621
7667
  };
7622
7668
  }, {
7623
- readonly key: "react-doctor/rn-bottom-sheet-prefer-native";
7624
- readonly id: "rn-bottom-sheet-prefer-native";
7669
+ readonly key: "react-doctor/rerender-functional-setstate";
7670
+ readonly id: "rerender-functional-setstate";
7625
7671
  readonly source: "react-doctor";
7626
7672
  readonly originallyExternal: false;
7627
7673
  readonly rule: {
7628
- readonly framework: "react-native";
7629
- readonly category: "Bugs";
7630
- readonly tags: readonly string[];
7674
+ readonly framework: "global";
7675
+ readonly category: "Performance";
7676
+ readonly requires: readonly Capability[];
7631
7677
  readonly id: string;
7632
7678
  readonly title?: string;
7633
7679
  readonly severity: RuleSeverity;
7634
- readonly requires?: ReadonlyArray<Capability>;
7635
7680
  readonly disabledWhen?: ReadonlyArray<Capability>;
7681
+ readonly tags?: ReadonlyArray<string>;
7636
7682
  readonly matchByOccurrence?: boolean;
7637
7683
  readonly defaultEnabled?: boolean;
7638
7684
  readonly lifecycle?: "retired";
@@ -7643,19 +7689,19 @@ declare const REACT_DOCTOR_RULES: readonly [{
7643
7689
  readonly create: (context: RuleContext) => RuleVisitors;
7644
7690
  };
7645
7691
  }, {
7646
- readonly key: "react-doctor/rn-detox-missing-await";
7647
- readonly id: "rn-detox-missing-await";
7692
+ readonly key: "react-doctor/rerender-lazy-ref-init";
7693
+ readonly id: "rerender-lazy-ref-init";
7648
7694
  readonly source: "react-doctor";
7649
7695
  readonly originallyExternal: false;
7650
7696
  readonly rule: {
7651
- readonly framework: "react-native";
7652
- readonly category: "Bugs";
7653
- readonly tags: readonly string[];
7697
+ readonly framework: "global";
7698
+ readonly category: "Performance";
7699
+ readonly requires: readonly Capability[];
7654
7700
  readonly id: string;
7655
7701
  readonly title?: string;
7656
7702
  readonly severity: RuleSeverity;
7657
- readonly requires?: ReadonlyArray<Capability>;
7658
7703
  readonly disabledWhen?: ReadonlyArray<Capability>;
7704
+ readonly tags?: ReadonlyArray<string>;
7659
7705
  readonly matchByOccurrence?: boolean;
7660
7706
  readonly defaultEnabled?: boolean;
7661
7707
  readonly lifecycle?: "retired";
@@ -7666,8 +7712,215 @@ declare const REACT_DOCTOR_RULES: readonly [{
7666
7712
  readonly create: (context: RuleContext) => RuleVisitors;
7667
7713
  };
7668
7714
  }, {
7669
- readonly key: "react-doctor/rn-list-callback-per-row";
7670
- readonly id: "rn-list-callback-per-row";
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";
7671
7924
  readonly source: "react-doctor";
7672
7925
  readonly originallyExternal: false;
7673
7926
  readonly rule: {
@@ -9275,6 +9528,52 @@ declare const REACT_DOCTOR_RULES: readonly [{
9275
9528
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9276
9529
  readonly create: (context: RuleContext) => RuleVisitors;
9277
9530
  };
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
+ };
9278
9577
  }, {
9279
9578
  readonly key: "react-doctor/void-dom-elements-no-children";
9280
9579
  readonly id: "void-dom-elements-no-children";
@@ -9413,6 +9712,52 @@ declare const REACT_DOCTOR_RULES: readonly [{
9413
9712
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
9414
9713
  readonly create: (context: RuleContext) => RuleVisitors;
9415
9714
  };
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
+ };
9416
9761
  }];
9417
9762
  declare const EXTERNAL_RULES: readonly [{
9418
9763
  readonly key: "react-hooks-js/set-state-in-render";
@@ -9437,7 +9782,7 @@ declare const EXTERNAL_RULES: readonly [{
9437
9782
  }, {
9438
9783
  readonly key: "react-hooks-js/set-state-in-effect";
9439
9784
  readonly source: "react-compiler";
9440
- readonly severity: "error";
9785
+ readonly severity: "warn";
9441
9786
  }, {
9442
9787
  readonly key: "react-hooks-js/globals";
9443
9788
  readonly source: "react-compiler";
@@ -11733,29 +12078,6 @@ declare const RULES: readonly [{
11733
12078
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
11734
12079
  readonly create: (context: RuleContext) => RuleVisitors;
11735
12080
  };
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
- };
11759
12081
  }, {
11760
12082
  readonly key: "react-doctor/jsx-no-undef";
11761
12083
  readonly id: "jsx-no-undef";
@@ -11921,16 +12243,85 @@ declare const RULES: readonly [{
11921
12243
  readonly key: "react-doctor/label-has-associated-control";
11922
12244
  readonly id: "label-has-associated-control";
11923
12245
  readonly source: "react-doctor";
11924
- readonly originallyExternal: true;
12246
+ readonly originallyExternal: true;
12247
+ 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;
11925
12316
  readonly rule: {
11926
12317
  readonly framework: "global";
11927
- readonly category: "Accessibility";
11928
- readonly requires: readonly Capability[];
12318
+ readonly category: "Security";
12319
+ readonly tags: readonly string[];
11929
12320
  readonly id: string;
11930
12321
  readonly title?: string;
11931
12322
  readonly severity: RuleSeverity;
12323
+ readonly requires?: ReadonlyArray<Capability>;
11932
12324
  readonly disabledWhen?: ReadonlyArray<Capability>;
11933
- readonly tags?: ReadonlyArray<string>;
11934
12325
  readonly matchByOccurrence?: boolean;
11935
12326
  readonly defaultEnabled?: boolean;
11936
12327
  readonly lifecycle?: "retired";
@@ -11941,19 +12332,19 @@ declare const RULES: readonly [{
11941
12332
  readonly create: (context: RuleContext) => RuleVisitors;
11942
12333
  };
11943
12334
  }, {
11944
- readonly key: "react-doctor/lang";
11945
- readonly id: "lang";
12335
+ readonly key: "react-doctor/mdx-ssr-execution-risk";
12336
+ readonly id: "mdx-ssr-execution-risk";
11946
12337
  readonly source: "react-doctor";
11947
- readonly originallyExternal: true;
12338
+ readonly originallyExternal: false;
11948
12339
  readonly rule: {
11949
12340
  readonly framework: "global";
11950
- readonly category: "Accessibility";
11951
- readonly requires: readonly Capability[];
12341
+ readonly category: "Security";
12342
+ readonly tags: readonly string[];
11952
12343
  readonly id: string;
11953
12344
  readonly title?: string;
11954
12345
  readonly severity: RuleSeverity;
12346
+ readonly requires?: ReadonlyArray<Capability>;
11955
12347
  readonly disabledWhen?: ReadonlyArray<Capability>;
11956
- readonly tags?: ReadonlyArray<string>;
11957
12348
  readonly matchByOccurrence?: boolean;
11958
12349
  readonly defaultEnabled?: boolean;
11959
12350
  readonly lifecycle?: "retired";
@@ -11964,19 +12355,19 @@ declare const RULES: readonly [{
11964
12355
  readonly create: (context: RuleContext) => RuleVisitors;
11965
12356
  };
11966
12357
  }, {
11967
- readonly key: "react-doctor/local-rpc-native-bridge-risk";
11968
- readonly id: "local-rpc-native-bridge-risk";
12358
+ readonly key: "react-doctor/media-has-caption";
12359
+ readonly id: "media-has-caption";
11969
12360
  readonly source: "react-doctor";
11970
- readonly originallyExternal: false;
12361
+ readonly originallyExternal: true;
11971
12362
  readonly rule: {
11972
12363
  readonly framework: "global";
11973
- readonly category: "Security";
11974
- readonly tags: readonly string[];
12364
+ readonly category: "Accessibility";
12365
+ readonly requires: readonly Capability[];
11975
12366
  readonly id: string;
11976
12367
  readonly title?: string;
11977
12368
  readonly severity: RuleSeverity;
11978
- readonly requires?: ReadonlyArray<Capability>;
11979
12369
  readonly disabledWhen?: ReadonlyArray<Capability>;
12370
+ readonly tags?: ReadonlyArray<string>;
11980
12371
  readonly matchByOccurrence?: boolean;
11981
12372
  readonly defaultEnabled?: boolean;
11982
12373
  readonly lifecycle?: "retired";
@@ -11987,19 +12378,19 @@ declare const RULES: readonly [{
11987
12378
  readonly create: (context: RuleContext) => RuleVisitors;
11988
12379
  };
11989
12380
  }, {
11990
- readonly key: "react-doctor/mcp-tool-capability-risk";
11991
- readonly id: "mcp-tool-capability-risk";
12381
+ readonly key: "react-doctor/mobx-no-make-auto-observable-in-inheritance";
12382
+ readonly id: "mobx-no-make-auto-observable-in-inheritance";
11992
12383
  readonly source: "react-doctor";
11993
12384
  readonly originallyExternal: false;
11994
12385
  readonly rule: {
11995
12386
  readonly framework: "global";
11996
- readonly category: "Security";
11997
- readonly tags: readonly string[];
12387
+ readonly category: "Bugs";
11998
12388
  readonly id: string;
11999
12389
  readonly title?: string;
12000
12390
  readonly severity: RuleSeverity;
12001
12391
  readonly requires?: ReadonlyArray<Capability>;
12002
12392
  readonly disabledWhen?: ReadonlyArray<Capability>;
12393
+ readonly tags?: ReadonlyArray<string>;
12003
12394
  readonly matchByOccurrence?: boolean;
12004
12395
  readonly defaultEnabled?: boolean;
12005
12396
  readonly lifecycle?: "retired";
@@ -12010,19 +12401,19 @@ declare const RULES: readonly [{
12010
12401
  readonly create: (context: RuleContext) => RuleVisitors;
12011
12402
  };
12012
12403
  }, {
12013
- readonly key: "react-doctor/mdx-ssr-execution-risk";
12014
- readonly id: "mdx-ssr-execution-risk";
12404
+ readonly key: "react-doctor/mobx-no-observer-wrapped-memo";
12405
+ readonly id: "mobx-no-observer-wrapped-memo";
12015
12406
  readonly source: "react-doctor";
12016
12407
  readonly originallyExternal: false;
12017
12408
  readonly rule: {
12018
12409
  readonly framework: "global";
12019
- readonly category: "Security";
12020
- readonly tags: readonly string[];
12410
+ readonly category: "Bugs";
12021
12411
  readonly id: string;
12022
12412
  readonly title?: string;
12023
12413
  readonly severity: RuleSeverity;
12024
12414
  readonly requires?: ReadonlyArray<Capability>;
12025
12415
  readonly disabledWhen?: ReadonlyArray<Capability>;
12416
+ readonly tags?: ReadonlyArray<string>;
12026
12417
  readonly matchByOccurrence?: boolean;
12027
12418
  readonly defaultEnabled?: boolean;
12028
12419
  readonly lifecycle?: "retired";
@@ -12033,17 +12424,17 @@ declare const RULES: readonly [{
12033
12424
  readonly create: (context: RuleContext) => RuleVisitors;
12034
12425
  };
12035
12426
  }, {
12036
- readonly key: "react-doctor/media-has-caption";
12037
- readonly id: "media-has-caption";
12427
+ readonly key: "react-doctor/mobx-reaction-disposer-discarded";
12428
+ readonly id: "mobx-reaction-disposer-discarded";
12038
12429
  readonly source: "react-doctor";
12039
- readonly originallyExternal: true;
12430
+ readonly originallyExternal: false;
12040
12431
  readonly rule: {
12041
12432
  readonly framework: "global";
12042
- readonly category: "Accessibility";
12043
- readonly requires: readonly Capability[];
12433
+ readonly category: "Bugs";
12044
12434
  readonly id: string;
12045
12435
  readonly title?: string;
12046
12436
  readonly severity: RuleSeverity;
12437
+ readonly requires?: ReadonlyArray<Capability>;
12047
12438
  readonly disabledWhen?: ReadonlyArray<Capability>;
12048
12439
  readonly tags?: ReadonlyArray<string>;
12049
12440
  readonly matchByOccurrence?: boolean;
@@ -15863,7 +16254,214 @@ declare const RULES: readonly [{
15863
16254
  readonly title?: string;
15864
16255
  readonly severity: RuleSeverity;
15865
16256
  readonly disabledWhen?: ReadonlyArray<Capability>;
15866
- readonly tags?: ReadonlyArray<string>;
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[];
16460
+ readonly id: string;
16461
+ readonly title?: string;
16462
+ readonly severity: RuleSeverity;
16463
+ readonly requires?: ReadonlyArray<Capability>;
16464
+ readonly disabledWhen?: ReadonlyArray<Capability>;
15867
16465
  readonly matchByOccurrence?: boolean;
15868
16466
  readonly defaultEnabled?: boolean;
15869
16467
  readonly lifecycle?: "retired";
@@ -15874,19 +16472,19 @@ declare const RULES: readonly [{
15874
16472
  readonly create: (context: RuleContext) => RuleVisitors;
15875
16473
  };
15876
16474
  }, {
15877
- readonly key: "react-doctor/prefer-html-dialog";
15878
- readonly id: "prefer-html-dialog";
16475
+ readonly key: "react-doctor/public-env-secret-name";
16476
+ readonly id: "public-env-secret-name";
15879
16477
  readonly source: "react-doctor";
15880
16478
  readonly originallyExternal: false;
15881
16479
  readonly rule: {
15882
16480
  readonly framework: "global";
15883
- readonly category: "Accessibility";
15884
- readonly requires: readonly Capability[];
16481
+ readonly category: "Security";
16482
+ readonly tags: readonly string[];
15885
16483
  readonly id: string;
15886
16484
  readonly title?: string;
15887
16485
  readonly severity: RuleSeverity;
16486
+ readonly requires?: ReadonlyArray<Capability>;
15888
16487
  readonly disabledWhen?: ReadonlyArray<Capability>;
15889
- readonly tags?: ReadonlyArray<string>;
15890
16488
  readonly matchByOccurrence?: boolean;
15891
16489
  readonly defaultEnabled?: boolean;
15892
16490
  readonly lifecycle?: "retired";
@@ -15897,13 +16495,13 @@ declare const RULES: readonly [{
15897
16495
  readonly create: (context: RuleContext) => RuleVisitors;
15898
16496
  };
15899
16497
  }, {
15900
- readonly key: "react-doctor/prefer-module-scope-pure-function";
15901
- readonly id: "prefer-module-scope-pure-function";
16498
+ readonly key: "react-doctor/query-destructure-result";
16499
+ readonly id: "query-destructure-result";
15902
16500
  readonly source: "react-doctor";
15903
16501
  readonly originallyExternal: false;
15904
16502
  readonly rule: {
15905
- readonly framework: "global";
15906
- readonly category: "Maintainability";
16503
+ readonly framework: "tanstack-query";
16504
+ readonly category: "Bugs";
15907
16505
  readonly id: string;
15908
16506
  readonly title?: string;
15909
16507
  readonly severity: RuleSeverity;
@@ -15920,13 +16518,13 @@ declare const RULES: readonly [{
15920
16518
  readonly create: (context: RuleContext) => RuleVisitors;
15921
16519
  };
15922
16520
  }, {
15923
- readonly key: "react-doctor/prefer-module-scope-static-value";
15924
- readonly id: "prefer-module-scope-static-value";
16521
+ readonly key: "react-doctor/query-mutation-missing-invalidation";
16522
+ readonly id: "query-mutation-missing-invalidation";
15925
16523
  readonly source: "react-doctor";
15926
16524
  readonly originallyExternal: false;
15927
16525
  readonly rule: {
15928
- readonly framework: "global";
15929
- readonly category: "Maintainability";
16526
+ readonly framework: "tanstack-query";
16527
+ readonly category: "Bugs";
15930
16528
  readonly id: string;
15931
16529
  readonly title?: string;
15932
16530
  readonly severity: RuleSeverity;
@@ -15943,17 +16541,17 @@ declare const RULES: readonly [{
15943
16541
  readonly create: (context: RuleContext) => RuleVisitors;
15944
16542
  };
15945
16543
  }, {
15946
- readonly key: "react-doctor/prefer-stable-empty-fallback";
15947
- readonly id: "prefer-stable-empty-fallback";
16544
+ readonly key: "react-doctor/query-no-query-in-effect";
16545
+ readonly id: "query-no-query-in-effect";
15948
16546
  readonly source: "react-doctor";
15949
16547
  readonly originallyExternal: false;
15950
16548
  readonly rule: {
15951
- readonly framework: "global";
15952
- readonly category: "Performance";
15953
- readonly requires: readonly Capability[];
16549
+ readonly framework: "tanstack-query";
16550
+ readonly category: "Bugs";
15954
16551
  readonly id: string;
15955
16552
  readonly title?: string;
15956
16553
  readonly severity: RuleSeverity;
16554
+ readonly requires?: ReadonlyArray<Capability>;
15957
16555
  readonly disabledWhen?: ReadonlyArray<Capability>;
15958
16556
  readonly tags?: ReadonlyArray<string>;
15959
16557
  readonly matchByOccurrence?: boolean;
@@ -15966,17 +16564,17 @@ declare const RULES: readonly [{
15966
16564
  readonly create: (context: RuleContext) => RuleVisitors;
15967
16565
  };
15968
16566
  }, {
15969
- readonly key: "react-doctor/prefer-tag-over-role";
15970
- readonly id: "prefer-tag-over-role";
16567
+ readonly key: "react-doctor/query-no-rest-destructuring";
16568
+ readonly id: "query-no-rest-destructuring";
15971
16569
  readonly source: "react-doctor";
15972
- readonly originallyExternal: true;
16570
+ readonly originallyExternal: false;
15973
16571
  readonly rule: {
15974
- readonly framework: "global";
15975
- readonly category: "Accessibility";
15976
- readonly requires: readonly Capability[];
16572
+ readonly framework: "tanstack-query";
16573
+ readonly category: "Bugs";
15977
16574
  readonly id: string;
15978
16575
  readonly title?: string;
15979
16576
  readonly severity: RuleSeverity;
16577
+ readonly requires?: ReadonlyArray<Capability>;
15980
16578
  readonly disabledWhen?: ReadonlyArray<Capability>;
15981
16579
  readonly tags?: ReadonlyArray<string>;
15982
16580
  readonly matchByOccurrence?: boolean;
@@ -15989,17 +16587,17 @@ declare const RULES: readonly [{
15989
16587
  readonly create: (context: RuleContext) => RuleVisitors;
15990
16588
  };
15991
16589
  }, {
15992
- readonly key: "react-doctor/prefer-use-effect-event";
15993
- readonly id: "prefer-use-effect-event";
16590
+ readonly key: "react-doctor/query-no-usequery-for-mutation";
16591
+ readonly id: "query-no-usequery-for-mutation";
15994
16592
  readonly source: "react-doctor";
15995
16593
  readonly originallyExternal: false;
15996
16594
  readonly rule: {
15997
- readonly framework: "global";
16595
+ readonly framework: "tanstack-query";
15998
16596
  readonly category: "Bugs";
15999
- readonly requires: readonly Capability[];
16000
16597
  readonly id: string;
16001
16598
  readonly title?: string;
16002
16599
  readonly severity: RuleSeverity;
16600
+ readonly requires?: ReadonlyArray<Capability>;
16003
16601
  readonly disabledWhen?: ReadonlyArray<Capability>;
16004
16602
  readonly tags?: ReadonlyArray<string>;
16005
16603
  readonly matchByOccurrence?: boolean;
@@ -16012,17 +16610,17 @@ declare const RULES: readonly [{
16012
16610
  readonly create: (context: RuleContext) => RuleVisitors;
16013
16611
  };
16014
16612
  }, {
16015
- readonly key: "react-doctor/prefer-use-sync-external-store";
16016
- readonly id: "prefer-use-sync-external-store";
16613
+ readonly key: "react-doctor/query-no-void-query-fn";
16614
+ readonly id: "query-no-void-query-fn";
16017
16615
  readonly source: "react-doctor";
16018
16616
  readonly originallyExternal: false;
16019
16617
  readonly rule: {
16020
- readonly framework: "global";
16618
+ readonly framework: "tanstack-query";
16021
16619
  readonly category: "Bugs";
16022
- readonly requires: readonly Capability[];
16023
16620
  readonly id: string;
16024
16621
  readonly title?: string;
16025
16622
  readonly severity: RuleSeverity;
16623
+ readonly requires?: ReadonlyArray<Capability>;
16026
16624
  readonly disabledWhen?: ReadonlyArray<Capability>;
16027
16625
  readonly tags?: ReadonlyArray<string>;
16028
16626
  readonly matchByOccurrence?: boolean;
@@ -16035,17 +16633,17 @@ declare const RULES: readonly [{
16035
16633
  readonly create: (context: RuleContext) => RuleVisitors;
16036
16634
  };
16037
16635
  }, {
16038
- readonly key: "react-doctor/prefer-useReducer";
16039
- readonly id: "prefer-useReducer";
16636
+ readonly key: "react-doctor/query-stable-query-client";
16637
+ readonly id: "query-stable-query-client";
16040
16638
  readonly source: "react-doctor";
16041
16639
  readonly originallyExternal: false;
16042
16640
  readonly rule: {
16043
- readonly framework: "global";
16641
+ readonly framework: "tanstack-query";
16044
16642
  readonly category: "Bugs";
16045
- readonly requires: readonly Capability[];
16046
16643
  readonly id: string;
16047
16644
  readonly title?: string;
16048
16645
  readonly severity: RuleSeverity;
16646
+ readonly requires?: ReadonlyArray<Capability>;
16049
16647
  readonly disabledWhen?: ReadonlyArray<Capability>;
16050
16648
  readonly tags?: ReadonlyArray<string>;
16051
16649
  readonly matchByOccurrence?: boolean;
@@ -16058,8 +16656,8 @@ declare const RULES: readonly [{
16058
16656
  readonly create: (context: RuleContext) => RuleVisitors;
16059
16657
  };
16060
16658
  }, {
16061
- readonly key: "react-doctor/public-debug-artifact";
16062
- readonly id: "public-debug-artifact";
16659
+ readonly key: "react-doctor/raw-sql-injection-risk";
16660
+ readonly id: "raw-sql-injection-risk";
16063
16661
  readonly source: "react-doctor";
16064
16662
  readonly originallyExternal: false;
16065
16663
  readonly rule: {
@@ -16081,19 +16679,19 @@ declare const RULES: readonly [{
16081
16679
  readonly create: (context: RuleContext) => RuleVisitors;
16082
16680
  };
16083
16681
  }, {
16084
- readonly key: "react-doctor/public-env-secret-name";
16085
- readonly id: "public-env-secret-name";
16682
+ readonly key: "react-doctor/react-compiler-no-manual-memoization";
16683
+ readonly id: "react-compiler-no-manual-memoization";
16086
16684
  readonly source: "react-doctor";
16087
16685
  readonly originallyExternal: false;
16088
16686
  readonly rule: {
16089
16687
  readonly framework: "global";
16090
- readonly category: "Security";
16091
- readonly tags: readonly string[];
16688
+ readonly category: "Maintainability";
16092
16689
  readonly id: string;
16093
16690
  readonly title?: string;
16094
16691
  readonly severity: RuleSeverity;
16095
16692
  readonly requires?: ReadonlyArray<Capability>;
16096
16693
  readonly disabledWhen?: ReadonlyArray<Capability>;
16694
+ readonly tags?: ReadonlyArray<string>;
16097
16695
  readonly matchByOccurrence?: boolean;
16098
16696
  readonly defaultEnabled?: boolean;
16099
16697
  readonly lifecycle?: "retired";
@@ -16104,17 +16702,17 @@ declare const RULES: readonly [{
16104
16702
  readonly create: (context: RuleContext) => RuleVisitors;
16105
16703
  };
16106
16704
  }, {
16107
- readonly key: "react-doctor/query-destructure-result";
16108
- readonly id: "query-destructure-result";
16705
+ readonly key: "react-doctor/react-in-jsx-scope";
16706
+ readonly id: "react-in-jsx-scope";
16109
16707
  readonly source: "react-doctor";
16110
- readonly originallyExternal: false;
16708
+ readonly originallyExternal: true;
16111
16709
  readonly rule: {
16112
- readonly framework: "tanstack-query";
16710
+ readonly framework: "global";
16113
16711
  readonly category: "Bugs";
16712
+ readonly requires: readonly Capability[];
16114
16713
  readonly id: string;
16115
16714
  readonly title?: string;
16116
16715
  readonly severity: RuleSeverity;
16117
- readonly requires?: ReadonlyArray<Capability>;
16118
16716
  readonly disabledWhen?: ReadonlyArray<Capability>;
16119
16717
  readonly tags?: ReadonlyArray<string>;
16120
16718
  readonly matchByOccurrence?: boolean;
@@ -16127,13 +16725,13 @@ declare const RULES: readonly [{
16127
16725
  readonly create: (context: RuleContext) => RuleVisitors;
16128
16726
  };
16129
16727
  }, {
16130
- readonly key: "react-doctor/query-mutation-missing-invalidation";
16131
- readonly id: "query-mutation-missing-invalidation";
16728
+ readonly key: "react-doctor/react-markdown-unsanitized-raw-html";
16729
+ readonly id: "react-markdown-unsanitized-raw-html";
16132
16730
  readonly source: "react-doctor";
16133
16731
  readonly originallyExternal: false;
16134
16732
  readonly rule: {
16135
- readonly framework: "tanstack-query";
16136
- readonly category: "Bugs";
16733
+ readonly framework: "global";
16734
+ readonly category: "Security";
16137
16735
  readonly id: string;
16138
16736
  readonly title?: string;
16139
16737
  readonly severity: RuleSeverity;
@@ -16150,17 +16748,17 @@ declare const RULES: readonly [{
16150
16748
  readonly create: (context: RuleContext) => RuleVisitors;
16151
16749
  };
16152
16750
  }, {
16153
- readonly key: "react-doctor/query-no-query-in-effect";
16154
- readonly id: "query-no-query-in-effect";
16751
+ readonly key: "react-doctor/redux-useselector-inline-derivation";
16752
+ readonly id: "redux-useselector-inline-derivation";
16155
16753
  readonly source: "react-doctor";
16156
16754
  readonly originallyExternal: false;
16157
16755
  readonly rule: {
16158
- readonly framework: "tanstack-query";
16159
- readonly category: "Bugs";
16756
+ readonly framework: "global";
16757
+ readonly category: "Performance";
16758
+ readonly requires: readonly Capability[];
16160
16759
  readonly id: string;
16161
16760
  readonly title?: string;
16162
16761
  readonly severity: RuleSeverity;
16163
- readonly requires?: ReadonlyArray<Capability>;
16164
16762
  readonly disabledWhen?: ReadonlyArray<Capability>;
16165
16763
  readonly tags?: ReadonlyArray<string>;
16166
16764
  readonly matchByOccurrence?: boolean;
@@ -16173,17 +16771,17 @@ declare const RULES: readonly [{
16173
16771
  readonly create: (context: RuleContext) => RuleVisitors;
16174
16772
  };
16175
16773
  }, {
16176
- readonly key: "react-doctor/query-no-rest-destructuring";
16177
- readonly id: "query-no-rest-destructuring";
16774
+ readonly key: "react-doctor/redux-useselector-returns-new-collection";
16775
+ readonly id: "redux-useselector-returns-new-collection";
16178
16776
  readonly source: "react-doctor";
16179
16777
  readonly originallyExternal: false;
16180
16778
  readonly rule: {
16181
- readonly framework: "tanstack-query";
16182
- readonly category: "Bugs";
16779
+ readonly framework: "global";
16780
+ readonly category: "Performance";
16781
+ readonly requires: readonly Capability[];
16183
16782
  readonly id: string;
16184
16783
  readonly title?: string;
16185
16784
  readonly severity: RuleSeverity;
16186
- readonly requires?: ReadonlyArray<Capability>;
16187
16785
  readonly disabledWhen?: ReadonlyArray<Capability>;
16188
16786
  readonly tags?: ReadonlyArray<string>;
16189
16787
  readonly matchByOccurrence?: boolean;
@@ -16196,12 +16794,12 @@ declare const RULES: readonly [{
16196
16794
  readonly create: (context: RuleContext) => RuleVisitors;
16197
16795
  };
16198
16796
  }, {
16199
- readonly key: "react-doctor/query-no-usequery-for-mutation";
16200
- readonly id: "query-no-usequery-for-mutation";
16797
+ readonly key: "react-doctor/remotion-calculate-metadata-fetch-signal";
16798
+ readonly id: "remotion-calculate-metadata-fetch-signal";
16201
16799
  readonly source: "react-doctor";
16202
16800
  readonly originallyExternal: false;
16203
16801
  readonly rule: {
16204
- readonly framework: "tanstack-query";
16802
+ readonly framework: "global";
16205
16803
  readonly category: "Bugs";
16206
16804
  readonly id: string;
16207
16805
  readonly title?: string;
@@ -16219,12 +16817,12 @@ declare const RULES: readonly [{
16219
16817
  readonly create: (context: RuleContext) => RuleVisitors;
16220
16818
  };
16221
16819
  }, {
16222
- readonly key: "react-doctor/query-no-void-query-fn";
16223
- readonly id: "query-no-void-query-fn";
16820
+ readonly key: "react-doctor/remotion-deterministic-randomness";
16821
+ readonly id: "remotion-deterministic-randomness";
16224
16822
  readonly source: "react-doctor";
16225
16823
  readonly originallyExternal: false;
16226
16824
  readonly rule: {
16227
- readonly framework: "tanstack-query";
16825
+ readonly framework: "global";
16228
16826
  readonly category: "Bugs";
16229
16827
  readonly id: string;
16230
16828
  readonly title?: string;
@@ -16242,12 +16840,12 @@ declare const RULES: readonly [{
16242
16840
  readonly create: (context: RuleContext) => RuleVisitors;
16243
16841
  };
16244
16842
  }, {
16245
- readonly key: "react-doctor/query-stable-query-client";
16246
- readonly id: "query-stable-query-client";
16843
+ readonly key: "react-doctor/remotion-no-css-animation";
16844
+ readonly id: "remotion-no-css-animation";
16247
16845
  readonly source: "react-doctor";
16248
16846
  readonly originallyExternal: false;
16249
16847
  readonly rule: {
16250
- readonly framework: "tanstack-query";
16848
+ readonly framework: "global";
16251
16849
  readonly category: "Bugs";
16252
16850
  readonly id: string;
16253
16851
  readonly title?: string;
@@ -16265,19 +16863,19 @@ declare const RULES: readonly [{
16265
16863
  readonly create: (context: RuleContext) => RuleVisitors;
16266
16864
  };
16267
16865
  }, {
16268
- readonly key: "react-doctor/raw-sql-injection-risk";
16269
- readonly id: "raw-sql-injection-risk";
16866
+ readonly key: "react-doctor/remotion-no-css-transition";
16867
+ readonly id: "remotion-no-css-transition";
16270
16868
  readonly source: "react-doctor";
16271
16869
  readonly originallyExternal: false;
16272
16870
  readonly rule: {
16273
16871
  readonly framework: "global";
16274
- readonly category: "Security";
16275
- readonly tags: readonly string[];
16872
+ readonly category: "Bugs";
16276
16873
  readonly id: string;
16277
16874
  readonly title?: string;
16278
16875
  readonly severity: RuleSeverity;
16279
16876
  readonly requires?: ReadonlyArray<Capability>;
16280
16877
  readonly disabledWhen?: ReadonlyArray<Capability>;
16878
+ readonly tags?: ReadonlyArray<string>;
16281
16879
  readonly matchByOccurrence?: boolean;
16282
16880
  readonly defaultEnabled?: boolean;
16283
16881
  readonly lifecycle?: "retired";
@@ -16288,13 +16886,13 @@ declare const RULES: readonly [{
16288
16886
  readonly create: (context: RuleContext) => RuleVisitors;
16289
16887
  };
16290
16888
  }, {
16291
- readonly key: "react-doctor/react-compiler-no-manual-memoization";
16292
- readonly id: "react-compiler-no-manual-memoization";
16889
+ readonly key: "react-doctor/remotion-no-css-url-assets";
16890
+ readonly id: "remotion-no-css-url-assets";
16293
16891
  readonly source: "react-doctor";
16294
16892
  readonly originallyExternal: false;
16295
16893
  readonly rule: {
16296
16894
  readonly framework: "global";
16297
- readonly category: "Maintainability";
16895
+ readonly category: "Bugs";
16298
16896
  readonly id: string;
16299
16897
  readonly title?: string;
16300
16898
  readonly severity: RuleSeverity;
@@ -16311,17 +16909,17 @@ declare const RULES: readonly [{
16311
16909
  readonly create: (context: RuleContext) => RuleVisitors;
16312
16910
  };
16313
16911
  }, {
16314
- readonly key: "react-doctor/react-in-jsx-scope";
16315
- readonly id: "react-in-jsx-scope";
16912
+ readonly key: "react-doctor/remotion-no-module-scope-delay-render";
16913
+ readonly id: "remotion-no-module-scope-delay-render";
16316
16914
  readonly source: "react-doctor";
16317
- readonly originallyExternal: true;
16915
+ readonly originallyExternal: false;
16318
16916
  readonly rule: {
16319
16917
  readonly framework: "global";
16320
16918
  readonly category: "Bugs";
16321
- readonly requires: readonly Capability[];
16322
16919
  readonly id: string;
16323
16920
  readonly title?: string;
16324
16921
  readonly severity: RuleSeverity;
16922
+ readonly requires?: ReadonlyArray<Capability>;
16325
16923
  readonly disabledWhen?: ReadonlyArray<Capability>;
16326
16924
  readonly tags?: ReadonlyArray<string>;
16327
16925
  readonly matchByOccurrence?: boolean;
@@ -16334,13 +16932,13 @@ declare const RULES: readonly [{
16334
16932
  readonly create: (context: RuleContext) => RuleVisitors;
16335
16933
  };
16336
16934
  }, {
16337
- readonly key: "react-doctor/react-markdown-unsanitized-raw-html";
16338
- readonly id: "react-markdown-unsanitized-raw-html";
16935
+ readonly key: "react-doctor/remotion-no-native-media-elements";
16936
+ readonly id: "remotion-no-native-media-elements";
16339
16937
  readonly source: "react-doctor";
16340
16938
  readonly originallyExternal: false;
16341
16939
  readonly rule: {
16342
16940
  readonly framework: "global";
16343
- readonly category: "Security";
16941
+ readonly category: "Bugs";
16344
16942
  readonly id: string;
16345
16943
  readonly title?: string;
16346
16944
  readonly severity: RuleSeverity;
@@ -16357,17 +16955,17 @@ declare const RULES: readonly [{
16357
16955
  readonly create: (context: RuleContext) => RuleVisitors;
16358
16956
  };
16359
16957
  }, {
16360
- readonly key: "react-doctor/redux-useselector-inline-derivation";
16361
- readonly id: "redux-useselector-inline-derivation";
16958
+ readonly key: "react-doctor/remotion-no-next-image";
16959
+ readonly id: "remotion-no-next-image";
16362
16960
  readonly source: "react-doctor";
16363
16961
  readonly originallyExternal: false;
16364
16962
  readonly rule: {
16365
16963
  readonly framework: "global";
16366
- readonly category: "Performance";
16367
- readonly requires: readonly Capability[];
16964
+ readonly category: "Bugs";
16368
16965
  readonly id: string;
16369
16966
  readonly title?: string;
16370
16967
  readonly severity: RuleSeverity;
16968
+ readonly requires?: ReadonlyArray<Capability>;
16371
16969
  readonly disabledWhen?: ReadonlyArray<Capability>;
16372
16970
  readonly tags?: ReadonlyArray<string>;
16373
16971
  readonly matchByOccurrence?: boolean;
@@ -16380,17 +16978,17 @@ declare const RULES: readonly [{
16380
16978
  readonly create: (context: RuleContext) => RuleVisitors;
16381
16979
  };
16382
16980
  }, {
16383
- readonly key: "react-doctor/redux-useselector-returns-new-collection";
16384
- readonly id: "redux-useselector-returns-new-collection";
16981
+ readonly key: "react-doctor/remotion-stable-delay-render-handle";
16982
+ readonly id: "remotion-stable-delay-render-handle";
16385
16983
  readonly source: "react-doctor";
16386
16984
  readonly originallyExternal: false;
16387
16985
  readonly rule: {
16388
16986
  readonly framework: "global";
16389
- readonly category: "Performance";
16390
- readonly requires: readonly Capability[];
16987
+ readonly category: "Bugs";
16391
16988
  readonly id: string;
16392
16989
  readonly title?: string;
16393
16990
  readonly severity: RuleSeverity;
16991
+ readonly requires?: ReadonlyArray<Capability>;
16394
16992
  readonly disabledWhen?: ReadonlyArray<Capability>;
16395
16993
  readonly tags?: ReadonlyArray<string>;
16396
16994
  readonly matchByOccurrence?: boolean;
@@ -18587,6 +19185,52 @@ declare const RULES: readonly [{
18587
19185
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
18588
19186
  readonly create: (context: RuleContext) => RuleVisitors;
18589
19187
  };
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
+ };
18590
19234
  }, {
18591
19235
  readonly key: "react-doctor/void-dom-elements-no-children";
18592
19236
  readonly id: "void-dom-elements-no-children";
@@ -18725,6 +19369,52 @@ declare const RULES: readonly [{
18725
19369
  readonly recommendationFor?: (hasCapability: CapabilityQuery) => string | undefined;
18726
19370
  readonly create: (context: RuleContext) => RuleVisitors;
18727
19371
  };
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
+ };
18728
19418
  }, {
18729
19419
  readonly key: "react-hooks-js/set-state-in-render";
18730
19420
  readonly source: "react-compiler";
@@ -18748,7 +19438,7 @@ declare const RULES: readonly [{
18748
19438
  }, {
18749
19439
  readonly key: "react-hooks-js/set-state-in-effect";
18750
19440
  readonly source: "react-compiler";
18751
- readonly severity: "error";
19441
+ readonly severity: "warn";
18752
19442
  }, {
18753
19443
  readonly key: "react-hooks-js/globals";
18754
19444
  readonly source: "react-compiler";