eslint-plugin-ts-type-forge 0.2.0 → 0.3.0

package/src/rules/rules.mts

@@ -1,6 +1,7 @@
 import { type ESLintPlugin } from '../types.mjs';
-import { preferNonEmptyArray } from './prefer-non-empty-array.mjs';
+import { preferCanonicalLengthConstrainedTuple } from './prefer-canonical-length-constrained-tuple.mjs';
 
 export const tsTypeForgeRules = {
-  'prefer-non-empty-array': preferNonEmptyArray,
+  'prefer-canonical-length-constrained-tuple':
+    preferCanonicalLengthConstrainedTuple,
 } as const satisfies ESLintPlugin['rules'];

package/src/rules/tuple-rule-utils.mts

@@ -0,0 +1,124 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import { TS_TYPE_FORGE_MODULE } from './constants.mjs';
+import {
+  buildTypeImportFix,
+  getImportedLocalName,
+  getTsTypeForgeImports,
+  hasConflictingDeclaration,
+} from './import-utils.mjs';
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
+
+/** `JSONSchema4`, reached through the public rule-module types. */
+type JsonSchema = Exclude<
+  TSESLint.RuleModule<string, readonly unknown[]>['meta']['schema'],
+  readonly unknown[]
+>;
+
+export type ImportStyle = 'global' | 'named';
+
+export const DEFAULT_IMPORT_STYLE: ImportStyle = 'global';
+
+export const IMPORT_STYLE_SCHEMA_PROPERTY: JsonSchema = {
+  type: 'string',
+  enum: ['global', 'named'],
+  description: [
+    'How the ts-type-forge type is brought into scope.',
+    "'global' (default) assumes the ambient globals of",
+    '`ts-type-forge/global` and never touches imports;',
+    "'named' makes the autofix add the corresponding",
+    `\`import { type … } from '${TS_TYPE_FORGE_MODULE}';\``,
+    'when the name is not imported yet.',
+  ].join(' '),
+};
+
+/**
+ * Resolves how a ts-type-forge type name should be written in this file, and
+ * whether the autofix has to add an import for it.
+ *
+ * Returns `undefined` when the name is already bound to something else (a local
+ * alias, or an import from another module) — rewriting to it would then silently
+ * resolve to the wrong declaration, which is exactly what happens inside
+ * ts-type-forge's own sources.
+ */
+export const resolveTypeName = (
+  program: TSESTree.Program,
+  canonicalName: string,
+  importStyle: ImportStyle,
+): Readonly<{ localName: string; needsImport: boolean }> | undefined => {
+  const importedLocalName = getImportedLocalName(
+    getTsTypeForgeImports(program),
+    canonicalName,
+  );
+
+  if (importedLocalName !== undefined) {
+    return { localName: importedLocalName, needsImport: false };
+  }
+
+  return hasConflictingDeclaration(program, canonicalName)
+    ? undefined
+    : { localName: canonicalName, needsImport: importStyle === 'named' };
+};
+
+export type TupleRewrite = Readonly<{
+  node: TSESTree.Node;
+  canonicalName: string;
+  /** Text inside the `<...>` of the replacement, e.g. `'2, string'`. */
+  typeArgs: string;
+}>;
+
+/**
+ * Emits one report per rewrite, resolving each target name and attaching every
+ * required import to the *first* report.
+ *
+ * All import fixes must live on a single report: `insertTextBefore(program, …)`
+ * produces overlapping ranges, and ESLint merges each report's fixes into one
+ * span — so spreading them across reports makes the fixes conflict and only one
+ * survives per pass.
+ */
+export const reportTupleRewrites = <MessageIds extends string>(
+  context: TSESLint.RuleContext<MessageIds, readonly unknown[]>,
+  rewrites: readonly TupleRewrite[],
+  messageId: MessageIds,
+  importStyle: ImportStyle,
+): void => {
+  const sourceCode = context.sourceCode;
+
+  const program = sourceCode.ast;
+
+  const resolved = rewrites.flatMap((rewrite) => {
+    const target = resolveTypeName(program, rewrite.canonicalName, importStyle);
+
+    // The name is already bound to something else in this file, so the rewrite
+    // would resolve to the wrong declaration.
+    return target === undefined ? [] : [{ rewrite, target }];
+  });
+
+  const importNames = Array.from(
+    new Set(
+      resolved
+        .filter(({ target }) => target.needsImport)
+        .map(({ rewrite }) => rewrite.canonicalName),
+    ),
+  );
+
+  for (const [index, { rewrite, target }] of resolved.entries()) {
+    const replacement = `${target.localName}<${rewrite.typeArgs}>`;
+
+    context.report({
+      node: rewrite.node,
+      messageId,
+      data: { original: sourceCode.getText(rewrite.node), replacement },
+      fix: (fixer) => [
+        ...(index === 0
+          ? importNames.flatMap((name) =>
+              buildTypeImportFix(fixer, program, name),
+            )
+          : []),
+        fixer.replaceText(rewrite.node, replacement),
+      ],
+    });
+  }
+};
+
+/* eslint-enable @typescript-eslint/prefer-readonly-parameter-types */

