ts-const-value-transformer 0.9.0 → 0.10.0

package/dist/lspTransformer.mjs

@@ -0,0 +1,226 @@
+import * as tsNamespace from 'typescript';
+import { nodeToTypeString, nodeToTypeFlags, isExpressionReadonly, isExternalReference, isUndefinedIdentifier, isEnumAccess, } from './lsp/lspTransformerUtil.mjs';
+import { printSourceWithMapWithProxy, printSourceWithProxy, transformAndPrintSourceWithMapWithProxy, transformAndPrintSourceWithProxy, transformSourceWithProxy, } from './transform.mjs';
+function makeLspProxy(tsInstance, lspClient, getSourceFile) {
+    return {
+        visitEachChild(node, visitor, context) {
+            return tsInstance.visitEachChild(node, visitor, context);
+        },
+        getNodeText(node, sourceFile) {
+            return node.getText(sourceFile);
+        },
+        getNodeFullText(node, sourceFile) {
+            return node.getFullText(sourceFile);
+        },
+        appendMultiLineComment(node, comment) {
+            return tsInstance.addSyntheticTrailingComment(node, tsInstance.SyntaxKind.MultiLineCommentTrivia, comment);
+        },
+        setTextRange(range, location) {
+            return tsInstance.setTextRange(range, location);
+        },
+        isExpression(node) {
+            return tsInstance.isExpression(node);
+        },
+        isAsExpression(node) {
+            return tsInstance.isAsExpression(node);
+        },
+        isCallLikeExpression(node) {
+            return tsInstance.isCallLikeExpression(node);
+        },
+        isTemplateExpression(node) {
+            return tsInstance.isTemplateExpression(node);
+        },
+        isPropertyAccessExpression(node) {
+            return tsInstance.isPropertyAccessExpression(node);
+        },
+        isElementAccessExpression(node) {
+            return tsInstance.isElementAccessExpression(node);
+        },
+        isInterfaceDeclaration(node) {
+            return tsInstance.isInterfaceDeclaration(node);
+        },
+        isTypeAliasDeclaration(node) {
+            return tsInstance.isTypeAliasDeclaration(node);
+        },
+        isImportDeclaration(node) {
+            return tsInstance.isImportDeclaration(node);
+        },
+        isTypeOnlyExportDeclaration(node) {
+            return tsInstance.isTypeOnlyExportDeclaration(node);
+        },
+        isIdentifier(node) {
+            return tsInstance.isIdentifier(node);
+        },
+        isComputedPropertyName(node) {
+            return tsInstance.isComputedPropertyName(node);
+        },
+        getTypeAtLocation(node, sourceFile) {
+            if (!lspClient) {
+                return undefined;
+            }
+            const typeString = nodeToTypeString(node, sourceFile, tsInstance, lspClient);
+            const flags = nodeToTypeFlags(node, sourceFile, tsInstance, lspClient);
+            let value = typeString;
+            if ((flags & tsInstance.TypeFlags.NumberLiteral) !== 0) {
+                value = Number(typeString);
+            }
+            else if ((flags & tsInstance.TypeFlags.StringLiteral) !== 0) {
+                try {
+                    value = JSON.parse(typeString);
+                }
+                catch { }
+            }
+            const t = {
+                flags,
+                typeString,
+                value,
+            };
+            return t;
+        },
+        isEnumLiteral(type) {
+            return ((type.flags & tsInstance.TypeFlags.EnumLiteral) !== 0);
+        },
+        isStringLiteral(type) {
+            return ((type.flags & tsInstance.TypeFlags.StringLiteral) !== 0);
+        },
+        isNumberLiteral(type) {
+            return ((type.flags & tsInstance.TypeFlags.NumberLiteral) !== 0);
+        },
+        isBigIntLiteral(type) {
+            return ((type.flags & tsInstance.TypeFlags.BigIntLiteral) !== 0);
+        },
+        isBooleanLiteral(type) {
+            return ((type.flags & tsInstance.TypeFlags.BooleanLiteral) !== 0);
+        },
+        isNullType(type) {
+            return (type.flags & tsInstance.TypeFlags.Null) !== 0;
+        },
+        isUndefinedType(type) {
+            return (type.flags & tsInstance.TypeFlags.Undefined) !== 0;
+        },
+        typeToString(type) {
+            return type.typeString;
+        },
+        factory: {
+            createIdentifier(text) {
+                return tsInstance.factory.createIdentifier(text);
+            },
+            createStringLiteral(value) {
+                return tsInstance.factory.createStringLiteral(value);
+            },
+            createNumericLiteral(value) {
+                return tsInstance.factory.createNumericLiteral(value);
+            },
+            createExpressionWithMinusToken(operand) {
+                return tsInstance.factory.createParenthesizedExpression(tsInstance.factory.createPrefixUnaryExpression(tsInstance.SyntaxKind.MinusToken, operand));
+            },
+            createBigIntLiteral(value) {
+                return tsInstance.factory.createBigIntLiteral(value);
+            },
+            createTrue() {
+                return tsInstance.factory.createTrue();
+            },
+            createFalse() {
+                return tsInstance.factory.createFalse();
+            },
+            createNull() {
+                return tsInstance.factory.createNull();
+            },
+            createParenthesizedExpression(expression) {
+                return tsInstance.factory.createParenthesizedExpression(expression);
+            },
+            createVoidZero() {
+                return tsInstance.factory.createParenthesizedExpression(tsInstance.factory.createVoidZero());
+            },
+        },
+        isEnumAccess(node, sourceFile) {
+            if (!lspClient) {
+                return false;
+            }
+            return isEnumAccess(node, sourceFile, tsInstance, lspClient);
+        },
+        isEnumIdentifier(node, sourceFile) {
+            if (!lspClient) {
+                return false;
+            }
+            const typeFlags = nodeToTypeFlags(node, sourceFile, tsInstance, lspClient);
+            return (typeFlags & tsInstance.TypeFlags.EnumLiteral) !== 0;
+        },
+        isExternalReference(node, externalNames, sourceFile) {
+            if (!lspClient) {
+                return false;
+            }
+            return isExternalReference(node, sourceFile, tsInstance, lspClient, externalNames);
+        },
+        hasPureAnnotation(node, sourceFile) {
+            const fullText = node.getFullText(sourceFile);
+            const ranges = tsInstance.getLeadingCommentRanges(fullText, 0) ?? [];
+            for (const range of ranges) {
+                if (range.kind !== tsInstance.SyntaxKind.MultiLineCommentTrivia) {
+                    continue;
+                }
+                const text = fullText.slice(range.pos + 2, range.end - 2).trim();
+                if ((text[0] === '@' || text[0] === '#') &&
+                    text.slice(1) === '__PURE__') {
+                    return true;
+                }
+            }
+            return false;
+        },
+        isReadonlyExpression(node, sourceFile) {
+            if (!lspClient) {
+                return null;
+            }
+            return isExpressionReadonly(node, sourceFile, tsInstance, lspClient, getSourceFile);
+        },
+        isHoistablePropertyAccess(_node, sourceFile) {
+            if (!lspClient) {
+                return false;
+            }
+            const node = _node;
+            const typeFlags = nodeToTypeFlags(node, sourceFile, tsInstance, lspClient);
+            return typeFlags !== 0;
+        },
+        isUndefinedIdentifier(node, parent, sourceFile) {
+            if (!lspClient) {
+                return false;
+            }
+            return isUndefinedIdentifier(node, parent, sourceFile, tsInstance, lspClient);
+        },
+        makeStringLiteralSource(value) {
+            // TypeScript namespace may export `function escapeNonAsciiString(s: string, quoteChar?: CharacterCodes.doubleQuote | CharacterCodes.singleQuote | CharacterCodes.backtick): string`
+            return 'escapeNonAsciiString' in tsInstance
+                ? `"${tsInstance.escapeNonAsciiString(value, 'CharacterCodes' in tsInstance
+                    ? tsInstance.CharacterCodes
+                        .doubleQuote
+                    : 34 /* doubleQuote */)}"`
+                : JSON.stringify(value);
+        },
+        getLineStarts(sourceFile) {
+            return sourceFile.getLineStarts();
+        },
+    };
+}
+export function printSource(sourceFile, tsInstance) {
+    const _ts = tsInstance ?? tsNamespace;
+    return printSourceWithProxy(sourceFile, makeLspProxy(_ts, null, null));
+}
+export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap, tsInstance) {
+    const _ts = tsInstance ?? tsNamespace;
+    return printSourceWithMapWithProxy(sourceFile, originalSourceName, makeLspProxy(_ts, null, null), startOfSourceMap);
+}
+export function transformSource(sourceFile, lspClient, getSourceFile, options) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeLspProxy(ts, lspClient, getSourceFile);
+    return transformSourceWithProxy(sourceFile, proxy, undefined, options);
+}
+export function transformAndPrintSource(sourceFile, lspClient, getSourceFile, options) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeLspProxy(ts, lspClient, getSourceFile);
+    return transformAndPrintSourceWithProxy(sourceFile, proxy, undefined, options);
+}
+export function transformAndPrintSourceWithMap(sourceFile, lspClient, getSourceFile, originalSourceName, options, startOfSourceMap) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeLspProxy(ts, lspClient, getSourceFile);
+    return transformAndPrintSourceWithMapWithProxy(sourceFile, proxy, undefined, originalSourceName, options, startOfSourceMap);
+}

