@eliasku/ts-transformers 0.0.8 → 0.0.9

package/README.md

@@ -3,7 +3,7 @@
 
 # @eliasku/ts-transformers
 
-TypeScript transformer for aggressive code minification through type-aware property renaming and const enum inlining.
+TypeScript transformer for aggressive code minification through type-aware property renaming.
 
 ## Important Requirement
 
@@ -24,7 +24,7 @@ Two-phase optimization pipeline:
 
 Based on type analysis, properties are categorized as:
 
-- **Public (External)**: Exported from entry points → **no prefix** (preserved)
+- **Public**: Exported from entry points → **no prefix** (preserved)
 - **Private**: Everything else → prefixed with `$_` (mangled by minifier)
 
 **Example:**
@@ -52,23 +52,7 @@ class A{publicApi(){},a(){},b=1}
 
 ### Const Enum Inlining
 
-Replaces const enum accesses with literal values and transforms declarations to remove codegen, but keep symbol to preserve default import/export flow.
-
-```typescript
-// Before
-const enum Status {
-  Active = 1,
-  Inactive = 0,
-}
-export const status = Status.Active;
-
-// After transformer
-export let Status: {};
-export const status = 1;
-
-// After minifier
-export const status=1;
-```
+TypeScript currently inlines const enums, if you use traditional compiler for production build. Check if you have option `isolatedModules: false` disabled in `tsconfig.json`.
 
 ## Usage
 
@@ -165,10 +149,6 @@ class AppComponent {
 }
 ```
 
-### inlineConstEnums (optional, default: true)
-
-Inline const enum values and transform declarations to preserve export/import flow.
-
 ## Complete Example
 
 ```typescript

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eliasku/ts-transformers",
   "description": "TypeScript transformer for code optimization",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -40,7 +40,6 @@
     "plugin",
     "transformer",
     "minify",
-    "const-enum",
     "treeshake",
     "mangle"
   ],

package/src/index.ts

@@ -1,6 +1,4 @@
 import ts from "typescript";