package/dist/rules/prefer-non-empty-array.d.mts

@@ -1,11 +0,0 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-type ImportStyle = 'global' | 'named';
-type Options = readonly [
-    Readonly<{
-        importStyle?: ImportStyle;
-    }>?
-];
-type MessageIds = 'useNonEmptyArray';
-export declare const preferNonEmptyArray: TSESLint.RuleModule<MessageIds, Options>;
-export {};
-//# sourceMappingURL=prefer-non-empty-array.d.mts.map

package/dist/rules/prefer-non-empty-array.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefer-non-empty-array.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-non-empty-array.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAiB,MAAM,0BAA0B,CAAC;AAaxE,KAAK,WAAW,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,WAAW,CAAC,EAAE,WAAW,CAAC;KAC3B,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,kBAAkB,CAAC;AAIrC,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAuG/D,CAAC"}

package/dist/rules/prefer-non-empty-array.mjs

@@ -1,81 +0,0 @@
-import { getNonEmptyArrayElementText } from './ast-utils.mjs';
-import { NON_EMPTY_ARRAY_TYPE_NAME, TS_TYPE_FORGE_MODULE } from './constants.mjs';
-import { getImportedLocalName, getTsTypeForgeImports, hasConflictingDeclaration, buildTypeImportFix } from './import-utils.mjs';
-
-const DEFAULT_IMPORT_STYLE = "global";
-const preferNonEmptyArray = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Replace the `readonly [V, ...V[]]` tuple spelling with `NonEmptyArray<V>` from ts-type-forge."
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          importStyle: {
-            type: "string",
-            enum: ["global", "named"],
-            description: [
-              "How `NonEmptyArray` is brought into scope.",
-              "'global' (default) assumes the ambient globals of",
-              "`ts-type-forge/global` and never touches imports;",
-              "'named' makes the autofix add",
-              `\`import { type ${NON_EMPTY_ARRAY_TYPE_NAME} } from '${TS_TYPE_FORGE_MODULE}';\``,
-              "when the name is not imported yet."
-            ].join(" ")
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      useNonEmptyArray: "Replace `{{original}}` with `{{replacement}}` from ts-type-forge."
-    }
-  },
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const program = sourceCode.ast;
-    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;
-    const importedLocalName = getImportedLocalName(
-      getTsTypeForgeImports(program),
-      NON_EMPTY_ARRAY_TYPE_NAME
-    );
-    const mut_nodesToFix = [];
-    return {
-      TSTypeOperator: (node) => {
-        const elementText = getNonEmptyArrayElementText(node, sourceCode);
-        if (elementText === void 0) return;
-        mut_nodesToFix.push({ node, elementText });
-      },
-      "Program:exit": () => {
-        if (mut_nodesToFix.length === 0) return;
-        if (importedLocalName === void 0 && hasConflictingDeclaration(program, NON_EMPTY_ARRAY_TYPE_NAME)) {
-          return;
-        }
-        const localName = importedLocalName ?? NON_EMPTY_ARRAY_TYPE_NAME;
-        const needsImport = importStyle === "named" && importedLocalName === void 0;
-        for (const [index, { node, elementText }] of mut_nodesToFix.entries()) {
-          const replacement = `${localName}<${elementText}>`;
-          context.report({
-            node,
-            messageId: "useNonEmptyArray",
-            data: {
-              original: sourceCode.getText(node),
-              replacement
-            },
-            fix: (fixer) => [
-              ...index === 0 && needsImport ? buildTypeImportFix(fixer, program, NON_EMPTY_ARRAY_TYPE_NAME) : [],
-              fixer.replaceText(node, replacement)
-            ]
-          });
-        }
-      }
-    };
-  },
-  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }]
-};
-
-export { preferNonEmptyArray };
-//# sourceMappingURL=prefer-non-empty-array.mjs.map

