ts-codemod-lib 3.5.1 → 4.0.1

package/dist/functions/ast-transformers/convert-to-readonly.mjs

@@ -1,5 +1,6 @@
-import { Arr, ISet, isString, mapNullable, match, pipe, } from 'ts-data-forge';
+import { Arr, ISet, isRecord, isString, mapNullable, match, pipe, } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
+import { DEFAULT_MUTABLE_PREFIXES, DEFAULT_MUTABLE_TYPE_PREFIXES, } from '../constants/index.mjs';
 import { hasCallOrConstructSignature, hasDisableNextLineComment, isAtomicTypeNode, isConditionalTypeDistributionGuard, isReadonlyArrayTypeNode, isReadonlyTupleOrArrayTypeNode, isReadonlyTupleTypeNode, isReadonlyTypeReferenceNode, removeParentheses, shouldAvoidParenthesesForReadonly, unwrapReadonlyTypeArgText, wrapWithParentheses, } from '../functions/index.mjs';
 import { replaceNodeWithDebugPrint, replaceNodeWithText, } from '../utils/index.mjs';
 import { groupUnionIntersectionTypes, invalidDeepReadonlyTypeName, isMergeableReadonlyTypeReferenceNode, nextReadonlyContext, } from './readonly-transformer-helpers/index.mjs';
@@ -11,17 +12,20 @@ export const convertToReadonlyTransformer = (options) => {
     }
     const DeepReadonlyTypeName = options?.DeepReadonly?.typeName ?? 'DeepReadonly';
 