-export type { OptimizerOptions } from "./types";
-
 import { ExportsSymbolTree } from "./exports/tracker";
 import {
   getDeclarationsForSymbol,
@@ -16,25 +14,17 @@ import {
 } from "./utils/symbol-utils";
 import { getNodeJSDocComment } from "./utils/ast-utils";
 import { OptimizerOptions, defaultOptions, VisibilityType } from "./types";
-import { ConstEnumRegistry } from "./const-enum/registry";
-import { EnumEvaluator } from "./const-enum/evaluator";
-import { isConstEnumType } from "./const-enum/utils";
 import { LOGS } from "./config";
 
-export const optimizer = (
-  program: ts.Program,
-  config?: Partial<OptimizerOptions>,
-): ts.TransformerFactory<ts.SourceFile> => createTransformerFactory(program, config);
+export type { OptimizerOptions } from "./types";
 
-function createTransformerFactory(
+export const optimizer = (
   program: ts.Program,
   options?: Partial<OptimizerOptions>,
-): ts.TransformerFactory<ts.SourceFile> {
+): ts.TransformerFactory<ts.SourceFile> => {
   const fullOptions: OptimizerOptions = { ...defaultOptions, ...options };
   const typeChecker = program.getTypeChecker();
   const exportsSymbolTree = new ExportsSymbolTree(program, fullOptions.entrySourceFiles);
-  const constEnumRegistry = new ConstEnumRegistry(program);
-  const enumEvaluator = new EnumEvaluator();
 
   const cache = new Map<ts.Symbol, VisibilityType>();
 
@@ -45,16 +35,6 @@ function createTransformerFactory(
 
   return (context: ts.TransformationContext) => {
     function transformNode(node: ts.Node): ts.Node | undefined {
-      if (fullOptions.inlineConstEnums !== false) {
-        if (ts.isPropertyAccessExpression(node)) {
-          const inlined = tryInlineConstEnum(node);
-          if (inlined) {
-            ts.setOriginalNode(inlined, node);
-            return inlined;
-          }
-        }
-      }
-
       // const a = { node }
       if (ts.isShorthandPropertyAssignment(node)) {
         return handleShorthandPropertyAssignment(node);
@@ -636,77 +616,9 @@ function createTransformerFactory(
       return isSymbolClassMember(typeChecker.getSymbolAtLocation(node));
     }
 
-    function tryInlineConstEnum(node: ts.PropertyAccessExpression): ts.Expression | null {
-      const expressionType = typeChecker.getTypeAtLocation(node.expression);
-      if (!isConstEnumType(expressionType)) return null;
-
-      const enumSymbol = expressionType.symbol || expressionType.aliasSymbol;
-      if (!enumSymbol) return null;
-
-      const enumInfo = constEnumRegistry.getEnumInfo(enumSymbol);
-      if (!enumInfo) return null;
-
-      const memberValue = enumInfo.members.get(node.name.text)?.value;
-      if (memberValue === undefined || memberValue === null) return null;
-      const newNode = enumEvaluator.createLiteral(memberValue);
-
-      const r = ts.setOriginalNode(newNode, node);
-      ts.setSourceMapRange(newNode, ts.getSourceMapRange(node));
-      (newNode as any).symbol = (node as any).symbol; // eslint-disable-line @typescript-eslint/no-explicit-any
-      return r;
-    }
-
-    return (sourceFile: ts.SourceFile) => {
-      function handleEnumDeclaration(node: ts.EnumDeclaration): ts.EnumDeclaration | undefined {
-        if (fullOptions.inlineConstEnums === false) {
-          return node;
-        }
-        if (!hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
-          return node;
-        }
-
-        if (sourceFile.isDeclarationFile) {
-          return ts.factory.updateEnumDeclaration(
-            node,
-            node.modifiers?.filter((m) => m.kind !== ts.SyntaxKind.ConstKeyword),
-            node.name,
-            node.members,
-          );
-        }
-
-        return ts.factory.createVariableStatement(
-          [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-          ts.factory.createVariableDeclarationList(
-            [
-              ts.factory.createVariableDeclaration(
-                node.name, // Reuse enum name
-                undefined,
-                ts.factory.createTypeLiteralNode([]), // Empty object type: {}
-                undefined, // No initializer (empty declaration)
-              ),
-            ],
-            ts.NodeFlags.Let, // Sets the 'const' modifier
-          ),
-        ) as unknown as ts.EnumDeclaration;
-      }
-
-      function wrapTransformNode(node: ts.Node): ts.Node | undefined {
-        if (ts.isEnumDeclaration(node)) {
-          const result = handleEnumDeclaration(node);
-          if (result !== node) {
-            if (result) {
-              return transformNode(result);
-            }
-            return result;
-          }
-        }
-        return transformNode(node);
-      }
-
-      const wrappedTransformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
-        ts.visitEachChild(wrapTransformNode(node), wrappedTransformNodeAndChildren, context);
+    const transformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
+      ts.visitEachChild(transformNode(node), transformNodeAndChildren, context);
 
-      return wrappedTransformNodeAndChildren(sourceFile) as ts.SourceFile;
-    };
+    return (sourceFile: ts.SourceFile) => transformNodeAndChildren(sourceFile) as ts.SourceFile;
   };
-}
+};

package/src/types.ts

@@ -27,11 +27,6 @@ export interface OptimizerOptions {
    * A field is treated as "decorated" if itself or any its parent (on type level) has a decorator.
    */
   ignoreDecorated: boolean;
-
-  /**
-   * Whether to inline const enum values.
-   */
-  inlineConstEnums?: boolean;
 }
 
 export const enum VisibilityType {
@@ -44,5 +39,4 @@ export const defaultOptions: OptimizerOptions = {
   privatePrefix: "$_",
   publicJSDocTag: "public",
   ignoreDecorated: false,
-  inlineConstEnums: true,
 };

package/src/const-enum/evaluator.ts

@@ -1,158 +0,0 @@
-import ts from "typescript";
-
-export type EnumValue = string | number;
-
-export interface EvaluationContext {
-  localMembers: Map<string, EnumValue>;
-  allowEnumReferences: boolean;
-}
-
-export class EnumEvaluator {
-  private lastImplicitValue = -1;
-
-  reset(): void {
-    this.lastImplicitValue = -1;
-  }
-
-  evaluate(expr: ts.Expression, context: EvaluationContext): EnumValue {
-    if (ts.isPrefixUnaryExpression(expr)) {
-      return this.evaluateUnary(expr, context);
-    } else if (ts.isBinaryExpression(expr)) {
-      return this.evaluateBinary(expr, context);
-    } else if (ts.isStringLiteralLike(expr)) {
-      return expr.text;
-    } else if (ts.isNumericLiteral(expr)) {
-      return +expr.text;
-    } else if (ts.isParenthesizedExpression(expr)) {
-      return this.evaluate(expr.expression, context);
-    } else if (ts.isIdentifier(expr)) {
-      return this.evaluateIdentifier(expr, context);
-    } else if (
-      expr.kind === ts.SyntaxKind.TrueKeyword ||
-      expr.kind === ts.SyntaxKind.FalseKeyword ||
-      expr.kind === ts.SyntaxKind.NullKeyword
-    ) {
-      throw this.createError(expr, `Unsupported literal: ${ts.SyntaxKind[expr.kind]}`);
-    }
-
-    throw this.createError(expr, `Cannot evaluate expression: ${expr.getText()}`);
-  }
-
-  evaluateEnumMember(member: ts.EnumMember, context: EvaluationContext): EnumValue {
-    if (!member.initializer) {
-      return this.evaluateImplicitMember(member);
-    }
-
-    const value = this.evaluate(member.initializer, context);
-
-    if (typeof value === "number") {
-      this.lastImplicitValue = value;
-    }
-
-    return value;
-  }
-
-  private evaluateImplicitMember(member: ts.EnumMember): EnumValue {
-    const name = ts.isIdentifier(member.name) ? member.name.text : `<computed>`;
-    void name;
-
-    if (this.lastImplicitValue === -1) {
-      this.lastImplicitValue = 0;
-      return 0;
-    }
-
-    const nextValue = this.lastImplicitValue + 1;
-    this.lastImplicitValue = nextValue;
-    return nextValue;
-  }
-
-  createLiteral(value: EnumValue): ts.Expression {
-    if (typeof value === "string") {
-      return ts.factory.createStringLiteral(value);
-    } else {
-      if (value < 0) {
-        return ts.factory.createPrefixMinus(ts.factory.createNumericLiteral(Math.abs(value).toString()));
-      }
-      return ts.factory.createNumericLiteral(value.toString());
-    }
-  }
-
-  private evaluateUnary(expr: ts.PrefixUnaryExpression, context: EvaluationContext): number {
-    const value = this.evaluate(expr.operand, context);
-    if (typeof value !== "number") {
-      throw this.createError(expr, `Unary operator requires numeric value, got ${typeof value}`);
-    }
-
-    switch (expr.operator) {
-      case ts.SyntaxKind.PlusToken:
-        return value;
-      case ts.SyntaxKind.MinusToken:
-        return -value;
-      case ts.SyntaxKind.TildeToken:
-        return ~value;
-      default:
-        throw this.createError(expr, `Unsupported unary operator: ${ts.SyntaxKind[expr.operator]}`);
-    }
-  }
-
-  private evaluateBinary(expr: ts.BinaryExpression, context: EvaluationContext): EnumValue {
-    const left = this.evaluate(expr.left, context);
-    const right = this.evaluate(expr.right, context);
-
-    if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-      return left + right;
-    }
-
-    if (typeof left === "number" && typeof right === "number") {
-      switch (expr.operatorToken.kind) {
-        case ts.SyntaxKind.BarToken:
-          return left | right;
-        case ts.SyntaxKind.AmpersandToken:
-          return left & right;
-        case ts.SyntaxKind.GreaterThanGreaterThanToken:
-          return left >> right;
-        case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-          return left >>> right;
-        case ts.SyntaxKind.LessThanLessThanToken:
-          return left << right;
-        case ts.SyntaxKind.CaretToken:
-          return left ^ right;
-        case ts.SyntaxKind.AsteriskToken:
-          return left * right;
-        case ts.SyntaxKind.SlashToken:
-          return left / right;
-        case ts.SyntaxKind.PlusToken:
-          return left + right;
-        case ts.SyntaxKind.MinusToken:
-          return left - right;
-        case ts.SyntaxKind.PercentToken:
-          return left % right;
-        case ts.SyntaxKind.AsteriskAsteriskToken:
-          return left ** right;
-        default:
-          throw this.createError(expr, `Unsupported binary operator: ${ts.SyntaxKind[expr.operatorToken.kind]}`);
-      }
-    }
-
-    throw this.createError(expr, `Cannot evaluate binary expression with types ${typeof left} and ${typeof right}`);
-  }
-
-  private evaluateIdentifier(expr: ts.Identifier, context: EvaluationContext): EnumValue {
-    if (!context.allowEnumReferences) {
-      throw this.createError(expr, `Cannot reference enum member here`);
-    }
-
-    const value = context.localMembers.get(expr.text);
-    if (value === undefined) {
-      throw this.createError(expr, `Undefined enum member: ${expr.text}`);
-    }
-
-    return value;
-  }
-
-  private createError(node: ts.Node, message: string): Error {
-    const sourceFile = node.getSourceFile();
-    const pos = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    return new Error(`${sourceFile.fileName}:${pos.line + 1}:${pos.character}: ${message}`);
-  }
-}

package/src/const-enum/registry.ts

@@ -1,152 +0,0 @@
-import ts from "typescript";
-import { EnumValue, EvaluationContext } from "./evaluator";
-import { EnumEvaluator } from "./evaluator";
-import { isConstEnumSymbol } from "./utils";
-import { hasModifier } from "../utils/symbol-utils";
-
-export interface ConstEnumInfo {
-  declaration: ts.EnumDeclaration;
-  members: Map<string, ConstEnumMemberInfo>;
-  isExported: boolean;
-  sourceFile: ts.SourceFile;
-}
-
-export interface ConstEnumMemberInfo {
-  declaration: ts.EnumMember;
-  name: string;
-  value: EnumValue | null;
-}
-
-export class ConstEnumRegistry {
-  private readonly program: ts.Program;
-  private readonly typeChecker: ts.TypeChecker;
-  private readonly enumDeclarations: Map<string, ConstEnumInfo>;
-
-  constructor(program: ts.Program) {
-    this.program = program;
-    this.typeChecker = program.getTypeChecker();
-    this.enumDeclarations = new Map();
-    this.collectConstEnumsFromEntryPoints();
-  }
-
-  getEnum(enumName: string): ConstEnumInfo | undefined {
-    return this.enumDeclarations.get(enumName);
-  }
-
-  getEnumInfo(symbol: ts.Symbol): ConstEnumInfo | undefined {
-    const name = this.getEnumSymbolName(symbol);
-    return this.enumDeclarations.get(name);
-  }
-
-  getMemberValue(enumName: string, memberName: string): EnumValue | undefined {
-    const enumInfo = this.enumDeclarations.get(enumName);
-    if (!enumInfo) return undefined;
-    const memberInfo = enumInfo.members.get(memberName);
-    return memberInfo?.value ?? undefined;
-  }
-
-  getAllEnums(): ConstEnumInfo[] {
-    return Array.from(this.enumDeclarations.values());
-  }
-
-  getEnumCount(): number {
-    return this.enumDeclarations.size;
-  }
-
-  private collectConstEnumsFromEntryPoints(): void {
-    const sourceFiles = this.program.getSourceFiles();
-
-    for (const sourceFile of sourceFiles) {
-      if (sourceFile.isDeclarationFile) {
-        continue;
-      }
-
-      this.registerConstEnumFromSource(sourceFile);
-    }
-  }
-
-  private registerConstEnumFromSource(sourceFile: ts.SourceFile): void {
-    ts.forEachChild(sourceFile, (node) => {
-      if (ts.isEnumDeclaration(node) && hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
-        const symbol = this.typeChecker.getSymbolAtLocation(node.name);
-        if (symbol && isConstEnumSymbol(symbol)) {
-          this.registerEnum(symbol, node, sourceFile);
-        }
-      }
-    });
-  }
-
-  private registerEnum(symbol: ts.Symbol, declaration: ts.EnumDeclaration, sourceFile: ts.SourceFile): void {
-    const name = this.getEnumSymbolName(symbol);
-
-    if (this.enumDeclarations.has(name)) {
-      return;
-    }
-
-    const isExported = this.hasExportModifier(declaration);
-
-    const enumInfo: ConstEnumInfo = {
-      declaration,
-      members: new Map(),
-      isExported,
-      sourceFile,
-    };
-
-    this.evaluateEnumMembers(enumInfo);
-
-    this.enumDeclarations.set(name, enumInfo);
-  }
-
-  private hasExportModifier(node: ts.Node): boolean {
-    if (!ts.canHaveModifiers(node)) {
-      return false;
-    }
-    const modifiers = ts.getModifiers(node);
-    if (!modifiers) {
-      return false;
-    }
-    return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-  }
-
-  private evaluateEnumMembers(enumInfo: ConstEnumInfo): void {
-    const evaluator = new EnumEvaluator();
-    evaluator.reset();
-    const context: EvaluationContext = {
-      localMembers: new Map(),
-      allowEnumReferences: true,
-    };
-
-    for (const member of enumInfo.declaration.members) {
-      if (!ts.isIdentifier(member.name)) continue;
-
-      try {
-        const value = evaluator.evaluateEnumMember(member, context);
-        context.localMembers.set(member.name.text, value);
-        enumInfo.members.set(member.name.text, {
-          declaration: member,
-          name: member.name.text,
-          value,
-        });
-      } catch (error) {
-        throw new Error(
-          `Failed to evaluate const enum member ${enumInfo.declaration.name.text}.${member.name.text}: ${error}`,
-        );
-      }
-    }
-  }
-
-  private getEnumDeclaration(symbol: ts.Symbol): ts.EnumDeclaration | null {
-    const decl = symbol.declarations?.[0];
-    if (decl && ts.isEnumDeclaration(decl)) {
-      return decl;
-    }
-    return null;
-  }
-
-  private getEnumSymbolName(symbol: ts.Symbol): string {
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      return this.typeChecker.getAliasedSymbol(symbol).name;
-    }
-    return symbol.name;
-  }
-}

package/src/const-enum/utils.ts

@@ -1,13 +0,0 @@
-import ts from "typescript";
-
-export const isConstEnumSymbol = (symbol: ts.Symbol): boolean => (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
-
-export const isConstEnumType = (type: ts.Type | undefined): boolean => {
-  if (type) {
-    const symbol = type.symbol || type.aliasSymbol;
-    if (symbol) {
-      return (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
-    }
-  }
-  return false;
-};