package/dist/rules/prefer-non-empty-array.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"prefer-non-empty-array.mjs","sources":["../../src/rules/prefer-non-empty-array.mts"],"sourcesContent":["import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';\nimport { getNonEmptyArrayElementText } from './ast-utils.mjs';\nimport {\n  NON_EMPTY_ARRAY_TYPE_NAME,\n  TS_TYPE_FORGE_MODULE,\n} from './constants.mjs';\nimport {\n  buildTypeImportFix,\n  getImportedLocalName,\n  getTsTypeForgeImports,\n  hasConflictingDeclaration,\n} from './import-utils.mjs';\n\ntype ImportStyle = 'global' | 'named';\n\ntype Options = readonly [\n  Readonly<{\n    importStyle?: ImportStyle;\n  }>?,\n];\n\ntype MessageIds = 'useNonEmptyArray';\n\nconst DEFAULT_IMPORT_STYLE: ImportStyle = 'global';\n\nexport const preferNonEmptyArray: TSESLint.RuleModule<MessageIds, Options> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Replace the `readonly [V, ...V[]]` tuple spelling with `NonEmptyArray<V>` from ts-type-forge.',\n    },\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          importStyle: {\n            type: 'string',\n            enum: ['global', 'named'],\n            description: [\n              'How `NonEmptyArray` is brought into scope.',\n              \"'global' (default) assumes the ambient globals of\",\n              '`ts-type-forge/global` and never touches imports;',\n              \"'named' makes the autofix add\",\n              `\\`import { type ${NON_EMPTY_ARRAY_TYPE_NAME} } from '${TS_TYPE_FORGE_MODULE}';\\``,\n              'when the name is not imported yet.',\n            ].join(' '),\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n    messages: {\n      useNonEmptyArray:\n        'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',\n    },\n  },\n\n  create: (context) => {\n    const sourceCode = context.sourceCode;\n\n    const program = sourceCode.ast;\n\n    // `context.options` is what the user actually configured; `defaultOptions`\n    // is only merged in by `RuleCreator`, which plain rule objects do not use.\n    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;\n\n    const importedLocalName = getImportedLocalName(\n      getTsTypeForgeImports(program),\n      NON_EMPTY_ARRAY_TYPE_NAME,\n    );\n\n    const mut_nodesToFix: {\n      node: TSESTree.TSTypeOperator;\n      elementText: string;\n    }[] = [];\n\n    return {\n      TSTypeOperator: (node) => {\n        const elementText = getNonEmptyArrayElementText(node, sourceCode);\n\n        if (elementText === undefined) return;\n\n        mut_nodesToFix.push({ node, elementText });\n      },\n      'Program:exit': () => {\n        if (mut_nodesToFix.length === 0) return;\n\n        // Rewriting to `NonEmptyArray<...>` is only sound when that name is\n        // free (or already bound to the ts-type-forge export). Otherwise the\n        // rewritten type would resolve to the wrong declaration — most\n        // notably inside ts-type-forge's own sources, which define\n        // `NonEmptyArray`.\n        if (\n          importedLocalName === undefined &&\n          hasConflictingDeclaration(program, NON_EMPTY_ARRAY_TYPE_NAME)\n        ) {\n          return;\n        }\n\n        const localName = importedLocalName ?? NON_EMPTY_ARRAY_TYPE_NAME;\n\n        const needsImport =\n          importStyle === 'named' && importedLocalName === undefined;\n\n        for (const [index, { node, elementText }] of mut_nodesToFix.entries()) {\n          const replacement = `${localName}<${elementText}>`;\n\n          context.report({\n            node,\n            messageId: 'useNonEmptyArray',\n            data: {\n              original: sourceCode.getText(node),\n              replacement,\n            },\n            fix: (fixer) => [\n              ...(index === 0 && needsImport\n                ? buildTypeImportFix(fixer, program, NON_EMPTY_ARRAY_TYPE_NAME)\n                : []),\n              fixer.replaceText(node, replacement),\n            ],\n          });\n        }\n      },\n    };\n  },\n  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],\n} as const;\n"],"names":[],"mappings":"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"}

package/src/rules/prefer-non-empty-array.mts

