ts-codemod-lib 3.5.1 → 4.0.1

package/src/functions/ast-transformers/convert-to-readonly.test.mts

@@ -14,39 +14,6 @@ import {
 } from './convert-to-readonly.mjs';
 import { transformSourceCode } from './transform-source-code.mjs';
 
-const testFn = async ({
-  source,
-  expected,
-  debug,
-  options,
-  isTsx = false,
-}: Readonly<{
-  source: string;
-  expected: string;
-  debug?: boolean;
-  options?: ReadonlyTransformerOptions;
-  isTsx?: boolean;
-}>): Promise<void> => {
-  if (debug !== true) {
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'debug').mockImplementation(() => {});
-
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-
-    // eslint-disable-next-line vitest/no-restricted-vi-methods
-    vi.spyOn(console, 'trace').mockImplementation(() => {});
-  }
-
-  const transformedCodeRaw = await formatter(
-    transformSourceCode(source, isTsx, [convertToReadonlyTransformer(options)]),
-  );
-
-  const expectedFormatted = await formatter(expected);
-
-  expect(transformedCodeRaw).toBe(expectedFormatted);
-};
-
 /**
  * Normalizes whitespace in a code string, primarily for comparing AST structure outputs.
  * - Preserves newlines immediately following line comments (`//`).
@@ -93,6 +60,39 @@ const formatter = async (code: string): Promise<string> => {
   });
 };
 
+const testFn = async ({
+  source,
+  expected,
+  debug,
+  options,
+  isTsx = false,
+}: Readonly<{
+  source: string;
+  expected: string;
+  debug?: boolean;
+  options?: ReadonlyTransformerOptions;
+  isTsx?: boolean;
+}>): Promise<void> => {
+  if (debug !== true) {
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'debug').mockImplementation(() => {});
+
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    // eslint-disable-next-line vitest/no-restricted-vi-methods
+    vi.spyOn(console, 'trace').mockImplementation(() => {});
+  }
+
+  const transformedCodeRaw = await formatter(
+    transformSourceCode(source, isTsx, [convertToReadonlyTransformer(options)]),
+  );
+
+  const expectedFormatted = await formatter(expected);
+
+  expect(transformedCodeRaw).toBe(expectedFormatted);
+};
+
 describe(convertToReadonlyTransformer, () => {
   describe('TypeReferences', () => {
     describe('Sets', () => {
@@ -788,6 +788,33 @@ describe(convertToReadonlyTransformer, () => {
           function foo(a: readonly number[], b: Promise<readonly number[]>) {}
         `,
       },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a string literal type',
+        source: dedent`
+          type T = Array<(A | '(') | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((A | '(') | (B))[];
+        `,
+      },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a comment',
+        source: dedent`
+          type T = Array<(A | /* ( */ C) | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((A | /* ( */ C) | (B))[];
+        `,
+      },
+      {
+        name: 'Array<T> whose element type has a parenthesis inside a template literal type',
+        source: dedent`
+          type T = Array<(\`(\${A}\` | C) | (B)>;
+        `,
+        expected: dedent`
+          type T = readonly ((\`(\${A}\` | C) | (B))[];
+        `,
+      },
       {
         name: 'Mutable array types in function args (generic)',
         source: dedent`
@@ -1980,6 +2007,7 @@ describe(convertToReadonlyTransformer, () => {
               }
             }
           `,
+          options: { mutablePropertyPrefixes: ['_mut_'] },
         },
         {
           name: 'Method with "draft" prefix',
@@ -1997,6 +2025,7 @@ describe(convertToReadonlyTransformer, () => {
               }
             }
           `,
+          options: { mutablePropertyPrefixes: ['draft'] },
         },
         {
           name: 'Method without mut_ prefix should be transformed',
@@ -3977,15 +4006,20 @@ describe(convertToReadonlyTransformer, () => {
           type T = { draftItems: number[]; readonly b: readonly string[] };
           type U = { mutable_items: number[]; readonly b: readonly string[] };
         `,
-        options: { ignorePrefixes: ['draft', 'mutable_'] },
+        options: {
+          mutableVariablePrefixes: ['draft', 'mutable_'],
+          mutablePropertyPrefixes: ['draft', 'mutable_'],
+        },
       },
       {
-        name: 'The "_mut_" prefix is recognized by default',
+        name: '"mut_" alone is the default: it covers "#mut_" and no longer "_mut_"',
         source: dedent`
           type T = { _mut_items: number[]; b: string[] };
+          class C { #mut_items: number[] = []; c: string[] = []; }
         `,
         expected: dedent`
-          type T = { _mut_items: number[]; readonly b: readonly string[] };
+          type T = Readonly<{ _mut_items: readonly number[]; b: readonly string[] }>;
+          class C { #mut_items: number[] = []; readonly c: readonly string[] = []; }
         `,
       },
       {
@@ -4291,7 +4325,7 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           type T = Readonly<{ mut_a: readonly number[]; b: readonly string[] }>;
         `,
-        options: { ignorePrefixes: [] },
+        options: { mutableVariablePrefixes: [], mutablePropertyPrefixes: [] },
       },
     ])('$name', testFn);
 
@@ -4849,7 +4883,7 @@ describe(convertToReadonlyTransformer, () => {
     ])('$name', testFn);
   });
 
-  describe('ignorePrefixes option', () => {
+  describe('mutableVariablePrefixes and mutablePropertyPrefixes options', () => {
     test.each([
       {
         name: 'Variable declarations',
@@ -4872,10 +4906,10 @@ describe(convertToReadonlyTransformer, () => {
       {
         name: 'Type aliases',
         source: dedent`
-          type mut_Foo = number[]
+          type MutableFoo = number[]
         `,
         expected: dedent`
-          type mut_Foo = number[]
+          type MutableFoo = number[]
         `,
       },
       {
@@ -4889,7 +4923,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly normalValue: readonly string[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Multiple ignore prefixes',
@@ -4903,7 +4940,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly normalValue: readonly boolean[];
           };
         `,
-        options: { ignorePrefixes: ['mut_', 'mutable_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_', 'mutable_'],
+          mutablePropertyPrefixes: ['mut_', 'mutable_'],
+        },
       },
       {
         name: 'Ignore prefix in nested properties',
@@ -4923,7 +4963,10 @@ describe(convertToReadonlyTransformer, () => {
             };
           }>;
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefix in interface',
@@ -4939,7 +4982,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly roles: readonly string[];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefixes for various name node types in interface',
@@ -4961,7 +5007,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly ['mu'  + 't_d']: readonly string[]; // ComputedPropertyName
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Ignore prefix with index signature',
@@ -4979,7 +5028,10 @@ describe(convertToReadonlyTransformer, () => {
             };
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Index signature in ignored property',
@@ -4997,21 +5049,27 @@ describe(convertToReadonlyTransformer, () => {
             };
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Type alias with ignored prefix',
         source: dedent`
-          type mut_Config = {
+          type MutableConfig = {
             items: string[];
           };
         `,
         expected: dedent`
-          type mut_Config = {
+          type MutableConfig = {
             items: string[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Function with ignored prefix',
@@ -5021,21 +5079,27 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           function mut_process(data: string[]): number[] { return []; }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Class with ignored prefix',
         source: dedent`
-          class mut_Store {
+          class MutableStore {
             items: string[] = [];
           }
         `,
         expected: dedent`
-          class mut_Store {
+          class MutableStore {
             items: string[] = [];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Variable declaration with ignored prefix',
@@ -5045,37 +5109,46 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const mut_items: string[] = []
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Generic type with ignored prefix',
         source: dedent`
-          type mut_List<T> = {
+          type MutableList<T> = {
             items: T[]
           }
         `,
         expected: dedent`
-          type mut_List<T> = {
+          type MutableList<T> = {
             items: T[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Union type with ignored prefix members',
         source: dedent`
-          type Result = mut_Success | Error;
-          type mut_Success = {
+          type Result = MutableSuccess | Error;
+          type MutableSuccess = {
             data: string[]
           };
         `,
         expected: dedent`
-          type Result = mut_Success | Error;
-          type mut_Success = {
+          type Result = MutableSuccess | Error;
+          type MutableSuccess = {
             data: string[];
           };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Property with ignored prefix in class',
@@ -5091,7 +5164,10 @@ describe(convertToReadonlyTransformer, () => {
             readonly items: readonly number[] = [];
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Method parameter with ignored prefix',
@@ -5105,7 +5181,10 @@ describe(convertToReadonlyTransformer, () => {
             process(mut_data: string[], data: readonly number[]) {}
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Function expression with ignored prefix',
@@ -5115,7 +5194,10 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const fn = function mut_process(data: string[]): number[] { return []; }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Array binding pattern in variable declaration (not implemented)',
@@ -5125,7 +5207,10 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const [mut_first, mut_second]: readonly [readonly string[], readonly number[]] = [[], []];
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         // The binding pattern itself is not looked at (see the TODO in
@@ -5137,7 +5222,10 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const { mut_arr, mut_obj }: { mut_arr: string[], mut_obj: number[] } = { mut_arr: [], mut_obj: [] };
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Parameter with ignored prefix in class constructor',
@@ -5151,7 +5239,10 @@ describe(convertToReadonlyTransformer, () => {
             constructor(mut_config: string[]) {}
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Parameter with ignored prefix in type literal method',
@@ -5165,7 +5256,10 @@ describe(convertToReadonlyTransformer, () => {
             process(mut_data: string[]): void;
           }>;
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Multiple parameters with ignored prefix',
@@ -5179,7 +5273,10 @@ describe(convertToReadonlyTransformer, () => {
             update(mut_id: string, mut_data: object[], data: readonly string[]): void;
           }
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
         name: 'Arrow function with ignored prefix parameters',
@@ -5189,18 +5286,228 @@ describe(convertToReadonlyTransformer, () => {
         expected: dedent`
           const handler = (mut_event: Event[], event: readonly CustomEvent[]) => {};
         `,
-        options: { ignorePrefixes: ['mut_'] },
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutablePropertyPrefixes: ['mut_'],
+        },
       },
       {
-        name: 'Arrow function parameters with "draft" prefix (default)',
+        name: '"draft" is not a default prefix',
         source: dedent`
           const handler = (draft: Event[], event: CustomEvent[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: readonly Event[], event: readonly CustomEvent[]) => {};
+          type T = Readonly<{ draft: boolean; items: readonly string[] }>;
+        `,
+      },
+      {
+        name: '"Mutable" and "mut_" are the default type prefixes',
+        source: dedent`
+          type MutableFoo = { a: string[] };
+          interface MutableBar { a: string[] }
+          class MutableBaz { a: string[] = []; }
+          const Q = class MutableQ { a: string[] = []; };
+          type mut_Qux = { a: string[] };
+          type Foo = { a: MutableFoo[] };
+        `,
+        expected: dedent`
+          type MutableFoo = { a: string[] };
+          interface MutableBar { a: string[] }
+          class MutableBaz { a: string[] = []; }
+          const Q = class MutableQ { a: string[] = []; };
+          type mut_Qux = { a: string[] };
+          type Foo = Readonly<{ a: readonly MutableFoo[] }>;
+        `,
+      },
+      {
+        name: 'Variable and property prefixes are separate',
+        source: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = Readonly<{ draft: boolean; items: readonly string[] }>;
+        `,
+        options: { mutableVariablePrefixes: ['draft'] },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: variables',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = Readonly<{ a: readonly string[] }>;
+          interface mut_I { readonly a: readonly string[] }
+          class mut_C { readonly a: readonly string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = readonly [mut_a: readonly string[], b: readonly string[]];
+          class D { readonly #mut_p: readonly string[] = []; readonly 'mut_q': readonly string[] = []; }
+          type V = Readonly<{ mut_r: readonly string[]; s: readonly string[] }>;
+          interface J { readonly mut_a: readonly string[]; f(mut_p: string[]): void }
+          type W = Readonly<{ mut_m(): readonly string[]; b: readonly string[] }>;
+          class E { mut_m(x: readonly string[]): readonly string[] { return []; } get mut_g(): readonly string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: ['mut_'],
+          mutableTypePrefixes: [],
+          mutablePropertyPrefixes: [],
+        },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: types',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: readonly string[]): void {}
+          const mut_x: readonly string[] = [];
+          type U = readonly [mut_a: readonly string[], b: readonly string[]];
+          class D { readonly #mut_p: readonly string[] = []; readonly 'mut_q': readonly string[] = []; }
+          type V = Readonly<{ mut_r: readonly string[]; s: readonly string[] }>;
+          interface J { readonly mut_a: readonly string[]; f(mut_p: readonly string[]): void }
+          type W = Readonly<{ mut_m(): readonly string[]; b: readonly string[] }>;
+          class E { mut_m(x: readonly string[]): readonly string[] { return []; } get mut_g(): readonly string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: [],
+          mutableTypePrefixes: ['mut_'],
+          mutablePropertyPrefixes: [],
+        },
+      },
+      {
+        name: 'Each kind of name is matched against its own list: properties',
+        source: dedent`
+          type mut_T = { a: string[] };
+          interface mut_I { a: string[] }
+          class mut_C { a: string[] = []; }
+          function mut_f(a: string[]): void {}
+          const mut_x: string[] = [];
+          type U = [mut_a: string[], b: string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; s: string[] };
+          interface J { mut_a: string[]; f(mut_p: string[]): void }
+          type W = { mut_m(): string[]; b: string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        expected: dedent`
+          type mut_T = Readonly<{ a: readonly string[] }>;
+          interface mut_I { readonly a: readonly string[] }
+          class mut_C { readonly a: readonly string[] = []; }
+          function mut_f(a: readonly string[]): void {}
+          const mut_x: readonly string[] = [];
+          type U = readonly [mut_a: string[], b: readonly string[]];
+          class D { #mut_p: string[] = []; 'mut_q': string[] = []; }
+          type V = { mut_r: string[]; readonly s: readonly string[] };
+          interface J { mut_a: string[]; f(mut_p: readonly string[]): void }
+          type W = { mut_m(): string[]; readonly b: readonly string[] };
+          class E { mut_m(x: string[]): string[] { return []; } get mut_g(): string[] { return []; } }
+        `,
+        options: {
+          mutableVariablePrefixes: [],
+          mutableTypePrefixes: [],
+          mutablePropertyPrefixes: ['mut_'],
+        },
+      },
+      {
+        name: 'A property prefix with a "#" covers private names only',
+        source: dedent`
+          class C { #mut_a: string[] = []; mut_b: string[] = []; }
+        `,
+        expected: dedent`
+          class C { #mut_a: string[] = []; readonly mut_b: readonly string[] = []; }
+        `,
+        options: { mutablePropertyPrefixes: ['#mut_'] },
+      },
+      {
+        name: 'A property prefix does not apply to variables',
+        source: dedent`
+          const handler = (draft: Event[]) => {};
+          type T = { draft: boolean; items: string[] };
+        `,
+        expected: dedent`
+          const handler = (draft: readonly Event[]) => {};
+          type T = { draft: boolean; readonly items: readonly string[] };
+        `,
+        options: { mutablePropertyPrefixes: ['draft'] },
+      },
+      {
+        name: 'A constructor parameter property is a property',
+        source: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], readonly draftD: string[], draftC: string[]) {}
+          }
+        `,
+        expected: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], readonly draftD: string[], draftC: readonly string[]) {}
+          }
+        `,
+        options: { mutablePropertyPrefixes: ['draft'] },
+      },
+      {
+        name: 'A constructor parameter that is not a property is a variable',
+        source: dedent`
+          class C {
+            draftA: string[] = [];
+            constructor(private draftB: string[], draftC: string[]) {}
+          }
         `,
         expected: dedent`
-          const handler = (draft: Event[], event: readonly CustomEvent[]) => {};
+          class C {
+            readonly draftA: readonly string[] = [];
+            constructor(private readonly draftB: readonly string[], draftC: string[]) {}
+          }
         `,
+        options: { mutableVariablePrefixes: ['draft'] },
       },
     ])('$name', testFn);
+
+    test('the removed ignorePrefixes option is refused', () => {
+      expect(() =>
+        convertToReadonlyTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: ['mut_'] },
+        ),
+      ).toThrow('mutableVariablePrefixes');
+    });
+
+    test('an unset ignorePrefixes option is accepted', () => {
+      expect(() =>
+        convertToReadonlyTransformer(
+          // @ts-expect-error removed in 4.0.0
+          { ignorePrefixes: undefined },
+        ),
+      ).not.toThrow();
+    });
   });
 
   describe('Disable comment handling', () => {