ts-const-value-transformer 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v0.9.0
+
+- Add `transformAndPrintSource` and `transformAndPrintSourceWithMap` to visit nodes only once, and use them in portal transformer
+
+## v0.8.2
+
+- Fix to use internal functions to reduce memory usage
+
 ## v0.8.1
 
 - Fix to parenthesize expression with multi-line

package/README.md

@@ -260,6 +260,17 @@ Prints (generates) source code from `SourceFile`, along with raw source-map data
 - `originalSourceName` would be the file name of `sourceFile`, but you can specify another name.
 - `startOfSourceMap` is a base source map (if original source file is a generated-content) if available.
 
+#### transformAndPrintSource: (sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions) => string
+
+Transforms the source file with TypeScript project and prints a new source code. This acts like combination of `transformSource` and `printSource`, but performs in one loop, so if transformed AST is not necessary, this function is suitable.
+
+#### transformAndPrintSourceWithMap: (sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, originalSourceName: string, options?: TransformOptions, startOfSourceMap?: RawSourceMap) => [string, RawSourceMap]
+
+Transforms the source file with TypeScript project and prints a new source code. This acts like combination of `transformSource` and `printSourceWithMap`, but performs in one loop, so if transformed AST is not necessary, this function is suitable.
+
+- `originalSourceName` would be the file name of `sourceFile`, but you can specify another name.
+- `startOfSourceMap` is a base source map (if original source file is a generated-content) if available.
+
 #### transformSource: (sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext, options?: TransformOptions) => ts.SourceFile
 
 Transforms the source file with TypeScript project. You don't need to call this function directly; use `createTransformer` or `createPortalTransformer` instead.

package/dist/createPortalTransformer.mjs

@@ -1,8 +1,7 @@
 import * as fs from 'fs';
 import { createRequire } from 'module';
 import * as path from 'path';