@@ -1,129 +0,0 @@
-import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
-import { getNonEmptyArrayElementText } from './ast-utils.mjs';
-import {
-  NON_EMPTY_ARRAY_TYPE_NAME,
-  TS_TYPE_FORGE_MODULE,
-} from './constants.mjs';
-import {
-  buildTypeImportFix,
-  getImportedLocalName,
-  getTsTypeForgeImports,
-  hasConflictingDeclaration,
-} from './import-utils.mjs';
-
-type ImportStyle = 'global' | 'named';
-
-type Options = readonly [
-  Readonly<{
-    importStyle?: ImportStyle;
-  }>?,
-];
-
-type MessageIds = 'useNonEmptyArray';
-
-const DEFAULT_IMPORT_STYLE: ImportStyle = 'global';
-
-export const preferNonEmptyArray: TSESLint.RuleModule<MessageIds, Options> = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Replace the `readonly [V, ...V[]]` tuple spelling with `NonEmptyArray<V>` from ts-type-forge.',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          importStyle: {
-            type: 'string',
-            enum: ['global', 'named'],
-            description: [
-              'How `NonEmptyArray` is brought into scope.',
-              "'global' (default) assumes the ambient globals of",
-              '`ts-type-forge/global` and never touches imports;',
-              "'named' makes the autofix add",
-              `\`import { type ${NON_EMPTY_ARRAY_TYPE_NAME} } from '${TS_TYPE_FORGE_MODULE}';\``,
-              'when the name is not imported yet.',
-            ].join(' '),
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      useNonEmptyArray:
-        'Replace `{{original}}` with `{{replacement}}` from ts-type-forge.',
-    },
-  },
-
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-
-    const program = sourceCode.ast;
-
-    // `context.options` is what the user actually configured; `defaultOptions`
-    // is only merged in by `RuleCreator`, which plain rule objects do not use.
-    const importStyle = context.options[0]?.importStyle ?? DEFAULT_IMPORT_STYLE;
-
-    const importedLocalName = getImportedLocalName(
-      getTsTypeForgeImports(program),
-      NON_EMPTY_ARRAY_TYPE_NAME,
-    );
-
-    const mut_nodesToFix: {
-      node: TSESTree.TSTypeOperator;
-      elementText: string;
-    }[] = [];
-
-    return {
-      TSTypeOperator: (node) => {
-        const elementText = getNonEmptyArrayElementText(node, sourceCode);
-
-        if (elementText === undefined) return;
-
-        mut_nodesToFix.push({ node, elementText });
-      },
-      'Program:exit': () => {
-        if (mut_nodesToFix.length === 0) return;
-
-        // Rewriting to `NonEmptyArray<...>` is only sound when that name is
-        // free (or already bound to the ts-type-forge export). Otherwise the
-        // rewritten type would resolve to the wrong declaration — most
-        // notably inside ts-type-forge's own sources, which define
-        // `NonEmptyArray`.
-        if (
-          importedLocalName === undefined &&
-          hasConflictingDeclaration(program, NON_EMPTY_ARRAY_TYPE_NAME)
-        ) {
-          return;
-        }
-
-        const localName = importedLocalName ?? NON_EMPTY_ARRAY_TYPE_NAME;
-
-        const needsImport =
-          importStyle === 'named' && importedLocalName === undefined;
-
-        for (const [index, { node, elementText }] of mut_nodesToFix.entries()) {
-          const replacement = `${localName}<${elementText}>`;
-
-          context.report({
-            node,
-            messageId: 'useNonEmptyArray',
-            data: {
-              original: sourceCode.getText(node),
-              replacement,
-            },
-            fix: (fixer) => [
-              ...(index === 0 && needsImport
-                ? buildTypeImportFix(fixer, program, NON_EMPTY_ARRAY_TYPE_NAME)
-                : []),
-              fixer.replaceText(node, replacement),
-            ],
-          });
-        }
-      },
-    };
-  },
-  defaultOptions: [{ importStyle: DEFAULT_IMPORT_STYLE }],
-} as const;

package/src/rules/prefer-non-empty-array.test.mts

