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.
- package/dist/index.d.ts +266 -956
- package/dist/index.js +899 -4568
- 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" | "
|
|
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/
|
|
7141
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7164
|
-
readonly id: "
|
|
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/
|
|
7187
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7210
|
-
readonly id: "
|
|
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/
|
|
7233
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7256
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7279
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7302
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7325
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
7348
|
-
readonly id: "
|
|
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: "
|
|
7354
|
-
readonly
|
|
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/
|
|
7371
|
-
readonly id: "
|
|
7324
|
+
readonly key: "react-doctor/require-render-return";
|
|
7325
|
+
readonly id: "require-render-return";
|
|
7372
7326
|
readonly source: "react-doctor";
|
|
7373
|
-
readonly originallyExternal:
|
|
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/
|
|
7394
|
-
readonly id: "
|
|
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/
|
|
7417
|
-
readonly id: "
|
|
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/
|
|
7440
|
-
readonly id: "
|
|
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/
|
|
7463
|
-
readonly id: "
|
|
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/
|
|
7486
|
-
readonly id: "
|
|
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/
|
|
7509
|
-
readonly id: "
|
|
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/
|
|
7532
|
-
readonly id: "
|
|
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: "
|
|
7538
|
-
readonly
|
|
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/
|
|
7555
|
-
readonly id: "
|
|
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: "
|
|
7561
|
-
readonly
|
|
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/
|
|
7578
|
-
readonly id: "
|
|
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:
|
|
7534
|
+
readonly originallyExternal: false;
|
|
7581
7535
|
readonly rule: {
|
|
7582
7536
|
readonly framework: "global";
|
|
7583
|
-
readonly category: "
|
|
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-
|
|
7601
|
-
readonly id: "rerender-
|
|
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/
|
|
7624
|
-
readonly id: "
|
|
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: "
|
|
7582
|
+
readonly framework: "react-native";
|
|
7629
7583
|
readonly category: "Bugs";
|
|
7630
|
-
readonly
|
|
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/
|
|
7647
|
-
readonly id: "
|
|
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: "
|
|
7652
|
-
readonly category: "
|
|
7653
|
-
readonly
|
|
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/
|
|
7670
|
-
readonly id: "
|
|
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: "
|
|
7675
|
-
readonly category: "
|
|
7676
|
-
readonly
|
|
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/
|
|
7693
|
-
readonly id: "
|
|
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: "
|
|
7698
|
-
readonly category: "
|
|
7699
|
-
readonly
|
|
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/
|
|
7716
|
-
readonly id: "
|
|
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/
|
|
12336
|
-
readonly id: "
|
|
11944
|
+
readonly key: "react-doctor/lang";
|
|
11945
|
+
readonly id: "lang";
|
|
12337
11946
|
readonly source: "react-doctor";
|
|
12338
|
-
readonly originallyExternal:
|
|
11947
|
+
readonly originallyExternal: true;
|
|
12339
11948
|
readonly rule: {
|
|
12340
11949
|
readonly framework: "global";
|
|
12341
|
-
readonly category: "
|
|
12342
|
-
readonly
|
|
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/
|
|
12359
|
-
readonly id: "
|
|
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:
|
|
11970
|
+
readonly originallyExternal: false;
|
|
12362
11971
|
readonly rule: {
|
|
12363
11972
|
readonly framework: "global";
|
|
12364
|
-
readonly category: "
|
|
12365
|
-
readonly
|
|
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/
|
|
12382
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
12405
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
12428
|
-
readonly id: "
|
|
12036
|
+
readonly key: "react-doctor/media-has-caption";
|
|
12037
|
+
readonly id: "media-has-caption";
|
|
12429
12038
|
readonly source: "react-doctor";
|
|
12430
|
-
readonly originallyExternal:
|
|
12039
|
+
readonly originallyExternal: true;
|
|
12431
12040
|
readonly rule: {
|
|
12432
12041
|
readonly framework: "global";
|
|
12433
|
-
readonly category: "
|
|
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/
|
|
16476
|
-
readonly id: "
|
|
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: "
|
|
16482
|
-
readonly
|
|
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/
|
|
16499
|
-
readonly id: "
|
|
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: "
|
|
16504
|
-
readonly category: "
|
|
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/
|
|
16522
|
-
readonly id: "
|
|
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: "
|
|
16527
|
-
readonly category: "
|
|
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/
|
|
16545
|
-
readonly id: "
|
|
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: "
|
|
16550
|
-
readonly category: "
|
|
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/
|
|
16568
|
-
readonly id: "
|
|
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:
|
|
15972
|
+
readonly originallyExternal: true;
|
|
16571
15973
|
readonly rule: {
|
|
16572
|
-
readonly framework: "
|
|
16573
|
-
readonly category: "
|
|
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/
|
|
16591
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16614
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16637
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16660
|
-
readonly id: "
|
|
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/
|
|
16683
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16706
|
-
readonly id: "
|
|
16107
|
+
readonly key: "react-doctor/query-destructure-result";
|
|
16108
|
+
readonly id: "query-destructure-result";
|
|
16707
16109
|
readonly source: "react-doctor";
|
|
16708
|
-
readonly originallyExternal:
|
|
16110
|
+
readonly originallyExternal: false;
|
|
16709
16111
|
readonly rule: {
|
|
16710
|
-
readonly framework: "
|
|
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/
|
|
16729
|
-
readonly id: "
|
|
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: "
|
|
16734
|
-
readonly category: "
|
|
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/
|
|
16752
|
-
readonly id: "
|
|
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: "
|
|
16757
|
-
readonly category: "
|
|
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/
|
|
16775
|
-
readonly id: "
|
|
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: "
|
|
16780
|
-
readonly category: "
|
|
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/
|
|
16798
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16821
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16844
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16867
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16890
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16913
|
-
readonly id: "
|
|
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:
|
|
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/
|
|
16936
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16959
|
-
readonly id: "
|
|
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: "
|
|
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/
|
|
16982
|
-
readonly id: "
|
|
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: "
|
|
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";
|