ts-const-value-transformer 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## v0.4.0
+
+Add `unsafeHoistWritableValues` option to prevent from hoisting non-const values with literal type unexpectedly
+
+## v0.3.0
+
+Add `externalNames` option for `hoistExternalValues`
+
 ## v0.2.1
 
 Fix for tracing imported symbol

package/README.md

@@ -160,6 +160,14 @@ export interface TransformOptions {
   hoistPureFunctionCall?: boolean | undefined;
   /** Hoist expressions with `as XXX`. Default is false because the base (non-`as`) value may be non-constant. */
   unsafeHoistAsExpresion?: boolean | undefined;
+  /** Hoist properties/variables that can write (i.e. `let` / `var` variables or properies without `readonly`). Default is false because although the value is literal type at some point, the value may change to another literal type. */
+  unsafeHoistWritableValues?: 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.
+   * - Default is `['/node_modules/']`.
+   */
+  externalNames?: ReadonlyArray<string | RegExp> | undefined;
 }
 ```
 
@@ -247,6 +255,21 @@ The version string of this package.
 
 See [Transform options](#transform-options).
 
+## Notice
+
+Starting from v0.4.0, `unsafeHoistWritableValues` option is introduced. Since TypeScript sometimes narrows non-constant values to literal types such as:
+
+```ts
+const resultObject = { success: false };
+someFunc1(resultObject);
+console.log(resultObject.success); // resultObject.success will be `boolean` type
+resultObject.success = false;
+someFunc1(resultObject);
+console.log(resultObject.success); // resultObject.success will be `false` type, not `boolean`
+```
+
+... so if `unsafeHoistWritableValues` is true, the second reference of `resultObject.success` above will be replaced to `false`, which may not be correct.
+
 ## Additional notes
 
 I think there should be more optimization methods by using strictly-typed information, like other programming languages.

package/dist/transform.d.mts

@@ -15,6 +15,14 @@ export interface TransformOptions {
     hoistPureFunctionCall?: boolean | undefined;
     /** Hoist expressions with `as XXX`. Default is false because the base (non-`as`) value may be non-constant. */
     unsafeHoistAsExpresion?: boolean | undefined;
+    /** Hoist properties/variables that can write (i.e. `let` / `var` variables or properies without `readonly`). Default is false because although the value is literal type at some point, the value may change to another literal type. */
+    unsafeHoistWritableValues?: 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.
+     * - Default is `['/node_modules/']`.
+     */
+    externalNames?: ReadonlyArray<string | RegExp> | undefined;
 }
 export declare function transformSource(sourceFile: ts.SourceFile, program: ts.Program, context: ts.TransformationContext, options?: TransformOptions): ts.SourceFile;
 export declare function printSource(sourceFile: ts.SourceFile): string;

package/dist/transform.mjs

@@ -11,6 +11,8 @@ function assignDefaultValues(options = {}) {
         unsafeHoistAsExpresion: options.unsafeHoistAsExpresion ?? false,
         hoistPureFunctionCall: options.hoistPureFunctionCall ?? false,
         unsafeHoistFunctionCall: options.unsafeHoistFunctionCall ?? false,
+        unsafeHoistWritableValues: options.unsafeHoistWritableValues ?? false,
+        externalNames: options.externalNames ?? [],
     };
 }
 ////////////////////////////////////////////////////////////////////////////////
@@ -55,7 +57,8 @@ function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options
             return node;
         }
     }
-    if (!options.hoistExternalValues && isExternalReference(node, program)) {
+    if (!options.hoistExternalValues &&
+        isExternalReference(node, program, options.externalNames)) {
         return node;
     }
     if (ts.isIdentifier(node)) {
@@ -65,9 +68,7 @@ function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options
             (!ts.isExpression(node.parent) &&
                 (!('initializer' in node.parent) ||
                     node !== node.parent.initializer)) ||
-            (!options.hoistProperty &&
-                ts.isPropertyAccessExpression(node.parent) &&
-                node === node.parent.name)) {
+            (ts.isPropertyAccessExpression(node.parent) && node === node.parent.name)) {
             return node;
         }
     }
@@ -76,6 +77,12 @@ function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options
             hasParentAsExpression(node.parent, context, ts))) {
         return node;
     }
+    if (!options.unsafeHoistWritableValues) {
+        const r = isReadonlyExpression(node, program, ts);
+        if (r === false) {
+            return node;
+        }
+    }
     try {
         const typeChecker = program.getTypeChecker();
         const type = typeChecker.getTypeAtLocation(node);
@@ -132,13 +139,28 @@ function isEnumIdentifier(node, program, tsInstance) {
     const type = typeChecker.getTypeAtLocation(node);
     return (type.getFlags() & ts.TypeFlags.EnumLiteral) !== 0;
 }
-function isExternalReference(node, program) {
+function isExternalReference(node, program, externalNames) {
     const typeChecker = program.getTypeChecker();
     const nodeSym = typeChecker.getSymbolAtLocation(node);
     let nodeFrom = nodeSym?.getDeclarations()?.[0];
     while (nodeFrom) {
-        if (program.isSourceFileFromExternalLibrary(nodeFrom.getSourceFile())) {
-            return true;
+        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 (!ts.isImportSpecifier(nodeFrom)) {
@@ -216,6 +238,85 @@ function hasPureAnnotation(node, sourceFile, tsInstance) {
     }
     return false;
 }
+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);
+    const memberName = a.name.getText();
+    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 && 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;
+            }
+        }
+    }
+    return false;
+}
+function isReadonlyExpression(node, program, tsInstance) {
+    const ts = tsInstance;
+    const typeChecker = program.getTypeChecker();
+    if (ts.isIdentifier(node) &&
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        node.parent &&
+        !ts.isPropertyAccessExpression(node.parent)) {
+        const nodeSym = typeChecker.getSymbolAtLocation(node);
+        if (nodeSym?.valueDeclaration) {
+            if (ts.isVariableDeclarationList(nodeSym.valueDeclaration.parent)) {
+                if (nodeSym.valueDeclaration.parent.flags & ts.NodeFlags.Const) {
+                    return true;
+                }
+                return false;
+            }
+        }
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        if (isEnumAccess(node, program, ts)) {
+            return true;
+        }
+        return isReadonlyPropertyAccess(node, typeChecker, ts);
+    }
+    return null;
+}
 ////////////////////////////////////////////////////////////////////////////////
 export function printSource(sourceFile) {
     return printSourceImpl(sourceFile)[0];

package/dist/version.d.mts

@@ -1,2 +1,2 @@
-declare const _default: "0.2.1";
+declare const _default: "0.4.0";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.2.1';
+export default '0.4.0';

package/package.json

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