-
-
-
-    const ignorePrefixes = ISet.create(options?.ignorePrefixes ?? ['mut_', '#mut_', '_mut_', 'draft']);
+    const untypedOptions = options;
+    if (isRecord(untypedOptions) &&
+        untypedOptions['ignorePrefixes'] !== undefined) {
+        throw new Error(`The "ignorePrefixes" option of ${TRANSFORMER_NAME} was replaced by "mutableVariablePrefixes", "mutableTypePrefixes" and "mutablePropertyPrefixes".`);
+    }
     const optionsInternal = {
         DeepReadonly: {
             typeName: DeepReadonlyTypeName,
             applyLevel: 'keep',
         },
         ignoreEmptyObjectTypes: options?.ignoreEmptyObjectTypes ?? true,
-        ignoredPrefixes: ignorePrefixes,
+        mutableVariablePrefixes: ISet.create(options?.mutableVariablePrefixes ?? DEFAULT_MUTABLE_PREFIXES),
+        mutableTypePrefixes: ISet.create(options?.mutableTypePrefixes ?? DEFAULT_MUTABLE_TYPE_PREFIXES),
+        mutablePropertyPrefixes: ISet.create(options?.mutablePropertyPrefixes ?? DEFAULT_MUTABLE_PREFIXES),
         recordStyle: options?.recordStyle ?? 'ReadonlyRecord',
         debugPrint: options?.debug === true ? console.debug : () => { },
         replaceNode: options?.debug === true
@@ -41,6 +45,18 @@ const initialReadonlyContext = {
     type: 'none',
     indexedAccessDepth: 0,
 };
+
+const hasMutableTypeName = (name, options) => name !== undefined &&
+    options.mutableTypePrefixes.some((p) => name.startsWith(p));
+
+
+
+
+const mutablePrefixesOfParameter = (
+
+param, options) => param.isParameterProperty()
+    ? options.mutablePropertyPrefixes
+    : options.mutableVariablePrefixes;
 const transformNode = (node, readonlyContext, options) => {
     if (tsm.Node.isTypeNode(node) ||
         node.isKind(tsm.SyntaxKind.InterfaceDeclaration) ||
@@ -58,10 +74,10 @@ const transformNode = (node, readonlyContext, options) => {
 
     if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
         const nodeName = node.getName();
-        if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+        if (options.mutableVariablePrefixes.some((p) => nodeName.startsWith(p))) {
 
 
-            options.debugPrint('skipped variable declaration by ignorePrefixes');
+            options.debugPrint('skipped variable declaration by mutableVariablePrefixes');
             return;
         }
 
@@ -77,12 +93,12 @@ const transformNode = (node, readonlyContext, options) => {
 
     if ((node.isKind(tsm.SyntaxKind.FunctionDeclaration) ||
         node.isKind(tsm.SyntaxKind.FunctionExpression)) &&
-        options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
+        options.mutableVariablePrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
         return;
     }
     if (node.isKind(tsm.SyntaxKind.Parameter)) {
         const nodeName = node.getName();
-        if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+        if (mutablePrefixesOfParameter(node, options).some((p) => nodeName.startsWith(p))) {
 
 
             return;
@@ -97,7 +113,7 @@ const transformNode = (node, readonlyContext, options) => {
 
 
     if (node.isKind(tsm.SyntaxKind.TypeAliasDeclaration) &&
-        options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
+        hasMutableTypeName(node.getName(), options)) {
         return;
     }
     if (node.isKind(tsm.SyntaxKind.TypeReference)) {
@@ -147,16 +163,21 @@ const transformNode = (node, readonlyContext, options) => {
     if (node.isKind(tsm.SyntaxKind.InterfaceDeclaration)) {
 
 
-        if (options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
+        if (hasMutableTypeName(node.getName(), options)) {
             return;
         }
         transformInterfaceDeclarationNode(node, options);
         return;
     }
+
+    if (node.isKind(tsm.SyntaxKind.ClassExpression) &&
+        hasMutableTypeName(node.getName(), options)) {
+        return;
+    }
     if (node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
 
 
-        if (options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
+        if (hasMutableTypeName(node.getName(), options)) {
             return;
         }
         transformClassDeclarationNode(node, options);
@@ -189,6 +210,137 @@ const transformNode = (node, readonlyContext, options) => {
 
 
 
+const readonlyRecordText = (keyText, valueText, options) => options.recordStyle === 'ReadonlyRecord'
+    ? `ReadonlyRecord<${keyText}, ${valueText}>`
+    : `Readonly<Record<${keyText}, ${valueText}>>`;
+
+
+
+
+
+const commentsBetween = (
+
+sourceFile, from, to) => {
+    if (to <= from) {
+        return '';
+    }
+    const scanner = tsm.ts.createScanner(tsm.ts.ScriptTarget.Latest, false, tsm.ts.LanguageVariant.Standard, sourceFile.getFullText(), undefined, from, to - from);
+    const mut_comments = [];
+    while (scanner.scan() !== tsm.ts.SyntaxKind.EndOfFileToken) {
+        const token = scanner.getToken();
+
+        const separator = token === tsm.ts.SyntaxKind.SingleLineCommentTrivia
+            ? '\n'
+            : token === tsm.ts.SyntaxKind.MultiLineCommentTrivia
+                ? ' '
+                : undefined;
+        if (separator !== undefined) {
+            mut_comments.push(`${scanner.getTokenText()}${separator}`);
+        }
+    }
+    return mut_comments.join('');
+};
+
+const getDeepReadonlyTypeArg = (
+
+node, deepReadonlyTypeName) => {
+    if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
+        return undefined;
+    }
+    const typeName = node.getTypeName();
+    const typeArguments = node.getTypeArguments();
+    return typeName.isKind(tsm.SyntaxKind.Identifier) &&
+        typeName.getText() === deepReadonlyTypeName &&
+        Arr.isFixedLengthArray(1, typeArguments)
+        ? typeArguments[0]
+        : undefined;
+};
+const checkIfPropertyNameShouldBeIgnored = (
+
+nameNode, options) => {
+
+
+    return (
+
+    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
+        pipe(nameNode.getText()).map((nm) => options.mutablePropertyPrefixes.some((p) => nm.startsWith(p))).value) ||
+
+        (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
+            pipe(nameNode.getLiteralValue()).map((nm) => options.mutablePropertyPrefixes.some((p) => nm.startsWith(p))).value) ||
+
+        (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
+            pipe(nameNode.getText()).map((nm) => options.mutablePropertyPrefixes.some((p) => nm.startsWith(p) || nm.startsWith(`#${p}`))).value) ||
+
+        (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
+            pipe(nameNode.getExpression()).map((exp) => {
+                if (exp.isKind(tsm.SyntaxKind.StringLiteral) ||
+                    exp.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral)) {
+                    const nm = exp.getLiteralValue();
+                    return options.mutablePropertyPrefixes.some((p) => nm.startsWith(p));
+                }
+                return false;
+            }).value));
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const isLeftUnwrapped = (
+
+node, options) => {
+    const members = node.getMembers();
+    const isMethodOrAccessor = (
+
+    mb) => mb.isKind(tsm.SyntaxKind.MethodSignature) ||
+        mb.isKind(tsm.SyntaxKind.GetAccessor) ||
+        mb.isKind(tsm.SyntaxKind.SetAccessor);
+    const isIgnoredMember = (
+
+    mb) => (mb.isKind(tsm.SyntaxKind.PropertySignature) || isMethodOrAccessor(mb)) &&
+        checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options);
+    const needsReadonlyWrapper = (
+
+    mb) => !isIgnoredMember(mb) &&
+        (isMethodOrAccessor(mb) ||
+            ((mb.isKind(tsm.SyntaxKind.PropertySignature) ||
+                mb.isKind(tsm.SyntaxKind.IndexSignature)) &&
+                !mb.hasModifier(tsm.SyntaxKind.ReadonlyKeyword) &&
+                hasDisableNextLineComment(mb)));
+    return members.some(isIgnoredMember) && !members.some(needsReadonlyWrapper);
+};
+
+const hasDisableNextLineCommentAround = (node) => {
+    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+        return true;
+    }
+    const parent = node.getParent();
+    return (parent?.isKind(tsm.SyntaxKind.ParenthesizedType) === true &&
+        hasDisableNextLineCommentAround(parent));
+};
+
+
+
+
+
+
+
+const takesOffReadonly = (
+
+node, options) => isLeftUnwrapped(node, options) &&
+    !hasCallOrConstructSignature(node) &&
+    !hasDisableNextLineCommentAround(node);
+
 
 
 
@@ -511,10 +663,6 @@ node, readonlyContext, options) => {
     }
 };
 
-const readonlyRecordText = (keyText, valueText, options) => options.recordStyle === 'ReadonlyRecord'
-    ? `ReadonlyRecord<${keyText}, ${valueText}>`
-    : `Readonly<Record<${keyText}, ${valueText}>>`;
-
 const transformArrayTypeNode = (
 
 node, readonlyContext, options) => {
@@ -555,7 +703,7 @@ node, readonlyContext, options) => {
         });
         for (const el of node.getElements()) {
             if (el.isKind(tsm.SyntaxKind.NamedTupleMember)) {
-                if (options.ignoredPrefixes.every((p) => !el.getName().startsWith(p))) {
+                if (options.mutablePropertyPrefixes.every((p) => !el.getName().startsWith(p))) {
                     transformNode(el.getTypeNode(), nextReadonlyContextValue, options);
                 }
             }
@@ -781,7 +929,7 @@ param, options) => {
         return;
     }
     const name = param.getName();
-    if (options.ignoredPrefixes.some((p) => name.startsWith(p))) {
+    if (mutablePrefixesOfParameter(param, options).some((p) => name.startsWith(p))) {
         return;
     }
 
@@ -819,104 +967,6 @@ const transformUnionTypeNode = (
 node, readonlyContext, options) => {
     transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '|');
 };
-const transformUnionOrIntersectionTypeNodeImpl = (
-
-node, readonlyContext, options, operator) => {
-    const nextReadonlyContextValue = nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'keep',
-    });
-
-    for (const n of node.getTypeNodes() ) {
-        transformNode(n, nextReadonlyContextValue, options);
-    }
-    const newTypes = node.getTypeNodes();
-    const withLeadingComments = (
-
-    member, memberText) => `${leadingCommentsOfMember(node, member)}${memberText}`;
-
-
-    const wrapsTypeLiterals = nextReadonlyContextValue.type !== 'DeepReadonly' &&
-        nextReadonlyContextValue.indexedAccessDepth === 0;
-
-
-    const underReadonly = readonlyContext.type === 'Readonly' &&
-        readonlyContext.indexedAccessDepth === 0 &&
-        isTypeArgumentOfReadonly(node);
-    const { primitives, arraysAndTuples, typeLiterals, others } = groupUnionIntersectionTypes(newTypes, {
-        operator,
-        underReadonly,
-        deepReadonlyTypeName: options.DeepReadonly.typeName,
-        keptUnwrapped: (t) => wrapsTypeLiterals && takesOffReadonly(t, options),
-    });
-    options.debugPrint({ primitives, arraysAndTuples, typeLiterals, others });
-
-    const isEmptyTypeLiteral = (
-
-    n) => n.isKind(tsm.SyntaxKind.TypeLiteral) && Arr.isEmpty(n.getMembers());
-    const nonEmptyTypeLiterals = typeLiterals === undefined
-        ? undefined
-        : options.ignoreEmptyObjectTypes
-            ? typeLiterals.nodes.filter((n) => !isEmptyTypeLiteral(n))
-            : typeLiterals.nodes;
-    const emptyTypeLiterals = typeLiterals === undefined || !options.ignoreEmptyObjectTypes
-        ? undefined
-        : typeLiterals.nodes.filter(isEmptyTypeLiteral);
-    const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
-        ? []
-        : [
-            unionToString({
-                types: nonEmptyTypeLiterals.map((n) => withLeadingComments(n, isMergeableReadonlyTypeReferenceNode(n, operator)
-                    ?
-
-                        readonlyTypeArgTextSplicedInto(n, operator)
-                    : n.isKind(tsm.SyntaxKind.TypeLiteral)
-                        ? n.getText()
-                        :
-                            wrapWithParentheses(n.getText()))),
-                op: operator,
-                wrapWithReadonly: wrapsTypeLiterals,
-            }),
-        ];
-
-    const sorted = [
-        mapNullable(primitives, (a) => [
-            a.nodes.map((n) => withLeadingComments(n, n.getText())),
-            a.firstPosition,
-        ]),
-        mapNullable(arraysAndTuples, (a) => [
-            a.nodes.map((n) => withLeadingComments(n, n.getText())),
-            a.firstPosition,
-        ]),
-        nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
-            ? mapNullable(typeLiterals, (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition])
-            : undefined,
-        emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
-            ? mapNullable(typeLiterals, (a) => [
-                emptyTypeLiterals.map((n) => withLeadingComments(n, n.getText())),
-
-                a.firstPosition +
-                    (nonEmptyTypeLiterals !== undefined &&
-                        Arr.isNonEmpty(nonEmptyTypeLiterals)
-                        ? 0.5
-                        : 0),
-            ])
-            : undefined,
-        mapNullable(others, (a) => [
-
-
-            operator === '|'
-                ? mergeDeepReadonlyUnionMembers(a.nodes, options.DeepReadonly.typeName, withLeadingComments)
-                : a.nodes.map((n) => withLeadingComments(n, wrapWithParentheses(n.getText()))),
-            a.firstPosition,
-        ]),
-    ]
-        .filter((x) => x !== undefined)
-        .toSorted((a, b) => a[1] - b[1])
-        .flatMap((a) => a[0]);
-
-
 
 
 
@@ -925,14 +975,28 @@ node, readonlyContext, options, operator) => {
 
 
 
+const textWithoutParentheses = (
 
+outer, 
 
+inner) => `${commentsBetween(outer.getSourceFile(), outer.getPos(), inner.getStart())}${inner.getText()}`;
+const unionToStringImpl = ({ types, op, wrapWithReadonly, }) => Arr.isEmpty(types)
+    ? 'never'
+    : Arr.isFixedLengthArray(1, types)
+        ? wrapWithReadonly === false
+            ? wrapWithParentheses(types[0])
+            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>`
+        : wrapWithReadonly === false
+            ? wrapWithParentheses(types.join(` ${op} `))
+            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types.join(` ${op} `)}>`;
+const unionToString = ({ types: typesRaw, op, wrapWithReadonly, }) => {
 
 
 
 
 
-    options.replaceNode(node, unionToString({ types: sorted, op: operator, wrapWithReadonly: false }));
+    const types = typesRaw.map((s) => s.trim());
+    return unionToStringImpl({ types, op, wrapWithReadonly });
 };
 
 
@@ -1052,79 +1116,121 @@ node, operator) => {
         ? textWithoutParentheses(typeArgument, T)
         : unwrapReadonlyTypeArgText(node);
 };
+const transformUnionOrIntersectionTypeNodeImpl = (
 
+node, readonlyContext, options, operator) => {
+    const nextReadonlyContextValue = nextReadonlyContext({
+        currentReadonlyContext: readonlyContext,
+        nextReadonlyContextType: 'none',
+        indexedAccessDepthChange: 'keep',
+    });
 
+    for (const n of node.getTypeNodes() ) {
+        transformNode(n, nextReadonlyContextValue, options);
+    }
+    const newTypes = node.getTypeNodes();
+    const withLeadingComments = (
 
+    member, memberText) => `${leadingCommentsOfMember(node, member)}${memberText}`;
 
 
+    const wrapsTypeLiterals = nextReadonlyContextValue.type !== 'DeepReadonly' &&
+        nextReadonlyContextValue.indexedAccessDepth === 0;
 
 
+    const underReadonly = readonlyContext.type === 'Readonly' &&
+        readonlyContext.indexedAccessDepth === 0 &&
+        isTypeArgumentOfReadonly(node);
+    const { primitives, arraysAndTuples, typeLiterals, others } = groupUnionIntersectionTypes(newTypes, {
+        operator,
+        underReadonly,
+        deepReadonlyTypeName: options.DeepReadonly.typeName,
+        keptUnwrapped: (t) => wrapsTypeLiterals && takesOffReadonly(t, options),
+    });
+    options.debugPrint({ primitives, arraysAndTuples, typeLiterals, others });
 
-const textWithoutParentheses = (
+    const isEmptyTypeLiteral = (
 
-outer, 
+    n) => n.isKind(tsm.SyntaxKind.TypeLiteral) && Arr.isEmpty(n.getMembers());
+    const nonEmptyTypeLiterals = typeLiterals === undefined
+        ? undefined
+        : options.ignoreEmptyObjectTypes
+            ? typeLiterals.nodes.filter((n) => !isEmptyTypeLiteral(n))
+            : typeLiterals.nodes;
+    const emptyTypeLiterals = typeLiterals === undefined || !options.ignoreEmptyObjectTypes
+        ? undefined
+        : typeLiterals.nodes.filter(isEmptyTypeLiteral);
+    const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === undefined || Arr.isEmpty(nonEmptyTypeLiterals)
+        ? []
+        : [
+            unionToString({
+                types: nonEmptyTypeLiterals.map((n) => withLeadingComments(n, isMergeableReadonlyTypeReferenceNode(n, operator)
+                    ?
 
-inner) => `${commentsBetween(outer.getSourceFile(), outer.getPos(), inner.getStart())}${inner.getText()}`;
+                        readonlyTypeArgTextSplicedInto(n, operator)
+                    : n.isKind(tsm.SyntaxKind.TypeLiteral)
+                        ? n.getText()
+                        :
+                            wrapWithParentheses(n.getText()))),
+                op: operator,
+                wrapWithReadonly: wrapsTypeLiterals,
+            }),
+        ];
 
+    const sorted = [
+        mapNullable(primitives, (a) => [
+            a.nodes.map((n) => withLeadingComments(n, n.getText())),
+            a.firstPosition,
+        ]),
+        mapNullable(arraysAndTuples, (a) => [
+            a.nodes.map((n) => withLeadingComments(n, n.getText())),
+            a.firstPosition,
+        ]),
+        nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
+            ? mapNullable(typeLiterals, (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition])
+            : undefined,
+        emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
+            ? mapNullable(typeLiterals, (a) => [
+                emptyTypeLiterals.map((n) => withLeadingComments(n, n.getText())),
 
+                a.firstPosition +
+                    (nonEmptyTypeLiterals !== undefined &&
+                        Arr.isNonEmpty(nonEmptyTypeLiterals)
+                        ? 0.5
+                        : 0),
+            ])
+            : undefined,
+        mapNullable(others, (a) => [
 
 
+            operator === '|'
+                ? mergeDeepReadonlyUnionMembers(a.nodes, options.DeepReadonly.typeName, withLeadingComments)
+                : a.nodes.map((n) => withLeadingComments(n, wrapWithParentheses(n.getText()))),
+            a.firstPosition,
+        ]),
+    ]
+        .filter((x) => x !== undefined)
+        .toSorted((a, b) => a[1] - b[1])
+        .flatMap((a) => a[0]);
 
-const commentsBetween = (
 
-sourceFile, from, to) => {
-    if (to <= from) {
-        return '';
-    }
-    const scanner = tsm.ts.createScanner(tsm.ts.ScriptTarget.Latest, false, tsm.ts.LanguageVariant.Standard, sourceFile.getFullText(), undefined, from, to - from);
-    const mut_comments = [];
-    while (scanner.scan() !== tsm.ts.SyntaxKind.EndOfFileToken) {
-        const token = scanner.getToken();
 
-        const separator = token === tsm.ts.SyntaxKind.SingleLineCommentTrivia
-            ? '\n'
-            : token === tsm.ts.SyntaxKind.MultiLineCommentTrivia
-                ? ' '
-                : undefined;
-        if (separator !== undefined) {
-            mut_comments.push(`${scanner.getTokenText()}${separator}`);
-        }
-    }
-    return mut_comments.join('');
-};
 
-const getDeepReadonlyTypeArg = (
 
-node, deepReadonlyTypeName) => {
-    if (!node.isKind(tsm.SyntaxKind.TypeReference)) {
-        return undefined;
-    }
-    const typeName = node.getTypeName();
-    const typeArguments = node.getTypeArguments();
-    return typeName.isKind(tsm.SyntaxKind.Identifier) &&
-        typeName.getText() === deepReadonlyTypeName &&
-        Arr.isFixedLengthArray(1, typeArguments)
-        ? typeArguments[0]
-        : undefined;
-};
-const unionToString = ({ types: typesRaw, op, wrapWithReadonly, }) => {
 
 
 
 
 
-    const types = typesRaw.map((s) => s.trim());
-    return unionToStringImpl({ types, op, wrapWithReadonly });
+
+
+
+
+
+
+
+    options.replaceNode(node, unionToString({ types: sorted, op: operator, wrapWithReadonly: false }));
 };
-const unionToStringImpl = ({ types, op, wrapWithReadonly, }) => Arr.isEmpty(types)
-    ? 'never'
-    : Arr.isFixedLengthArray(1, types)
-        ? wrapWithReadonly === false
-            ? wrapWithParentheses(types[0])
-            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>`
-        : wrapWithReadonly === false
-            ? wrapWithParentheses(types.join(` ${op} `))
-            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types.join(` ${op} `)}>`;
 
 const transformParenthesizedTypeNode = (
 
@@ -1138,16 +1244,12 @@ node, readonlyContext, options) => {
     const T = node.getTypeNode();
     if (
 
-
     T.isKind(tsm.SyntaxKind.TypeReference) ||
 
-
         T.isKind(tsm.SyntaxKind.ArrayType) ||
 
-
         T.isKind(tsm.SyntaxKind.TupleType) ||
 
-
         isAtomicTypeNode(T) ||
 
 
@@ -1244,89 +1346,4 @@ node, readonlyModifier, readonlyContext, options) => {
         }
     }
 };
-const checkIfPropertyNameShouldBeIgnored = (
-
-nameNode, options) => {
-
-
-    return (
-
-    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
-        pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
-
-        (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
-            pipe(nameNode.getLiteralValue()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
-
-        (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
-            pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(`#${p}`))).value) ||
-
-        (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
-            pipe(nameNode.getExpression()).map((exp) => {
-                if (exp.isKind(tsm.SyntaxKind.StringLiteral) ||
-                    exp.isKind(tsm.SyntaxKind.NoSubstitutionTemplateLiteral)) {
-                    const nm = exp.getLiteralValue();
-                    return options.ignoredPrefixes.some((p) => nm.startsWith(p));
-                }
-                return false;
-            }).value));
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-const isLeftUnwrapped = (
-
-node, options) => {
-    const members = node.getMembers();
-    const isMethodOrAccessor = (
-
-    mb) => mb.isKind(tsm.SyntaxKind.MethodSignature) ||
-        mb.isKind(tsm.SyntaxKind.GetAccessor) ||
-        mb.isKind(tsm.SyntaxKind.SetAccessor);
-    const isIgnoredMember = (
-
-    mb) => (mb.isKind(tsm.SyntaxKind.PropertySignature) || isMethodOrAccessor(mb)) &&
-        checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options);
-    const needsReadonlyWrapper = (
-
-    mb) => !isIgnoredMember(mb) &&
-        (isMethodOrAccessor(mb) ||
-            ((mb.isKind(tsm.SyntaxKind.PropertySignature) ||
-                mb.isKind(tsm.SyntaxKind.IndexSignature)) &&
-                !mb.hasModifier(tsm.SyntaxKind.ReadonlyKeyword) &&
-                hasDisableNextLineComment(mb)));
-    return members.some(isIgnoredMember) && !members.some(needsReadonlyWrapper);
-};
-
-const hasDisableNextLineCommentAround = (node) => {
-    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-        return true;
-    }
-    const parent = node.getParent();
-    return (parent?.isKind(tsm.SyntaxKind.ParenthesizedType) === true &&
-        hasDisableNextLineCommentAround(parent));
-};
-
-
-
-
-
-
-
-const takesOffReadonly = (
-
-node, options) => isLeftUnwrapped(node, options) &&
-    !hasCallOrConstructSignature(node) &&
-    !hasDisableNextLineCommentAround(node);
 //# sourceMappingURL=convert-to-readonly.mjs.map