package/dist/transform.d.mts

@@ -1,5 +1,6 @@
 import * as sourceMap from 'source-map';
 import type * as ts from 'typescript';
+import type { ApiProxy, ProxyTypes } from './TsProxy.mjs';
 export interface TransformOptions {
     /** `typescript` namespace object */
     ts?: typeof ts;
@@ -21,6 +22,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.
@@ -36,8 +39,8 @@ export interface TransformOptions {
     ignoreFiles?: ReadonlyArray<string | RegExp> | ((fileName: string) => boolean);
 }
 export declare function getIgnoreFilesFunction(ignoreFiles: TransformOptions['ignoreFiles']): (fileName: string) => boolean;
-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];
+export declare function transformSourceWithProxy<TTransformationContext = void>(sourceFile: ProxyTypes.SourceFile, proxy: ApiProxy<TTransformationContext>, context: TTransformationContext | undefined, options?: TransformOptions): ProxyTypes.SourceFile;
+export declare function printSourceWithProxy<TTransformationContext = void>(sourceFile: ProxyTypes.SourceFile, proxy: ApiProxy<TTransformationContext>): string;
+export declare function printSourceWithMapWithProxy<TTransformationContext = void>(sourceFile: ProxyTypes.SourceFile, originalSourceName: string, proxy: ApiProxy<TTransformationContext>, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];
+export declare function transformAndPrintSourceWithProxy<TTransformationContext = void>(sourceFile: ProxyTypes.SourceFile, proxy: ApiProxy<TTransformationContext>, context: TTransformationContext | undefined, options?: TransformOptions): string;
+export declare function transformAndPrintSourceWithMapWithProxy<TTransformationContext = void>(sourceFile: ProxyTypes.SourceFile, proxy: ApiProxy<TTransformationContext>, context: TTransformationContext | undefined, originalSourceName: string, options?: TransformOptions, startOfSourceMap?: sourceMap.RawSourceMap): [string, sourceMap.RawSourceMap];