-import createTransformer from './createTransformer.mjs';
-import { getIgnoreFilesFunction, printSourceWithMap, } from './transform.mjs';
+import { getIgnoreFilesFunction, transformAndPrintSourceWithMap, } from './transform.mjs';
 const require = createRequire(import.meta.url);
 function optionsToString(options) {
     return JSON.stringify(options, (key, value) => {
@@ -105,18 +104,9 @@ function createPortalTransformerImpl(options, ts) {
                 });
                 sourceFile.text = content;
             }
-            const transformer = createTransformer(program, {
-                options: { ...options, ...individualOptions, ts },
-            });
-            const transformResult = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
-            const transformedSource = transformResult.transformed[0];
-            let result;
-            // If unchanged, return base file as-is
-            if (transformedSource === sourceFile) {
-                result = [content ?? sourceFile.text, rawSourceMap];
-            }
-            else {
-                result = printSourceWithMap(transformedSource, fileName, rawSourceMap, ts);
+            const result = transformAndPrintSourceWithMap(sourceFile, program, undefined, fileName, { ...options, ...individualOptions, ts }, rawSourceMap);
+            if (sourceFile.text === result[0]) {
+                result[1] = undefined;
             }
             if (cacheResult) {
                 // This forces to concatenate strings into flatten one, to reduce object trees for ConsString

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import createPortalTransformer, { createPortalTransformerSync, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull } from './createPortalTransformer.mjs';
 import createTransformer from './createTransformer.mjs';
 import version from './version.mjs';
-export { printSource, printSourceWithMap, transformSource, type TransformOptions, } from './transform.mjs';
+export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, type TransformOptions, } from './transform.mjs';
 export { createPortalTransformer, createPortalTransformerSync, createTransformer, type CreatePortalTransformerOptions, type PortalTransformer, type PortalTransformerResult, type PortalTransformerResultNonNull, version, };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import createPortalTransformer, { createPortalTransformerSync, } from './createPortalTransformer.mjs';
 import createTransformer from './createTransformer.mjs';
 import version from './version.mjs';
-export { printSource, printSourceWithMap, transformSource, } from './transform.mjs';
+export { printSource, printSourceWithMap, transformAndPrintSource, transformAndPrintSourceWithMap, transformSource, } from './transform.mjs';
 export { createPortalTransformer, createPortalTransformerSync, createTransformer, version, };

package/dist/transform.d.mts

@@ -39,3 +39,5 @@ export declare function getIgnoreFilesFunction(ignoreFiles: TransformOptions['ig
 export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions): ts.SourceFile;
 export declare function printSource(sourceFile: ts.SourceFile, tsInstance?: typeof ts): string;
 export declare function printSourceWithMap(sourceFile: ts.SourceFile, originalSourceName: string, startOfSourceMap?: sourceMap.RawSourceMap, tsInstance?: typeof ts): [string, sourceMap.RawSourceMap];
+export declare function transformAndPrintSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, options?: TransformOptions): string;
+export declare function transformAndPrintSourceWithMap(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext | undefined, originalSourceName: string, options?: TransformOptions, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];

package/dist/transform.mjs

@@ -41,25 +41,44 @@ export function getIgnoreFilesFunction(ignoreFiles) {
 ////////////////////////////////////////////////////////////////////////////////
 export function transformSource(sourceFile, program, context, options) {
     const requiredOptions = assignDefaultValues(options);
-    return requiredOptions.ts.visitEachChild(sourceFile, (node) => visitNodeChildren(node, sourceFile, sourceFile, program, requiredOptions, context), context);
+    const ts = requiredOptions.ts;
+    return ts.visitEachChild(sourceFile, (node) => visitNodeChildren(node, sourceFile, sourceFile, program, requiredOptions, context, (node) => {
+        // skip statements which would not have 'value' expressions
+        if (ts.isInterfaceDeclaration(node) ||
+            ts.isTypeAliasDeclaration(node) ||
+            // Identifies in import clause should not be parsed
+            ts.isImportDeclaration(node) ||
+            ts.isTypeOnlyExportDeclaration(node)) {
+            return false;
+        }
+        return true;
+    }), context);
 }
-function visitNodeChildren(node, parent, sourceFile, program, options, context) {
+function visitNodeChildren(node, parent, sourceFile, program, options, context, fnVisit, visitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace) {
     const ts = options.ts;
-    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context);
-    if (newNode[SYMBOL_ORIGINAL_NODE_DATA]) {
-        return newNode;
+    if (fnVisitBeforeReplace) {
+        fnVisitBeforeReplace(node, parent, visitContext);
+    }
+    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context, visitContext, fnReplace ?? 'create');
+    if (newNode == null) {
+        return node;
     }
-    // skip statements which would not have 'value' expressions
-    if (ts.isInterfaceDeclaration(newNode) ||
-        ts.isTypeAliasDeclaration(newNode) ||
-        // Identifies in import clause should not be parsed
-        ts.isImportDeclaration(newNode) ||
-        ts.isTypeOnlyExportDeclaration(newNode)) {
+    if (newNode !== node) {
         return newNode;
     }
-    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, newNode, sourceFile, program, options, context), context);
+    if (!fnVisit(node, parent, visitContext)) {
+        return node;
+    }
+    const childVisitContext = fnVisitBeforeChild
+        ? fnVisitBeforeChild(node, parent, visitContext)
+        : visitContext;
+    const r = ts.visitEachChild(node, (nodeChild) => visitNodeChildren(nodeChild, node, sourceFile, program, options, context, fnVisit, childVisitContext, fnVisitBeforeReplace, fnVisitBeforeChild, fnVisitAfterChild, fnReplace), context);
+    if (fnVisitAfterChild) {
+        fnVisitAfterChild(node, parent, childVisitContext);
+    }
+    return r;
 }
-function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context) {
+function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options, context, visitContext, replaceOption) {
     const ts = options.ts;
     if (ts.isCallLikeExpression(node)) {
         if (!ts.isExpression(node) ||
@@ -127,7 +146,9 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
         }
         let newSource;
         if (type.isStringLiteral()) {
-            newNode = ts.factory.createStringLiteral(type.value);
+            if (replaceOption === 'create') {
+                newNode = ts.factory.createStringLiteral(type.value);
+            }
             newSource =
                 // TypeScript namespace may export `function escapeNonAsciiString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote | CharacterCodes.backtick): string`
                 'escapeNonAsciiString' in ts
@@ -138,36 +159,50 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
         }
         else if (type.isNumberLiteral()) {
             if (type.value < 0) {
-                newNode = ts.factory.createParenthesizedExpression(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-type.value)));
+                if (replaceOption === 'create') {
+                    newNode = ts.factory.createParenthesizedExpression(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-type.value)));
+                }
                 newSource = `(-${-type.value})`;
             }
             else {
-                newNode = ts.factory.createNumericLiteral(type.value);
+                if (replaceOption === 'create') {
+                    newNode = ts.factory.createNumericLiteral(type.value);
+                }
                 newSource = `${type.value}`;
             }
         }
         else if (flags & ts.TypeFlags.BigIntLiteral) {
             const text = typeChecker.typeToString(type);
-            newNode = ts.factory.createBigIntLiteral(text);
+            if (replaceOption === 'create') {
+                newNode = ts.factory.createBigIntLiteral(text);
+            }
             newSource = text;
         }
         else if (flags & ts.TypeFlags.BooleanLiteral) {
             const text = typeChecker.typeToString(type);
-            newNode =
-                text === 'true' ? ts.factory.createTrue() : ts.factory.createFalse();
+            if (replaceOption === 'create') {
+                newNode =
+                    text === 'true' ? ts.factory.createTrue() : ts.factory.createFalse();
+            }
             newSource = text;
         }
         else if (flags & ts.TypeFlags.Null) {
-            newNode = ts.factory.createNull();
+            if (replaceOption === 'create') {
+                newNode = ts.factory.createNull();
+            }
             newSource = 'null';
         }
         else if (flags & ts.TypeFlags.Undefined) {
             if (options.useUndefinedSymbolForUndefinedValue) {
-                newNode = ts.factory.createIdentifier('undefined');
+                if (replaceOption === 'create') {
+                    newNode = ts.factory.createIdentifier('undefined');
+                }
                 newSource = 'undefined';
             }
             else {
-                newNode = ts.factory.createParenthesizedExpression(ts.factory.createVoidZero());
+                if (replaceOption === 'create') {
+                    newNode = ts.factory.createParenthesizedExpression(ts.factory.createVoidZero());
+                }
                 newSource = '(void 0)';
             }
         }
