ts-const-value-transformer 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v0.5.0
+
+- Add `useUndefinedSymbolForUndefinedValue` and `hoistUndefinedSymbol` options
+- Add `createPortalTransformer` to use transformer easily
+- Skip update process if unchanged
+- Skip some declarations for performance
+- Add hoisting computed property name
+- Add test for element access
+- Avoid hosting indexed property access
+- Add test case for OmittedExpression and SatisfiesExpression
+- Refactor to avoid handling unexpected expressions
+
 ## v0.4.1
 
 Fix for not hositing some more unary expressions and parenthesized expression

package/README.md

@@ -162,12 +162,25 @@ export interface TransformOptions {
   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;
+  /** Uses `undefined` symbol for `undefined` type values. Default is false and replaces to `void 0`. */
+  useUndefinedSymbolForUndefinedValue?: boolean | undefined;
+  /** Hoist `undefined` symbol to `void 0` (or `undefined` if useUndefinedSymbolForUndefinedValue is true). Default is true. */
+  hoistUndefinedSymbol?: 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;
+  /**
+   * Specifies for file name list or function to skip transformation. This option is used by webpack loader, the transformed called from ts-loader, and createPortalTransformer only.
+   * - For list, if the token is `string`, the transformation will be skipped if `fileName.indexOf(token) >= 0` is true.
+   *   If the token is `RegExp`, the transformation will be skipped if `fileName.indexOf(token) >= 0` is true.
+   * - For function, the transformation will be skipped if `fn(fileName)` is true.
+   */
+  ignoreFiles?:
+    | ReadonlyArray<string | RegExp>
+    | ((fileName: string) => boolean);
 }
 ```
 
@@ -183,6 +196,10 @@ import {
   transformSource,
   version,
   type TransformOptions,
+  createPortalTransformer,
+  createPortalTransformerSync,
+  type CreatePortalTransformerOptions,
+  type PortalTransformer,
 } from 'ts-const-value-transformer';
 ```
 
@@ -245,7 +262,7 @@ Prints (generates) source code from `SourceFile`, along with raw source-map data
 
 #### 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` instead.
+Transforms the source file with TypeScript project. You don't need to call this function directly; use `createTransformer` or `createPortalTransformer` instead.
 
 #### version: string
 
