ts-const-value-transformer 0.9.0 → 0.10.0

package/dist/tscTransformer.mjs

@@ -0,0 +1,377 @@
+import * as tsNamespace from 'typescript';
+import { printSourceWithMapWithProxy, printSourceWithProxy, transformAndPrintSourceWithMapWithProxy, transformAndPrintSourceWithProxy, transformSourceWithProxy, } from './transform.mjs';
+function getNameFromElementAccessExpression(node, typeChecker) {
+    const type = typeChecker.getTypeAtLocation(node.argumentExpression);
+    if (type.isStringLiteral() || type.isNumberLiteral()) {
+        return `${type.value}`;
+    }
+    return null;
+}
+function makeTscProxy(tsInstance, program) {
+    const typeChecker = program && program.getTypeChecker();
+    const isEnumAccess = (node) => {
+        if (!typeChecker) {
+            return false;
+        }
+        const type = typeChecker.getTypeAtLocation(node);
+        return (type.getFlags() & tsInstance.TypeFlags.EnumLiteral) !== 0;
+    };
+    const isReadonlyPropertyAccess = (node) => {
+        if (!typeChecker) {
+            return false;
+        }
+        const type = typeChecker.getTypeAtLocation(node.expression);
+        const memberName = tsInstance.isPropertyAccessExpression(node)
+            ? node.name.getText()
+            : getNameFromElementAccessExpression(node, typeChecker);
+        if (memberName == null) {
+            return false;
+        }
+        if (type.getFlags() & tsInstance.TypeFlags.Object) {
+            const prop = type.getProperty(memberName);
+            if (prop) {
+                // Use internal but exported function to improve memory performance
+                if ('getCheckFlags' in tsInstance &&
+                    'CheckFlags' in tsInstance &&
+                    tsInstance.CheckFlags.Readonly != null) {
+                    const checkFlags = tsInstance.getCheckFlags(prop);
+                    if (checkFlags &
+                        tsInstance.CheckFlags.Readonly) {
+                        return true;
+                    }
+                }
+                if ('getDeclarationModifierFlagsFromSymbol' in tsInstance) {
+                    const modifierFlags = tsInstance.getDeclarationModifierFlagsFromSymbol(prop);
+                    if (modifierFlags & tsInstance.ModifierFlags.Readonly) {
+                        return true;
+                    }
+                }
+                if (prop.declarations && prop.declarations.length > 0) {
+                    const decl = prop.declarations[0];
+                    if (tsInstance.isPropertySignature(decl) &&
+                        decl.modifiers?.some((m) => m.kind === tsInstance.SyntaxKind.ReadonlyKeyword)) {
+                        return true;
+                    }
+                    if (tsInstance.isVariableDeclaration(decl) &&
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        decl.parent &&
+                        tsInstance.isVariableDeclarationList(decl.parent) &&
+                        decl.parent.flags & tsInstance.NodeFlags.Const) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    };
+    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) {
+            return typeChecker?.getTypeAtLocation(node);
+        },
+        isEnumLiteral(type) {
+            return ((type.getFlags() & tsInstance.TypeFlags.EnumLiteral) !== 0);
+        },
+        isStringLiteral(type) {
+            return type.isStringLiteral();
+        },
+        isNumberLiteral(type) {
+            return type.isNumberLiteral();
+        },
+        isBigIntLiteral(type) {
+            return ((type.getFlags() & tsInstance.TypeFlags.BigIntLiteral) !==
+                0);
+        },
+        isBooleanLiteral(type) {
+            return ((type.getFlags() & tsInstance.TypeFlags.BooleanLiteral) !==
+                0);
+        },
+        isNullType(type) {
+            return (type.getFlags() & tsInstance.TypeFlags.Null) !== 0;
+        },
+        isUndefinedType(type) {
+            return ((type.getFlags() & tsInstance.TypeFlags.Undefined) !== 0);
+        },
+        typeToString(type) {
+            return typeChecker?.typeToString(type) ?? '';
+        },
+        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.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.createVoidZero();
+            },
+        },
+        isEnumAccess(node) {
+            return isEnumAccess(node);
+        },
+        isEnumIdentifier(node) {
+            if (!typeChecker) {
+                return false;
+            }
+            const type = typeChecker.getTypeAtLocation(node);
+            return (type.getFlags() & tsInstance.TypeFlags.EnumLiteral) !== 0;
+        },
+        isExternalReference(node, externalNames) {
+            if (!typeChecker) {
+                return false;
+            }
+            const nodeSym = typeChecker.getSymbolAtLocation(node);
+            let nodeFrom = nodeSym?.getDeclarations()?.[0];
+            while (nodeFrom) {
+                const sourceFileName = nodeFrom.getSourceFile();
+                if (externalNames.length === 0) {
+                    if (/[\\/]node_modules[\\/]/.test(sourceFileName.fileName)) {
+                        return true;
+                    }
+                }
+                else {
+                    if (externalNames.some((part) => {
+                        if (typeof part === 'string') {
+                            return sourceFileName.fileName
+                                .replace(/\\/g, '/')
+                                .includes(part);
+                        }
+                        else {
+                            return part.test(sourceFileName.fileName);
+                        }
+                    })) {
+                        return true;
+                    }
+                }
+                // Walk into the 'import' variables
+                if (!tsInstance.isImportSpecifier(nodeFrom)) {
+                    break;
+                }
+                const baseName = nodeFrom.propertyName ?? nodeFrom.name;
+                const baseSym = typeChecker.getSymbolAtLocation(baseName);
+                // We must follow 'aliased' symbol for parsing the symbol which name is not changed from the exported symbol name
+                const exportedSym = baseSym && baseSym.getFlags() & tsInstance.SymbolFlags.Alias
+                    ? typeChecker.getAliasedSymbol(baseSym)
+                    : baseSym;
+                nodeFrom = exportedSym?.getDeclarations()?.[0];
+            }
+            const type = typeChecker.getTypeAtLocation(node);
+            const sym = type.getSymbol();
+            if (!sym) {
+                return false;
+            }
+            const def = sym.getDeclarations()?.[0];
+            if (!def) {
+                return false;
+            }
+            const typeDefinitionSource = def.getSourceFile();
+            if (program.isSourceFileFromExternalLibrary(typeDefinitionSource)) {
+                return true;
+            }
+            return false;
+        },
+        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) {
+            if (!typeChecker) {
+                return null;
+            }
+            const node = _node;
+            if (tsInstance.isIdentifier(node) &&
+                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                node.parent &&
+                !tsInstance.isPropertyAccessExpression(node.parent)) {
+                const nodeSym = typeChecker.getSymbolAtLocation(node);
+                if (nodeSym?.valueDeclaration) {
+                    let target = nodeSym.valueDeclaration;
+                    for (;;) {
+                        // Parameters are writable
+                        if (tsInstance.isParameter(target)) {
+                            return false;
+                        }
+                        if (tsInstance.isVariableDeclarationList(target)) {
+                            if (target.flags & tsInstance.NodeFlags.Const) {
+                                return true;
+                            }
+                            else {
+                                return false;
+                            }
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (!target.parent || target === target.parent) {
+                            return false;
+                        }
+                        target = target.parent;
+                    }
+                }
+            }
+            if (tsInstance.isPropertyAccessExpression(node) ||
+                tsInstance.isElementAccessExpression(node)) {
+                if (isEnumAccess(node)) {
+                    return true;
+                }
+                return isReadonlyPropertyAccess(node);
+            }
+            return null;
+        },
+        isHoistablePropertyAccess(_node) {
+            if (!typeChecker) {
+                return false;
+            }
+            const node = _node;
+            const type = typeChecker.getTypeAtLocation(node.expression);
+            const memberName = tsInstance.isPropertyAccessExpression(node)
+                ? node.name.getText()
+                : getNameFromElementAccessExpression(node, typeChecker);
+            if (memberName == null) {
+                return false;
+            }
+            if (type.getFlags() & tsInstance.TypeFlags.Object) {
+                const prop = type.getProperty(memberName);
+                // If the property access uses indexed access, `prop` will be undefined
+                if (prop) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        isUndefinedIdentifier(node, parent) {
+            if (!typeChecker) {
+                return false;
+            }
+            if (tsInstance.isPropertyAccessExpression(parent) ||
+                tsInstance.isElementAccessExpression(parent)) {
+                return false;
+            }
+            const type = typeChecker.getTypeAtLocation(node);
+            const sym = typeChecker.getSymbolAtLocation(node);
+            if (!sym || sym.getEscapedName().toString() !== 'undefined') {
+                return false;
+            }
+            if (type.isUnionOrIntersection() ||
+                !(type.getFlags() & tsInstance.TypeFlags.Undefined)) {
+                return false;
+            }
+            return true;
+        },
+        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, makeTscProxy(_ts, null));
+}
+export function printSourceWithMap(sourceFile, originalSourceName, startOfSourceMap, tsInstance) {
+    const _ts = tsInstance ?? tsNamespace;
+    return printSourceWithMapWithProxy(sourceFile, originalSourceName, makeTscProxy(_ts, null), startOfSourceMap);
+}
+export function transformSource(sourceFile, program, context, options) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeTscProxy(ts, program);
+    return transformSourceWithProxy(sourceFile, proxy, context, options);
+}
+export function transformAndPrintSource(sourceFile, program, context, options) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeTscProxy(ts, program);
+    return transformAndPrintSourceWithProxy(sourceFile, proxy, context, options);
+}
+export function transformAndPrintSourceWithMap(sourceFile, program, context, originalSourceName, options, startOfSourceMap) {
+    const ts = options?.ts ?? tsNamespace;
+    const proxy = makeTscProxy(ts, program);
+    return transformAndPrintSourceWithMapWithProxy(sourceFile, proxy, context, originalSourceName, options, startOfSourceMap);
+}