@@ -176,19 +211,28 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
         }
         const originalSource = node.getText(sourceFile);
         const comment = ` ${originalSource.replace(/\/\*/g, ' *').replace(/\*\//g, '* ')} `;
-        let result = ts.addSyntheticTrailingComment(newNode, ts.SyntaxKind.MultiLineCommentTrivia, comment);
+        let result = newNode
+            ? ts.addSyntheticTrailingComment(newNode, ts.SyntaxKind.MultiLineCommentTrivia, comment)
+            : undefined;
         newSource = `${newSource} /*${comment}*/`;
         if (/[\r\n]/m.test(originalSource)) {
-            result = ts.factory.createParenthesizedExpression(result);
+            if (result) {
+                result = ts.factory.createParenthesizedExpression(result);
+            }
             newSource = `(${newSource})`;
         }
-        ts.setTextRange(result, node);
-        result[SYMBOL_ORIGINAL_NODE_DATA] = [
-            originalSource,
-            newSource,
-            node.pos,
-            node.end,
-        ];
+        if (result) {
+            ts.setTextRange(result, node);
+            result[SYMBOL_ORIGINAL_NODE_DATA] = [
+                originalSource,
+                newSource,
+                node.pos,
+                node.end,
+            ];
+        }
+        if (replaceOption !== 'create') {
+            replaceOption(newSource, originalSource, node.pos, node.end, visitContext);
+        }
         return result;
     }
     catch {
@@ -295,24 +339,6 @@ function getNameFromElementAccessExpression(node, typeChecker) {
     }
     return null;
 }