@@ -255,6 +272,15 @@ The version string of this package.
 
 See [Transform options](#transform-options).
 
+#### createPortalTransformer: (options?: CreatePortalTransformerOptions) => Promise<PortalTransformer>
+
+Creates 'portal transformer', which can be used the transformer easily from the code which does not use TypeScript Compiler API.  
+The return object has `transform` method with signature: `(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions) => [newSource: string, newSourceMap: RawSourceMap | undefined]`. You can call to transform TypeScript source code. (Note that this API does not transpile to JavaScript; the output code is still TypeScript code.)
+
+`CreatePortalTransformerOptions` has three optional options: `project` (path to tsconfig.json), `typescript` (package path to `typescript` or `typescript` namespace object), and `cwd` (current directory for file search). Also, `ignoreFiles` can be used.
+
+If `Promise` cannot be used for some reason, use `createPortalTransformerSync` instead.
+
 ## Notice
 
 Starting from v0.4.0, `unsafeHoistWritableValues` option is introduced. Since TypeScript sometimes narrows non-constant values to literal types such as:

package/dist/createPortalTransformer.d.mts

@@ -0,0 +1,42 @@
+import type { RawSourceMap } from 'source-map';
+import type * as tsNamespace from 'typescript';
+import { type TransformOptions } from './transform.mjs';
+export interface CreatePortalTransformerOptions extends TransformOptions {
+    project?: string;
+    typescript?: string | typeof tsNamespace;
+    cwd?: string;
+}
+export interface PortalTransformer {
+    /** The `typescript` namespace object */
+    readonly ts: typeof tsNamespace;
+    /** Active `Program` instance for the transformer */
+    readonly program: tsNamespace.Program;
+    /**
+     * Performs transformation.
+     * @param content Base source code. If null, uses loaded source code in the TS project.
+     * @param fileName Base file name (If not included in the TS project, transformation will not be performed.)
+     * @param sourceMap Base source map if exists
+     * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
+     * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
+     */
+    transform(content: string, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): [newSource: string, newSourceMap: RawSourceMap | undefined];
+    /**
+     * Performs transformation.
+     * @param content Base source code. If null, uses loaded source code in the TS project.
+     * @param fileName Base file name (If not included in the TS project, transformation will not be performed.)
+     * @param sourceMap Base source map if exists
+     * @param options Transform options (addition to `options` passed to `createPortalTransformer`)
+     * @returns Tuple of new source code and source map. Source map may be undefined if source code is unchanged.
+     */
+    transform(content: string | null, fileName: string, sourceMap?: string | RawSourceMap | null, options?: TransformOptions): [newSource: string | null, newSourceMap: RawSourceMap | undefined];
+}
+/**
+ * Creates the new portal transformer instance for the TS project.
+ * After creation, the transformation process can be performed by calling {@link PortalTransformer.transform}.
+ */
+export default function createPortalTransformer(options?: CreatePortalTransformerOptions): Promise<PortalTransformer>;
+/**
+ * Creates the new portal transformer instance for the TS project (using `require` function).
+ * After creation, the transformation process can be performed by calling {@link PortalTransformer.transform}.
+ */
+export declare function createPortalTransformerSync(options?: CreatePortalTransformerOptions): PortalTransformer;

package/dist/createPortalTransformer.mjs

@@ -0,0 +1,126 @@
+import * as fs from 'fs';
+import { createRequire } from 'module';
+import * as path from 'path';
+import createTransformer from './createTransformer.mjs';
+import { printSourceWithMap } from './transform.mjs';
+const require = createRequire(import.meta.url);
+function createPortalTransformerImpl(options, ts) {
+    const project = options.project ?? 'tsconfig.json';
+    let ignoreFiles = options.ignoreFiles ?? [];
+    if (typeof ignoreFiles !== 'function') {
+        const a = ignoreFiles;
+        ignoreFiles = (fileName) => {
+            return a.some((t) => {
+                if (typeof t === 'string') {
+                    return fileName.indexOf(t) >= 0;
+                }
+                else {
+                    return t.test(fileName);
+                }
+            });
+        };
+    }
+    const cwd = options.cwd ?? process.cwd();
+    const getCurrentDirectory = () => cwd;
+    const config = ts.getParsedCommandLineOfConfigFile(project, void 0, {
+        fileExists: fs.existsSync,
+        getCurrentDirectory,
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        readDirectory: ts.sys.readDirectory,
+        readFile: (file) => fs.readFileSync(path.isAbsolute(file) ? file : path.join(getCurrentDirectory(), file), 'utf-8'),
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        onUnRecoverableConfigFileDiagnostic: (diag) => {
+            throw new Error(ts.formatDiagnostics([diag], {
+                getCanonicalFileName: (f) => f,
+                getCurrentDirectory,
+                getNewLine: () => '\n',
+            }));
+        },
+    });
+    if (!config) {
+        throw new Error(`[ts-const-value-transformer] Unable to load tsconfig file (effective name = '${project}')`);
+    }
+    const program = ts.createProgram({
+        options: config.options,
+        rootNames: config.fileNames,
+    });
+    return {
+        ts,
+        program,
+        transform: (content, fileName, sourceMap, individualOptions) => {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const rawSourceMap = typeof sourceMap === 'string'
+                ? JSON.parse(sourceMap)
+                : (sourceMap ?? void 0);
+            if (ignoreFiles(fileName)) {
+                return [content, rawSourceMap];
+            }
+            const sourceFile = program.getSourceFile(fileName);
+            if (!sourceFile) {
+                return [content, rawSourceMap];
+            }
+            // If input content is changed, replace it
+            if (content != null && sourceFile.getFullText() !== content) {
+                sourceFile.update(content, {
+                    span: { start: 0, length: sourceFile.end },
+                    newLength: content.length,
+                });
+            }
+            const transformer = createTransformer(program, {
+                options: { ...options, ...individualOptions, ts },
+            });
+            const result = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
+            const transformedSource = result.transformed[0];
+            // If unchanged, return base file as-is
+            if (transformedSource === sourceFile) {
+                return [content ?? sourceFile.getFullText(), rawSourceMap];
+            }
+            const printed = printSourceWithMap(transformedSource, fileName, rawSourceMap);
+            return printed;
+        },
+    };
+}
+/**
+ * Creates the new portal transformer instance for the TS project.
+ * After creation, the transformation process can be performed by calling {@link PortalTransformer.transform}.
+ */
+export default async function createPortalTransformer(options = {}) {
+    let ts;
+    if (options.typescript != null) {
+        if (typeof options.typescript === 'string') {
+            ts = (await import(options.typescript));
+        }
+        else {
+            ts = options.typescript;
+        }
+    }
+    else if (options.ts != null) {
+        ts = options.ts;
+    }
+    else {
+        ts = await import('typescript');
+    }
+    return createPortalTransformerImpl(options, ts);
+}
+/**
+ * Creates the new portal transformer instance for the TS project (using `require` function).
+ * After creation, the transformation process can be performed by calling {@link PortalTransformer.transform}.
+ */
+export function createPortalTransformerSync(options = {}) {
+    let ts;
+    if (options.typescript != null) {
+        if (typeof options.typescript === 'string') {
+            ts = require(options.typescript);
+        }
+        else {
+            ts = options.typescript;
+        }
+    }
+    else if (options.ts != null) {
+        ts = options.ts;
+    }
+    else {
+        ts = require('typescript');
+    }
+    return createPortalTransformerImpl(options, ts);
+}

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -1,4 +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 { createTransformer, version };
+export { createPortalTransformer, createPortalTransformerSync, createTransformer, version, };

package/dist/loader.d.mts

@@ -1,6 +1,6 @@
 import type * as tsNamespace from 'typescript';
 import type * as webpack from 'webpack';
-import { type TransformOptions } from './transform.mjs';
+import type { TransformOptions } from './transform.mjs';
 export interface TsConstValueTransformerLoaderOptions extends TransformOptions {
     project?: string;
     typescript?: string | typeof tsNamespace;

package/dist/loader.mjs

@@ -1,74 +1,22 @@
-import * as fs from 'fs';
 import * as path from 'path';
-import createTransformer from './createTransformer.mjs';
-import { printSourceWithMap } from './transform.mjs';
-const programMap = new Map();
+import createPortalTransformer, {} from './createPortalTransformer.mjs';
+const transformerMap = new Map();
 const loader = function (content, sourceMap) {
     this.async();
     void (async () => {
         try {
             const options = this.getOptions() || {};
-            let ts;
-            if (options.typescript != null) {
-                if (typeof options.typescript === 'string') {
-                    ts = (await import(options.typescript));
-                }
-                else {
-                    ts = options.typescript;
-                }
-            }
-            else if (options.ts != null) {
-                ts = options.ts;
-            }
-            else {
-                ts = await import('typescript');
-            }
             const project = options.project ?? 'tsconfig.json';
-            let program = programMap.get(project);
-            if (!program) {
-                const getCurrentDirectory = () => path.dirname(this.resourcePath);
-                const config = ts.getParsedCommandLineOfConfigFile(project, void 0, {
-                    fileExists: fs.existsSync,
-                    getCurrentDirectory,
-                    // eslint-disable-next-line @typescript-eslint/unbound-method
-                    readDirectory: ts.sys.readDirectory,
-                    readFile: (file) => fs.readFileSync(path.isAbsolute(file)
-                        ? file
-                        : path.join(getCurrentDirectory(), file), 'utf-8'),
-                    useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
-                    onUnRecoverableConfigFileDiagnostic: (diag) => {
-                        throw new Error(ts.formatDiagnostics([diag], {
-                            getCanonicalFileName: (f) => f,
-                            getCurrentDirectory,
-                            getNewLine: () => '\n',
-                        }));
-                    },
+            let transformer = transformerMap.get(project);
+            if (!transformer) {
+                transformer = await createPortalTransformer({
+                    ...options,
+                    cwd: path.dirname(this.resourcePath),
                 });
-                if (!config) {
-                    throw new Error(`[ts-const-value-transformer-loader] Unable to load tsconfig file (effective name = '${project}')`);
-                }
-                program = ts.createProgram({
-                    options: config.options,
-                    rootNames: config.fileNames,
-                });
-                programMap.set(project, program);
-            }
-            const sourceFile = program.getSourceFile(this.resource);
-            if (!sourceFile) {
-                throw new Error(`'${this.resource}' is not in the TypeScript project.`);
+                transformerMap.set(project, transformer);
             }
-            sourceFile.update(content, {
-                span: { start: 0, length: sourceFile.end },
-                newLength: content.length,
-            });
-            const transformer = createTransformer(program, {
-                options: { ...options, ts },
-            });
-            const result = ts.transform(sourceFile, [transformer], program.getCompilerOptions());
-            const printed = printSourceWithMap(result.transformed[0], this.resource, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            typeof sourceMap === 'string' ? JSON.parse(sourceMap) : sourceMap);
-            this.callback(null, printed[0], printed[1]);
+            const result = transformer.transform(content, this.resource, sourceMap);
+            this.callback(null, result[0], result[1]);
         }
         catch (e) {
             this.callback(e);

package/dist/transform.d.mts

@@ -17,12 +17,23 @@ export interface TransformOptions {
     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;
+    /** Uses `undefined` symbol for `undefined` type values. Default is false and replaces to `void 0`. */
+    useUndefinedSymbolForUndefinedValue?: boolean | undefined;
+    /** Hoist `undefined` symbol to `void 0` (or `undefined` if {@linkcode useUndefinedSymbolForUndefinedValue} is true). Default is true. */
+    hoistUndefinedSymbol?: 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;
+    /**
+     * Specifies for file name list or function to skip transformation. This option is used by webpack loader, the transformed called from ts-loader, and {@link createPortalTransformer} only.
+     * - For list, if the token is `string`, the transformation will be skipped if `fileName.indexOf(token) >= 0` is true.
+     *   If the token is `RegExp`, the transformation will be skipped if `fileName.indexOf(token) >= 0` is true.
+     * - For function, the transformation will be skipped if `fn(fileName)` is true.
+     */
+    ignoreFiles?: ReadonlyArray<string | RegExp> | ((fileName: string) => boolean);
 }
 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

@@ -12,77 +12,87 @@ function assignDefaultValues(options = {}) {
         hoistPureFunctionCall: options.hoistPureFunctionCall ?? false,
         unsafeHoistFunctionCall: options.unsafeHoistFunctionCall ?? false,
         unsafeHoistWritableValues: options.unsafeHoistWritableValues ?? false,
+        useUndefinedSymbolForUndefinedValue: options.useUndefinedSymbolForUndefinedValue ?? false,
+        hoistUndefinedSymbol: options.hoistUndefinedSymbol ?? true,
         externalNames: options.externalNames ?? [],
+        ignoreFiles: options.ignoreFiles ?? [],
     };
 }
 ////////////////////////////////////////////////////////////////////////////////
 export function transformSource(sourceFile, program, context, options) {
-    return visitNodeChildren(sourceFile, sourceFile, program, context, assignDefaultValues(options));
+    return visitNodeChildren(sourceFile, sourceFile, sourceFile, program, context, assignDefaultValues(options));
 }
-function visitNodeChildren(node, sourceFile, program, context, options) {
-    const newNode = visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options);
+function visitNodeChildren(node, parent, sourceFile, program, context, options) {
+    const newNode = visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context, options);
     if (newNode[SYMBOL_ORIGINAL_NODE]) {
         return newNode;
     }
-    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, sourceFile, program, context, options), context);
+    // skip children for satisifes expression
+    if (ts.isSatisfiesExpression(newNode)) {
+        return newNode;
+    }
+    // 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)) {
+        return newNode;
+    }
+    return ts.visitEachChild(newNode, (node) => visitNodeChildren(node, newNode, sourceFile, program, context, options), context);
 }
-function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options) {
+function visitNodeAndReplaceIfNeeded(node, parent, sourceFile, program, context, options) {
     const ts = options.ts;
-    if (!ts.isExpression(node) && !ts.isIdentifier(node)) {
-        return node;
+    if (ts.isCallLikeExpression(node)) {
+        if (!ts.isExpression(node) ||
+            (!options.unsafeHoistFunctionCall &&
+                (!options.hoistPureFunctionCall ||
+                    !hasPureAnnotation(node, sourceFile, ts)))) {
+            return node;
+        }
     }
-    if (ts.isLiteralExpression(node) ||
-        ts.isObjectLiteralExpression(node) ||
-        // UnaryExpression start
-        ts.isPrefixUnaryExpression(node) ||
-        ts.isPostfixUnaryExpression(node) ||
-        ts.isDeleteExpression(node) ||
-        ts.isTypeOfExpression(node) ||
-        ts.isVoidExpression(node) ||
-        ts.isAwaitExpression(node) ||
-        ts.isTypeAssertionExpression(node) ||
-        // UnaryExpression end
-        ts.isBinaryExpression(node) ||
-        ts.isParenthesizedExpression(node) ||
-        ts.isConditionalExpression(node) ||
-        ts.isVoidExpression(node) ||
-        ts.isSpreadElement(node) ||
-        (!options.hoistProperty &&
-            ts.isPropertyAccessExpression(node) &&
-            !isEnumAccess(node, program, ts)) ||
-        (!options.hoistEnumValues &&
-            ((ts.isPropertyAccessExpression(node) &&
-                isEnumAccess(node, program, ts)) ||
-                (ts.isIdentifier(node) && isEnumIdentifier(node, program, ts)))) ||
-        node.kind === ts.SyntaxKind.TrueKeyword ||
-        node.kind === ts.SyntaxKind.FalseKeyword ||
-        node.kind === ts.SyntaxKind.NullKeyword) {
-        return node;
+    else if (ts.isIdentifier(node)) {
+        if (!ts.isComputedPropertyName(parent) &&
+            ((!ts.isExpression(parent) &&
+                (!('initializer' in parent) || node !== parent.initializer)) ||
+                (ts.isPropertyAccessExpression(parent) && node === parent.name))) {
+            return node;
+        }
+        if (!options.hoistEnumValues && isEnumIdentifier(node, program, ts)) {
+            return node;
+        }
+        if (!options.hoistUndefinedSymbol &&
+            isUndefinedIdentifier(node, parent, program, ts)) {
+            return node;
+        }
     }
-    if (!options.unsafeHoistFunctionCall &&
-        (!options.hoistPureFunctionCall || !hasPureAnnotation(node, sourceFile, ts))) {
-        if (ts.isCallLikeExpression(node)) {
+    else if (ts.isPropertyAccessExpression(node) ||
+        ts.isElementAccessExpression(node)) {
+        if (!isHoistablePropertyAccess(node, program, ts)) {
             return node;
         }
+        if ((!options.hoistProperty && !isEnumAccess(node, program, ts)) ||
+            (!options.hoistEnumValues &&
+                (isEnumAccess(node, program, ts) ||
+                    (ts.isIdentifier(node) && isEnumIdentifier(node, program, ts))))) {
+            return node;
+        }
+    }
+    else if (ts.isAsExpression(node)) {
+        if (!options.unsafeHoistAsExpresion) {
+            return node;
+        }
+    }
+    else {
+        return node;
     }
     if (!options.hoistExternalValues &&
         isExternalReference(node, program, options.externalNames)) {
         return node;
     }
-    if (ts.isIdentifier(node)) {
-        if (
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        !node.parent ||
-            (!ts.isExpression(node.parent) &&
-                (!('initializer' in node.parent) ||
-                    node !== node.parent.initializer)) ||
-            (ts.isPropertyAccessExpression(node.parent) && node === node.parent.name)) {
-            return node;
-        }
-    }
     if (!options.unsafeHoistAsExpresion &&
         (hasAsExpression(node, context, ts) ||
-            hasParentAsExpression(node.parent, context, ts))) {
+            hasParentAsExpression(parent, context, ts))) {
         return node;
     }
     if (!options.unsafeHoistWritableValues) {
@@ -96,6 +106,9 @@ function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options
         const type = typeChecker.getTypeAtLocation(node);
         const flags = type.getFlags();
         let newNode;
+        if (type.isUnionOrIntersection()) {
+            return node;
+        }
         if (type.isStringLiteral()) {
             newNode = context.factory.createStringLiteral(type.value);
         }
@@ -121,7 +134,12 @@ function visitNodeAndReplaceIfNeeded(node, sourceFile, program, context, options
             newNode = context.factory.createNull();
         }
         else if (flags & ts.TypeFlags.Undefined) {
-            newNode = context.factory.createVoidZero();
+            if (options.useUndefinedSymbolForUndefinedValue) {
+                newNode = context.factory.createIdentifier('undefined');
+            }
+            else {
+                newNode = context.factory.createVoidZero();
+            }
         }
         else {
             return node;
@@ -224,7 +242,8 @@ function hasParentAsExpression(node, context, tsInstance) {
     if (ts.isAsExpression(node) && !isAsConstExpression(node)) {
         return true;
     }
-    if (ts.isPropertyAccessExpression(node)) {
+    if (ts.isPropertyAccessExpression(node) ||
+        ts.isElementAccessExpression(node)) {
         if (hasAsExpression(node.expression, context, ts)) {
             return true;
         }
@@ -246,6 +265,13 @@ function hasPureAnnotation(node, sourceFile, tsInstance) {
     }
     return false;
 }
+function getNameFromElementAccessExpression(node, typeChecker) {
+    const type = typeChecker.getTypeAtLocation(node.argumentExpression);
+    if (type.isStringLiteral() || type.isNumberLiteral()) {
+        return `${type.value}`;
+    }
+    return null;
+}
 function getMemberName(m, tsInstance) {
     if (!m || !m.name) {
         return '';
@@ -267,7 +293,12 @@ function getMemberName(m, tsInstance) {
 function isReadonlyPropertyAccess(a, typeChecker, tsInstance) {
     const ts = tsInstance;
     const type = typeChecker.getTypeAtLocation(a.expression);
-    const memberName = a.name.getText();
+    const memberName = ts.isPropertyAccessExpression(a)
+        ? a.name.getText()
+        : getNameFromElementAccessExpression(a, typeChecker);
+    if (memberName == null) {
+        return false;
+    }
     if (type.getFlags() & ts.TypeFlags.Object) {
         const dummyTypeNode = typeChecker.typeToTypeNode(type, a, ts.NodeBuilderFlags.NoTruncation);
         if (dummyTypeNode && ts.isTypeLiteralNode(dummyTypeNode)) {
@@ -317,7 +348,8 @@ function isReadonlyExpression(node, program, tsInstance) {
             }
         }
     }
-    if (ts.isPropertyAccessExpression(node)) {
+    if (ts.isPropertyAccessExpression(node) ||
+        ts.isElementAccessExpression(node)) {
         if (isEnumAccess(node, program, ts)) {
             return true;
         }
@@ -325,6 +357,42 @@ function isReadonlyExpression(node, program, tsInstance) {
     }
     return null;
 }
+function isHoistablePropertyAccess(a, program, tsInstance) {
+    const ts = tsInstance;
+    const typeChecker = program.getTypeChecker();
+    const type = typeChecker.getTypeAtLocation(a.expression);
+    const memberName = ts.isPropertyAccessExpression(a)
+        ? a.name.getText()
+        : getNameFromElementAccessExpression(a, typeChecker);
+    if (memberName == null) {
+        return false;
+    }
+    if (type.getFlags() & ts.TypeFlags.Object) {
+        const prop = type.getProperty(memberName);
+        // If the property access uses indexed access, `prop` will be undefined
+        if (prop) {
+            return true;
+        }
+    }
+    return false;
+}
+function isUndefinedIdentifier(node, parent, program, tsInstance) {
+    if (tsInstance.isPropertyAccessExpression(parent) ||
+        tsInstance.isElementAccessExpression(parent)) {
+        return false;
+    }
+    const typeChecker = program.getTypeChecker();
+    const type = typeChecker.getTypeAtLocation(node);
+    const sym = typeChecker.getSymbolAtLocation(node);
+    if (!sym || sym.getEscapedName().toString() !== 'undefined') {
+        return false;
+    }
+    if (type.isUnionOrIntersection() ||
+        !(type.getFlags() & ts.TypeFlags.Undefined)) {
+        return false;
+    }
+    return true;
+}
 ////////////////////////////////////////////////////////////////////////////////
 export function printSource(sourceFile) {
     return printSourceImpl(sourceFile)[0];

package/dist/version.d.mts

@@ -1,2 +1,2 @@
-declare const _default: "0.4.1";
+declare const _default: "0.5.0";
 export default _default;

package/dist/version.mjs

@@ -1 +1 @@
-export default '0.4.1';
+export default '0.5.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-const-value-transformer",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "engines": {
     "node": ">=20.19.3"
   },
@@ -23,6 +23,16 @@
       "import": "./dist/createTransformer.mjs",
       "types": "./dist/createTransformer.d.mts"
     },
+    "./createPortalTransformer": {
+      "default": "./dist/createPortalTransformer.mjs",
+      "import": "./dist/createPortalTransformer.mjs",
+      "types": "./dist/createPortalTransformer.d.mts"
+    },
+    "./createPortalTransformer.mjs": {
+      "default": "./dist/createPortalTransformer.mjs",
+      "import": "./dist/createPortalTransformer.mjs",
+      "types": "./dist/createPortalTransformer.d.mts"
+    },
     "./getCustomTransformers": {
       "default": "./dist/getCustomTransformers.mjs",
       "import": "./dist/getCustomTransformers.mjs",