package/dist/version.d.mts

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

package/dist/version.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-const-value-transformer",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "engines": {
     "node": ">=20.19.3"
   },
@@ -33,6 +33,16 @@
       "import": "./dist/createPortalTransformer.mjs",
       "types": "./dist/createPortalTransformer.d.mts"
     },
+    "./createPortalTransformerWithTsLs": {
+      "default": "./dist/createPortalTransformerWithTsLs.mjs",
+      "import": "./dist/createPortalTransformerWithTsLs.mjs",
+      "types": "./dist/createPortalTransformerWithTsLs.d.mts"
+    },
+    "./createPortalTransformerWithTsLs.mjs": {
+      "default": "./dist/createPortalTransformerWithTsLs.mjs",
+      "import": "./dist/createPortalTransformerWithTsLs.mjs",
+      "types": "./dist/createPortalTransformerWithTsLs.d.mts"
+    },
     "./getCustomTransformers": {
       "default": "./dist/getCustomTransformers.mjs",
       "import": "./dist/getCustomTransformers.mjs",
@@ -96,6 +106,7 @@
     "@types/node": "~20.19.22",
     "@typescript-eslint/eslint-plugin": "^8.48.0",
     "@typescript-eslint/parser": "^8.48.0",
+    "@typescript/native-preview": "7.0.0-dev.20260211.1",
     "babel-loader": "^10.0.0",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
@@ -112,12 +123,14 @@
     "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"
   },
   "dependencies": {
-    "source-map": "^0.7.6"
+    "source-map": "^0.7.6",
+    "sync-child-process": "^1.0.2"
   }
 }