-function getMemberName(m, tsInstance) {
-    if (!m || !m.name) {
-        return '';
-    }
-    const name = m.name;
-    if (tsInstance.isIdentifier(name)) {
-        return name.escapedText;
-    }
-    else if (tsInstance.isPrivateIdentifier(name)) {
-        return name.escapedText;
-    }
-    else if (tsInstance.isStringLiteral(name)) {
-        return name.text;
-    }
-    else {
-        return '';
-    }
-}
 function isReadonlyPropertyAccess(a, typeChecker, tsInstance) {
     const ts = tsInstance;
     const type = typeChecker.getTypeAtLocation(a.expression);
@@ -323,32 +349,36 @@ function isReadonlyPropertyAccess(a, typeChecker, tsInstance) {
         return false;
     }
     if (type.getFlags() & ts.TypeFlags.Object) {
-        const dummyTypeNode = typeChecker.typeToTypeNode(type, a, ts.NodeBuilderFlags.NoTruncation);
-        if (dummyTypeNode && ts.isTypeLiteralNode(dummyTypeNode)) {
-            for (let i = 0; i < dummyTypeNode.members.length; ++i) {
-                const m = dummyTypeNode.members[i];
-                if (m &&
-                    getMemberName(m, ts) === memberName &&
-                    ts.isPropertySignature(m)) {
-                    if (m.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword)) {
-                        return true;
-                    }
+        const prop = type.getProperty(memberName);
+        if (prop) {
+            // Use internal but exported function to improve memory performance
+            if ('getCheckFlags' in ts &&
+                'CheckFlags' in ts &&
+                ts.CheckFlags.Readonly != null) {
+                const checkFlags = ts.getCheckFlags(prop);
+                if (checkFlags & ts.CheckFlags.Readonly) {
+                    return true;
                 }
             }
-        }
-        const prop = type.getProperty(memberName);
-        if (prop && prop.declarations && prop.declarations.length > 0) {
-            const decl = prop.declarations[0];
-            if (ts.isPropertySignature(decl) &&
-                decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword)) {
-                return true;
+            if ('getDeclarationModifierFlagsFromSymbol' in ts) {
+                const modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(prop);
+                if (modifierFlags & ts.ModifierFlags.Readonly) {
+                    return true;
+                }
             }
-            if (ts.isVariableDeclaration(decl) &&
-                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-                decl.parent &&
-                ts.isVariableDeclarationList(decl.parent) &&
-                decl.parent.flags & ts.NodeFlags.Const) {
-                return true;
+            if (prop.declarations && prop.declarations.length > 0) {
+                const decl = prop.declarations[0];
+                if (ts.isPropertySignature(decl) &&
+                    decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword)) {
+                    return true;
+                }
+                if (ts.isVariableDeclaration(decl) &&
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    decl.parent &&
+                    ts.isVariableDeclarationList(decl.parent) &&
+                    decl.parent.flags & ts.NodeFlags.Const) {
+                    return true;
+                }
             }
         }
     }
@@ -508,3 +538,103 @@ function printNode(tsInstance, baseSource, sourceFile, node, posContext, origina
         }
     }
 }
+////////////////////////////////////////////////////////////////////////////////
+export function transformAndPrintSource(sourceFile, program, context, options) {
+    return transformAndPrintSourceImpl(sourceFile, program, context, options)[0];
+}
+export function transformAndPrintSourceWithMap(sourceFile, program, context, originalSourceName, options, startOfSourceMap) {
+    const generator = new sourceMap.SourceMapGenerator(startOfSourceMap);
+    return transformAndPrintSourceImpl(sourceFile, program, context, options, originalSourceName, generator);
+}
+function transformAndPrintSourceImpl(sourceFile, program, context, options, originalSourceName, mapGenerator) {
+    const requiredOptions = assignDefaultValues(options);
+    if (mapGenerator) {
+        mapGenerator.setSourceContent(originalSourceName, sourceFile.getFullText());
+    }
+    const r = transformAndPrintNode({ pos: 0, diff: 0, lastLine: 0 }, sourceFile.getFullText(), sourceFile, program, context, requiredOptions, originalSourceName, mapGenerator);
+    return [r, mapGenerator?.toJSON()];
+}
+function transformAndPrintNode(posContext, baseSource, sourceFile, program, context, options, originalSourceName, mapGenerator) {
+    let output = '';
+    visitNodeChildren(sourceFile, sourceFile, sourceFile, program, options, context, 
+    // fnVisit
+    (child, _parent, visitContext) => {
+        visitContext.lastChildPos = child.end;
+        return true;
+    }, 
+    // visitContext
+    {
+        headPrinted: false,
+        lastChildPos: 0,
+    }, 
+    // fnVisitBeforeReplace
+    (child, parent, visitContext) => {
+        if (!visitContext.headPrinted) {
+            visitContext.headPrinted = true;
+            if (child.pos > parent.pos) {
+                const text = baseSource.substring(parent.pos, child.pos);
+                output += text;
+                posContext.pos = child.pos;
+            }
+        }
+        else if (child.pos > visitContext.lastChildPos) {
+            const text = baseSource.substring(visitContext.lastChildPos, child.pos);
+            output += text;
+            posContext.pos = child.pos;
+        }
+    }, 
+    // fnVisitBeforeChild
+    () => {
+        return {
+            headPrinted: false,
+            lastChildPos: 0,
+        };
+    }, 
+    // fnVisitAfterChild
+    (node, _parent, childVisitContext) => {
+        if (!childVisitContext.headPrinted) {
+            output += baseSource.substring(node.pos, node.end);
+            posContext.pos = node.end;
+        }
+        else if (childVisitContext.lastChildPos < node.end) {
+            const text = baseSource.substring(childVisitContext.lastChildPos, node.end);
+            output += text;
+            posContext.pos = node.end;
+        }
+    }, 
+    // fnReplace
+    (newSource, originalSource, pos, end, visitContext) => {
+        const oldFull = baseSource.substring(pos, end);
+        const i = oldFull.lastIndexOf(originalSource);
+        const leadingUnchanged = i < 0 ? 0 : i;
+        const newText = i < 0
+            ? newSource
+            : oldFull.substring(0, i) +
+                newSource +
+                oldFull.substring(i + originalSource.length);
+        posContext.pos = pos + leadingUnchanged;
+        addMappingForCurrent(originalSource);
+        posContext.diff += newSource.length - originalSource.length;
+        posContext.pos += originalSource.length;
+        addMappingForCurrent();
+        posContext.pos = end;
+        output += newText;
+        visitContext.lastChildPos = end;
+    });
+    return output;
+    function addMappingForCurrent(name) {
+        const original = positionToLineAndColumn(sourceFile, posContext.pos, 0);
+        if (original.line !== posContext.lastLine) {
+            posContext.diff = 0;
+            posContext.lastLine = original.line;
+        }
+        if (mapGenerator) {
+            mapGenerator.addMapping({
+                original,
+                generated: positionToLineAndColumn(sourceFile, posContext.pos, posContext.diff),
+                source: originalSourceName,
+                name,
+            });
+        }
+    }
+}

package/dist/version.d.mts

@@ -1,2 +1,2 @@
-declare const _default: "0.8.1";
+declare const _default: "0.9.0";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.8.1';
+export default '0.9.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-const-value-transformer",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "engines": {
     "node": ">=20.19.3"
   },