ts-codemod-lib 4.0.0 → 4.1.0

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

@@ -5,6 +5,8 @@ import { hasCallOrConstructSignature, hasDisableNextLineComment, isAtomicTypeNod
 import { replaceNodeWithDebugPrint, replaceNodeWithText, } from '../utils/index.mjs';
 import { groupUnionIntersectionTypes, invalidDeepReadonlyTypeName, isMergeableReadonlyTypeReferenceNode, nextReadonlyContext, } from './readonly-transformer-helpers/index.mjs';
 const TRANSFORMER_NAME = 'convert-to-readonly';
+const READONLY_RECORD_NAME = 'ReadonlyRecord';
+const READONLY_RECORD_MODULE = 'ts-type-forge';
 export const convertToReadonlyTransformer = (options) => {
     if (options?.DeepReadonly?.typeName !== undefined &&
         invalidDeepReadonlyTypeName.has(options.DeepReadonly.typeName)) {
@@ -27,6 +29,7 @@ export const convertToReadonlyTransformer = (options) => {
         mutableTypePrefixes: ISet.create(options?.mutableTypePrefixes ?? DEFAULT_MUTABLE_TYPE_PREFIXES),
         mutablePropertyPrefixes: ISet.create(options?.mutablePropertyPrefixes ?? DEFAULT_MUTABLE_PREFIXES),
         recordStyle: options?.recordStyle ?? 'ReadonlyRecord',
+        importStyle: options?.importStyle ?? 'named',
         debugPrint: options?.debug === true ? console.debug : () => { },
         replaceNode: options?.debug === true
             ? replaceNodeWithDebugPrint
@@ -35,8 +38,23 @@ export const convertToReadonlyTransformer = (options) => {
     return {
         name: TRANSFORMER_NAME,
         transform: (sourceAst) => {
+            const scope = optionsInternal.recordStyle === 'ReadonlyRecord' &&
+                optionsInternal.importStyle === 'named'
+                ? readonlyRecordScope(sourceAst.compilerNode)
+                : 'in-scope';
+
+
+
+
+            const mayImport = scope === 'free' && tsm.ts.isExternalModule(sourceAst.compilerNode);
+            const fileOptions = scope !== 'in-scope' && !mayImport
+                ? { ...optionsInternal, recordStyle: 'Readonly<Record>' }
+                : optionsInternal;
             for (const node of sourceAst.getChildren()) {
-                transformNode(node, initialReadonlyContext, optionsInternal);
+                transformNode(node, initialReadonlyContext, fileOptions);
+            }
+            if (mayImport && referencesReadonlyRecord(sourceAst.compilerNode)) {
+                addReadonlyRecordImport(sourceAst);
             }
         },
     };
@@ -45,6 +63,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) ||
@@ -198,6 +228,322 @@ const transformNode = (node, readonlyContext, options) => {
 
 
 
+const topLevelBindings = (
+
+statement) => {
+    if (tsm.ts.isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+
+        const namespaceImport = bindings !== undefined && tsm.ts.isNamespaceImport(bindings)
+            ? [{ name: bindings.name.text, isType: false }]
+            : [];
+        const named = bindings !== undefined && tsm.ts.isNamedImports(bindings)
+            ? bindings.elements.map((element) => ({
+                name: element.name.text,
+                isType: true,
+            }))
+            : [];
+        const defaultImport = clause?.name === undefined
+            ? []
+            : [{ name: clause.name.text, isType: true }];
+        return [...defaultImport, ...namespaceImport, ...named];
+    }
+    if (tsm.ts.isImportEqualsDeclaration(statement)) {
+        return [{ name: statement.name.text, isType: true }];
+    }
+    if (tsm.ts.isTypeAliasDeclaration(statement) ||
+        tsm.ts.isInterfaceDeclaration(statement) ||
+        tsm.ts.isClassDeclaration(statement) ||
+        tsm.ts.isEnumDeclaration(statement)) {
+        return statement.name === undefined
+            ? []
+            : [{ name: statement.name.text, isType: true }];
+    }
+    if ((tsm.ts.isFunctionDeclaration(statement) ||
+        tsm.ts.isModuleDeclaration(statement)) &&
+        statement.name !== undefined &&
+        tsm.ts.isIdentifier(statement.name)) {
+        return [{ name: statement.name.text, isType: false }];
+    }
+    if (tsm.ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations.flatMap((declaration) => tsm.ts.isIdentifier(declaration.name)
+            ? [{ name: declaration.name.text, isType: false }]
+            : []);
+    }
+    return [];
+};
+
+
+
+
+const referencesReadonlyRecord = (node) => (tsm.ts.isTypeReferenceNode(node) &&
+    tsm.ts.isIdentifier(node.typeName) &&
+    node.typeName.text === READONLY_RECORD_NAME) ||
+    (tsm.ts.isExpressionWithTypeArguments(node) &&
+        tsm.ts.isIdentifier(node.expression) &&
+        node.expression.text === READONLY_RECORD_NAME) ||
+    (tsm.ts.forEachChild(node, (child) => referencesReadonlyRecord(child) || undefined) ??
+        false);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const readonlyRecordScope = (
+
+sourceFile) => {
+    const topLevelNames = sourceFile.statements.flatMap(topLevelBindings);
+    return topLevelNames.some(({ name, isType }) => isType && name === READONLY_RECORD_NAME) || referencesReadonlyRecord(sourceFile)
+        ? 'in-scope'
+        : topLevelNames.some(({ name }) => name === READONLY_RECORD_NAME)
+            ? 'taken'
+            : 'free';
+};
+
+
+
+
+const endOfLineComments = (text, end) => tsm.ts.getTrailingCommentRanges(text, end)?.at(-1)?.end ?? end;
+
+
+
+
+
+
+
+
+
+
+const newImportPosition = (
+
+sourceFile) => {
+    const text = sourceFile.getFullText();
+    const first = sourceFile.getStatements().at(0);
+    if (first === undefined) {
+        return text.length;
+    }
+    const comments = tsm.ts.getLeadingCommentRanges(text, first.getFullStart()) ?? [];
+    let mut_position = first.getStart();
+    for (const comment of comments.toReversed()) {
+        const commentText = text.slice(comment.pos, comment.end);
+        if (/\n[^\S\n]*\n/u.test(text.slice(comment.end, mut_position)) ||
+            commentText.startsWith('///') ||
+            (commentText.startsWith('/*') && !commentText.startsWith('/**')) ||
+            /@(?:ts-nocheck|ts-check|jsx)/u.test(commentText)) {
+            break;
+        }
+        mut_position = comment.pos;
+    }
+    return mut_position;
+};
+
+const directivePrologue = (
+
+sourceFile) => {
+    const statements = sourceFile.compilerNode.statements;
+    const end = statements.findIndex((statement) => !(tsm.ts.isExpressionStatement(statement) &&
+        tsm.ts.isStringLiteral(statement.expression)));
+    return statements.slice(0, end === -1 ? statements.length : end);
+};
+const insertReadonlyRecordImport = (
+
+sourceFile, text) => {
+    const imports = sourceFile.getImportDeclarations();
+    const hosts = imports.filter((decl) => decl.getModuleSpecifierValue() === READONLY_RECORD_MODULE &&
+        tsm.Node.isNamedImports(decl.getImportClause()?.getNamedBindings()));
+    const host = hosts.find((decl) => decl.isTypeOnly()) ?? hosts.at(0);
+    if (host !== undefined) {
+
+
+        host.addNamedImport({
+            name: READONLY_RECORD_NAME,
+            isTypeOnly: !host.isTypeOnly(),
+        });
+        return;
+    }
+
+
+    const declaration = `import type { ${READONLY_RECORD_NAME} } from '${READONLY_RECORD_MODULE}';`;
+    const anchorEnd = imports.at(-1)?.getEnd() ?? directivePrologue(sourceFile).at(-1)?.end;
+    if (anchorEnd === undefined) {
+        sourceFile.insertText(newImportPosition(sourceFile), `${declaration}\n\n`);
+    }
+    else {
+        sourceFile.insertText(endOfLineComments(text, anchorEnd), `\n${declaration}`);
+    }
+};
+
+
+
+
+
+
+
+const addReadonlyRecordImport = (
+
+sourceFile) => {
+    const text = sourceFile.getFullText();
+
+
+    const { manipulationSettings } = sourceFile.getProject();
+    const newLineKind = manipulationSettings.getNewLineKind();
+    manipulationSettings.set({
+        newLineKind: text.includes('\r\n')
+            ? tsm.NewLineKind.CarriageReturnLineFeed
+            : tsm.NewLineKind.LineFeed,
+    });
+    try {
+        insertReadonlyRecordImport(sourceFile, text);
+    }
+    finally {
+        manipulationSettings.set({ newLineKind });
+    }
+};
+
+
+
+
+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);
+
 
 
 
@@ -520,10 +866,6 @@ node, readonlyContext, options) => {
     }
 };
 
-const readonlyRecordText = (keyText, valueText, options) => options.recordStyle === 'ReadonlyRecord'
-    ? `ReadonlyRecord<${keyText}, ${valueText}>`
-    : `Readonly<Record<${keyText}, ${valueText}>>`;
-
 const transformArrayTypeNode = (
 
 node, readonlyContext, options) => {
@@ -828,104 +1170,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]);
-
-
 
 
 
@@ -934,14 +1178,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 });
 };
 
 
@@ -1061,79 +1319,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 = (
 
@@ -1147,16 +1447,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) ||
 
 
@@ -1253,101 +1549,4 @@ node, readonlyModifier, readonlyContext, options) => {
         }
     }
 };
-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);
-
-const hasMutableTypeName = (name, options) => name !== undefined &&
-    options.mutableTypePrefixes.some((p) => name.startsWith(p));
-
-
-
-
-const mutablePrefixesOfParameter = (
-
-param, options) => param.isParameterProperty()
-    ? options.mutablePropertyPrefixes
-    : options.mutableVariablePrefixes;
 //# sourceMappingURL=convert-to-readonly.mjs.map