feat(eslint-plugin): [no-type-alias] allowTemplateLiterals

packages/eslint-plugin/docs/rules/no-type-alias.md

@@ -92,6 +92,7 @@ or more of the following you may pass an object with the options set as follows:
 - `allowMappedTypes` set to `"always"` will allow you to use type aliases as mapping tools (Defaults to `"never"`)
 - `allowTupleTypes` set to `"always"` will allow you to use type aliases with tuples (Defaults to `"never"`)
 - `allowGenerics` set to `"always"` will allow you to use type aliases with generics (Defaults to `"never"`)
+- `allowTemplateLiterals` set to `"always"` will allow you to use type aliases with template literals (Defaults to `"never"`)
 
 ### `allowAliases`
 
@@ -600,6 +601,61 @@ type Foo = Partial<Bar>;
 type Foo = Omit<Bar, 'a' | 'b'>;
 ```
 
+### `allowTemplateLiterals`
+
+This applies to template literals.
+
+The setting accepts the following values:
+
+- `"always"` or `"never"` to active or deactivate the feature.
+- `"in-unions"`
+- `"in-intersections"`
+- `"in-unions-and-intersections"`
+
+Examples of **correct** code for the `{ "allowTemplateLiterals": "always" }` options:
+
+```ts
+type Foo = `foo-${number}`;
+```
+
+Examples of **incorrect** code for the `{ "allowTemplateLiterals": "in-unions" }` option:
+
+```ts
+type Foo = `foo-${number}`;
+```
+
+Examples of **correct** code for the `{ "allowTemplateLiterals": "in-unions" }` option:
+
+```ts
+type Foo = `a-${number}` | `b-${number}`;
+```
+
+Examples of **incorrect** code for the `{ "allowTemplateLiterals": "in-intersections" }` option:
+
+```ts
+type Foo = `a-${number}` | `b-${number}`;
+```
+
+Examples of **correct** code for the `{ "allowTemplateLiterals": "in-intersections" }` option:
+
+```ts
+type Foo = `a-${number}` & `b-${number}`;
+```
+
+Examples of **incorrect** code for the `{ "allowTemplateLiterals": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo = `foo-${number}`;
+```
+
+Examples of **correct** code for the `{ "allowTemplateLiterals": "in-unions-and-intersections" }` option:
+
+```ts
+type Foo = `a-${number}` & `b-${number}`;
+
+type Foo = `a-${number}` | `b-${number}`;
+```
+
 ## When Not To Use It
 
 When you can't express some shape with an interface or you need to use a union, tuple type,

packages/eslint-plugin/src/rules/no-type-alias.ts

@@ -29,6 +29,7 @@ type Options = [
     allowMappedTypes?: Values;
     allowTupleTypes?: Values;
     allowGenerics?: 'always' | 'never';
+    allowTemplateLiterals?: Values;
   },
 ];
 type MessageIds = 'noTypeAlias' | 'noCompositionAlias';
@@ -83,6 +84,9 @@ export default util.createRule<Options, MessageIds>({
           allowGenerics: {
             enum: ['always', 'never'],
           },
+          allowTemplateLiterals: {
+            enum: enumValues,
+          },
         },
         additionalProperties: false,
       },
@@ -98,6 +102,7 @@ export default util.createRule<Options, MessageIds>({
       allowMappedTypes: 'never',
       allowTupleTypes: 'never',
       allowGenerics: 'never',
+      allowTemplateLiterals: 'never',
     },
   ],
   create(
@@ -112,6 +117,7 @@ export default util.createRule<Options, MessageIds>({
         allowMappedTypes,
         allowTupleTypes,
         allowGenerics,
+        allowTemplateLiterals,
       },
     ],
   ) {
@@ -271,6 +277,13 @@ export default util.createRule<Options, MessageIds>({
       } else if (type.node.type === AST_NODE_TYPES.TSMappedType) {
         // mapped type
         checkAndReport(allowMappedTypes!, isTopLevel, type, 'Mapped types');
+      } else if (type.node.type === AST_NODE_TYPES.TSTemplateLiteralType) {
+        checkAndReport(
+          allowTemplateLiterals!,
+          isTopLevel,
+          type,
+          'Template literals',
+        );
       } else if (isValidTupleType(type)) {
         // tuple types
         checkAndReport(allowTupleTypes!, isTopLevel, type, 'Tuple Types');