@@ -1,192 +0,0 @@
-import parser from '@typescript-eslint/parser';
-import { RuleTester } from '@typescript-eslint/rule-tester';
-import dedent from 'dedent';
-import { preferNonEmptyArray } from './prefer-non-empty-array.mjs';
-
-const tester = new RuleTester({
-  languageOptions: {
-    parser,
-    parserOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
-  },
-});
-
-describe('prefer-non-empty-array', () => {
-  tester.run('prefer-non-empty-array', preferNonEmptyArray, {
-    valid: [
-      {
-        name: 'ignores mutable tuples (that spelling is MutableNonEmptyArray)',
-        code: 'type T = [number, ...number[]];',
-      },
-      {
-        name: 'ignores plain readonly arrays',
-        code: 'type T = readonly number[];',
-      },
-      {
-        name: 'ignores tuples whose rest element type differs from the head',
-        code: 'type T = readonly [string, ...number[]];',
-      },
-      {
-        name: 'ignores min-length-2 tuples',
-        code: 'type T = readonly [number, number, ...number[]];',
-      },
-      {
-        name: 'ignores fixed-length tuples',
-        code: 'type T = readonly [number];',
-      },
-      {
-        name: 'ignores leading-rest tuples',
-        code: 'type T = readonly [...number[], number];',
-      },
-      {
-        name: 'ignores optional heads',
-        code: 'type T = readonly [number?, ...number[]];',
-      },
-      {
-        name: 'ignores labelled tuple members (the labels would be lost)',
-        code: 'type T = readonly [head: number, ...tail: number[]];',
-      },
-      {
-        name: 'ignores readonly operators applied to non-tuples',
-        code: 'type T = readonly string[];',
-      },
-      {
-        name: 'stays silent when NonEmptyArray is declared locally',
-        code: dedent`
-          type NonEmptyArray<A> = readonly [A, ...A[]];
-          type T = readonly [number, ...number[]];
-        `,
-      },
-      {
-        name: 'stays silent when NonEmptyArray is exported locally',
-        code: 'export type NonEmptyArray<A> = readonly [A, ...A[]];',
-      },
-      {
-        name: 'stays silent when NonEmptyArray is imported from elsewhere',
-        code: dedent`
-          import { type NonEmptyArray } from './my-types.mjs';
-
-          type T = readonly [number, ...number[]];
-          type U = NonEmptyArray<string>;
-        `,
-      },
-    ],
-    invalid: [
-      {
-        name: 'replaces readonly [V, ...V[]] with NonEmptyArray<V>',
-        code: 'type T = readonly [number, ...number[]];',
-        output: 'type T = NonEmptyArray<number>;',
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'replaces readonly [V, ...(readonly V[])] with NonEmptyArray<V>',
-        code: 'type T = readonly [number, ...(readonly number[])];',
-        output: 'type T = NonEmptyArray<number>;',
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'keeps a composite element type intact',
-        code: 'type T = readonly [string | number, ...(string | number)[]];',
-        output: 'type T = NonEmptyArray<string | number>;',
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'handles generic element types',
-        code: 'type T<A> = readonly [A, ...A[]];',
-        output: 'type T<A> = NonEmptyArray<A>;',
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'rewrites occurrences nested inside another tuple',
-        code: 'type T = readonly [readonly [number, ...number[]], ...string[]];',
-        output: 'type T = readonly [NonEmptyArray<number>, ...string[]];',
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'rewrites parameter and return type positions',
-        code: dedent`
-          declare const f: (xs: readonly [number, ...number[]]) => readonly [string, ...string[]];
-        `,
-        output: dedent`
-          declare const f: (xs: NonEmptyArray<number>) => NonEmptyArray<string>;
-        `,
-        errors: [
-          { messageId: 'useNonEmptyArray' },
-          { messageId: 'useNonEmptyArray' },
-        ],
-      },
-      {
-        name: 'reuses the local alias when NonEmptyArray is imported aliased',
-        code: dedent`
-          import { type NonEmptyArray as NEA } from 'ts-type-forge';
-
-          type T = readonly [number, ...number[]];
-        `,
-        output: dedent`
-          import { type NonEmptyArray as NEA } from 'ts-type-forge';
-
-          type T = NEA<number>;
-        `,
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'does not add an import with the default (global) import style',
-        code: dedent`
-          import { type StrictOmit } from 'ts-type-forge';
-
-          type T = readonly [number, ...number[]];
-        `,
-        output: dedent`
-          import { type StrictOmit } from 'ts-type-forge';
-
-          type T = NonEmptyArray<number>;
-        `,
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'adds the named import when importStyle is "named"',
-        options: [{ importStyle: 'named' }],
-        code: 'type T = readonly [number, ...number[]];',
-        output: dedent`
-          import { type NonEmptyArray } from 'ts-type-forge';
-          type T = NonEmptyArray<number>;
-        `,
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-      {
-        name: 'adds the named import only once per file',
-        options: [{ importStyle: 'named' }],
-        code: dedent`
-          type T = readonly [number, ...number[]];
-          type U = readonly [string, ...string[]];
-        `,
-        output: dedent`
-          import { type NonEmptyArray } from 'ts-type-forge';
-          type T = NonEmptyArray<number>;
-          type U = NonEmptyArray<string>;
-        `,
-        errors: [
-          { messageId: 'useNonEmptyArray' },
-          { messageId: 'useNonEmptyArray' },
-        ],
-      },
-      {
-        name: 'keeps an existing NonEmptyArray import untouched',
-        options: [{ importStyle: 'named' }],
-        code: dedent`
-          import { type NonEmptyArray } from 'ts-type-forge';
-
-          type T = readonly [number, ...number[]];
-        `,
-        output: dedent`
-          import { type NonEmptyArray } from 'ts-type-forge';
-
-          type T = NonEmptyArray<number>;
-        `,
-        errors: [{ messageId: 'useNonEmptyArray' }],
-      },
-    ],
-  });
-});