ts-const-value-transformer 0.8.2 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v0.9.1
+
+- Add `hoistConstTemplateLiteral` option
+- Fix for the return type of `getCustomTransformers`
+
+## 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

package/README.md

@@ -166,6 +166,8 @@ export interface TransformOptions {
   useUndefinedSymbolForUndefinedValue?: boolean | undefined;
   /** Hoist `undefined` symbol to `void 0` (or `undefined` if useUndefinedSymbolForUndefinedValue is true). Default is true. */
   hoistUndefinedSymbol?: boolean | undefined;
+  /** Hoist template literals with constant (not including variables). Default is false because it is not necessary for ES2015 or later; Script minifiers would optimize for those values. For ES5 (which will be deprecated in the future), TypeScript converts template literals to such as `''.concat(...)`, which is not treated as constant values. */
+  hoistConstTemplateLiteral?: boolean | undefined;
   /**
    * External names (tested with `.includes()` for string, with `.test()` for RegExp) for `hoistExternalValues` settings (If `hoistExternalValues` is not specified, this setting will be used).
    * - Path separators for input file name are always normalized to '/' internally.
@@ -260,6 +262,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/getCustomTransformers.d.mts

@@ -1,6 +1,2 @@
 import type * as ts from 'typescript';
-export default function getCustomTransformers(program: ts.Program, _getProgram: () => ts.Program): {
-    before?: Array<ts.TransformerFactory<ts.SourceFile>>;
-    after?: Array<ts.TransformerFactory<ts.SourceFile>>;
-    afterDeclarations?: Array<ts.TransformerFactory<ts.SourceFile>>;
-};
+export default function getCustomTransformers(program: ts.Program, _getProgram: () => ts.Program): ts.CustomTransformers;

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

@@ -21,6 +21,8 @@ export interface TransformOptions {
     useUndefinedSymbolForUndefinedValue?: boolean | undefined;
     /** Hoist `undefined` symbol to `void 0` (or `undefined` if {@linkcode useUndefinedSymbolForUndefinedValue} is true). Default is true. */
     hoistUndefinedSymbol?: boolean | undefined;
+    /** Hoist template literals with constant (not including variables). Default is false because it is not necessary for ES2015 or later; Script minifiers would optimize for those values. For ES5 (which will be deprecated in the future), TypeScript converts template literals to such as `''.concat(...)`, which is not treated as constant values. */
+    hoistConstTemplateLiteral?: boolean | undefined;
     /**
      * External names (tested with `.includes()` for string, with `.test()` for RegExp) for `hoistExternalValues` settings (If `hoistExternalValues` is not specified, this setting will be used).
      * - Path separators for input file name are always normalized to '/' internally.
@@ -39,3 +41,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

@@ -14,6 +14,7 @@ function assignDefaultValues(options = {}) {
         unsafeHoistWritableValues: options.unsafeHoistWritableValues ?? false,
         useUndefinedSymbolForUndefinedValue: options.useUndefinedSymbolForUndefinedValue ?? false,
         hoistUndefinedSymbol: options.hoistUndefinedSymbol ?? true,
+        hoistConstTemplateLiteral: options.hoistConstTemplateLiteral ?? false,
         externalNames: options.externalNames ?? [],
         ignoreFiles: options.ignoreFiles ?? [],
     };
@@ -41,25 +42,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) ||
@@ -101,6 +121,11 @@ function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, options,
             return node;
         }
     }
+    else if (ts.isTemplateExpression(node)) {
+        if (!options.hoistConstTemplateLiteral) {
+            return node;
+        }
+    }
     else {
         return node;
     }
@@ -127,7 +152,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 +165,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 +217,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 {
@@ -494,3 +544,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.2";
+declare const _default: "0.9.1";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.8.2';
+export default '0.9.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-const-value-transformer",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "engines": {
     "node": ">=20.19.3"
   },
@@ -112,7 +112,8 @@
     "ts-patch": "^3.3.0",
     "tslib": "^2.8.1",
     "typescript": "~5.5.4",
-    "webpack": "^5.103.0"
+    "webpack": "^5.103.0",
+    "webpack-cli": "^6.0.1"
   },
   "peerDependencies": {
     "typescript": ">=5.5"