feat(eslint-plugin): [prefer-nullish-coalescing] allow ignorePrimitives option to be true

packages/eslint-plugin/docs/rules/prefer-nullish-coalescing.md

@@ -165,6 +165,8 @@ const foo: string | undefined = 'bar';
 foo ?? 'a string';
 ```
 
+Also, if you would like to ignore all primitives types, you can set `ignorePrimitives: true`. It would be equivalent to `ignorePrimitives: { string: true, number: true, bigint: true, boolean: true }`.
+
 ## When Not To Use It
 
 If you are not using TypeScript 3.7 (or greater), then you will not be able to use this rule, as the operator is not supported.

packages/eslint-plugin/src/rules/prefer-nullish-coalescing.ts

@@ -10,12 +10,14 @@ export type Options = [
     allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
     ignoreConditionalTests?: boolean;
     ignoreMixedLogicalExpressions?: boolean;
-    ignorePrimitives?: {
-      bigint?: boolean;
-      boolean?: boolean;
-      number?: boolean;
-      string?: boolean;
-    };
+    ignorePrimitives?:
+      | {
+          bigint?: boolean;
+          boolean?: boolean;
+          number?: boolean;
+          string?: boolean;
+        }
+      | true;
     ignoreTernaryTests?: boolean;
   },
 ];
@@ -60,13 +62,21 @@ export default util.createRule<Options, MessageIds>({
             type: 'boolean',
           },
           ignorePrimitives: {
-            type: 'object',
-            properties: {
-              bigint: { type: 'boolean' },
-              boolean: { type: 'boolean' },
-              number: { type: 'boolean' },
-              string: { type: 'boolean' },
-            },
+            oneOf: [
+              {
+                type: 'object',
+                properties: {
+                  bigint: { type: 'boolean' },
+                  boolean: { type: 'boolean' },
+                  number: { type: 'boolean' },
+                  string: { type: 'boolean' },
+                },
+              },
+              {
+                type: 'boolean',
+                enum: [true],
+              },
+            ],
           },
           ignoreTernaryTests: {
             type: 'boolean',
@@ -302,12 +312,16 @@ export default util.createRule<Options, MessageIds>({
         }
 
         const ignorableFlags = [
-          ignorePrimitives!.bigint && ts.TypeFlags.BigInt,
-          ignorePrimitives!.boolean && ts.TypeFlags.BooleanLiteral,
-          ignorePrimitives!.number && ts.TypeFlags.Number,
-          ignorePrimitives!.string && ts.TypeFlags.String,
+          (ignorePrimitives === true || ignorePrimitives!.bigint) &&
+            ts.TypeFlags.BigInt,
+          (ignorePrimitives === true || ignorePrimitives!.boolean) &&
+            ts.TypeFlags.BooleanLiteral,
+          (ignorePrimitives === true || ignorePrimitives!.number) &&
+            ts.TypeFlags.Number,
+          (ignorePrimitives === true || ignorePrimitives!.string) &&
+            ts.TypeFlags.String,
         ]
-          .filter((flag): flag is number => flag !== undefined)
+          .filter((flag): flag is number => typeof flag === 'number')
           .reduce((previous, flag) => previous | flag, 0);
         if (
           type.flags !== ts.TypeFlags.Null &&

packages/eslint-plugin/tests/rules/prefer-nullish-coalescing.test.ts

@@ -215,6 +215,13 @@ x || y;
       `,
       options: [{ ignorePrimitives: { [type]: true } }],
     })),
+    ...ignorablePrimitiveTypes.map<TSESLint.ValidTestCase<Options>>(type => ({
+      code: `
+declare const x: ${type} | undefined;
+x || y;
+      `,
+      options: [{ ignorePrimitives: true }],
+    })),
   ],
   invalid: [
     ...nullishTypeInvalidTest((nullish, type) => ({