@eliasku/ts-transformers 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,357 @@
+# @eliasku/ts-transformers
+
+TypeScript transformer for code optimization and preparation for aggressive minification.
+
+## ⚠️ Important Requirement
+
+**You must compile ALL your code from TypeScript files.**
+
+- No pre-transpiled JavaScript files (`.js`) in your source code
+- Transformer requires TypeScript type information to analyze visibility
+- Any `.js` files will be included as-is without optimization
+- Mix of `.ts` and `.js` sources → partial optimization, unexpected results
+
+Applicable for only for application build, not libraries. For libraries it's better to use buildless approach, and provide `*.ts` files.
+
+## Approach
+
+This transformer prepares your code for aggressive minification by analyzing TypeScript types and applying two main optimizations:
+
+### 1. Property Renaming with Detectable Prefixes
+
+Based on type analysis, properties are categorized into three visibility levels:
+
+- **External (Public)**: Exported from entry points → **no prefix** (preserved by minifiers)
+- **Internal**: Used internally but not exported → prefixed with `$i$` (e.g., `$i$internalProperty`)
+- **Private**: Private class members → prefixed with `$p$` (e.g., `$p$privateMethod`)
+
+The special prefixes make these properties easily detectable by downstream minifiers (like **esbuild** or **terser**) for aggressive mangling, while preserving your public API surface.
+
+**Example:**
+```typescript
+// Before
+class MyClass {
+  /** @public <- annotation in JSDoc to keep symbol name: property, method, field */
+  publicApi() {} // `publicApi` is not renamed because it's marked by annotation
+  
+  public method() {}  // Internal → renamed to $i$method
+  internalHelper() {}    // Internal → renamed to $i$internalHelper
+  private secret = 1;    // Private → renamed to $p$secret
+}
+
+// After transformer (before minifier)
+class MyClass {
+  publicApi() {}
+  $i$apiMethod() {}
+  $i$internalHelper() {}
+  $p$secret = 1;
+}
+
+// After esbuild minifier (aggressive property mangling)
+class A{publicApi(){},a(){},b(){},c=1}
+```
+
+### 2. Const Enum Inlining
+
+Const enums are compile-time constants that should never exist at runtime. This transformer:
+
+- Replaces all const enum member accesses with their literal values
+- Removes const enum declarations from output
+- Strips `const` modifier from declarations in `.d.ts` files
+- Removes unused const enum imports
+
+**Example:**
+```typescript
+// Before
+const enum Status {
+  Active = 1,
+  Inactive = 0
+}
+
+const status = Status.Active;  // Access
+
+// After transformer (and minifier)
+const status = 1;
+// Status declaration removed, import removed
+```
+
+## Workflow
+
+This transformer is **Phase 1** of a two-phase optimization pipeline:
+
+### Phase 1: Type-Aware Preparation (This Transformer)
+- **Input**: TypeScript source files
+- **Process**: Analyze types, detect visibility, apply prefixes, inline const enums
+- **Output**: ES modules with detectable prefixes
+- **Tools**: `@eliasku/ts-transformers` + Rollup + TypeScript compiler
+
+### Phase 2: Aggressive Minification (esbuild / terser)
+- **Input**: ES modules from Phase 1
+- **Process**: Detect prefixes, mangle aggressively, apply all minification techniques
+- **Output**: Minified bundle with preserved public API
+- **Tools**: esbuild with property mangling
+
+**Why Two Phases?**
+- TypeScript types are only available during compilation (Phase 1)
+- Production minifiers (Phase 2) are faster and more sophisticated
+- Prefixes bridge the gap: Phase 1 marks what's safe to mangle, Phase 2 performs the mangling
+
+## Usage
+
+[Example Code](./example/build.ts)
+
+```typescript
+import { optimizer } from "@eliasku/ts-transformers";
+import typescript from "@rollup/plugin-typescript";
+import { rollup } from "rollup";
+import { build } from "esbuild";
+
+// Phase 1: Type-aware optimization with Rollup
+const bundle = await rollup({
+  /// ...
+  input: "./src/index.ts",
+  plugins: [
+    typescript({
+      transformers: (program) => ({
+        before: [
+          optimizer(program, {
+            entrySourceFiles: ["./src/index.ts"],
+            inlineConstEnums: true,
+          }),
+        ],
+      }),
+    }),
+  ],
+});
+
+await bundle.write({
+  /// ...
+  file: "./dist/bundle.js",
+  format: "es",
+});
+
+// Phase 2: Aggressive minification with esbuild
+await build({
+  entryPoints: ["./dist/bundle.js"],
+  outfile: "./dist/bundle.min.js",
+  minify: true,
+  mangleProps: /^\$[ip]\$/, // <- Match your custom prefixes here
+  mangleQuoted: false,
+  keepNames: false,
+  /// ...
+});
+```
+
+### Customizing esbuild to Match Your Prefixes
+
+If you customize the prefix options, update esbuild config to match:
+
+```typescript
+optimizer(program, {
+  entrySourceFiles: ["./src/index.ts"],
+  internalPrefix: "_int_",   // Custom internal prefix
+  privatePrefix: "_priv_",    // Custom private prefix
+});
+
+// Then in esbuild:
+mangleProps: /^(_int_|_priv_)/,  // Match custom prefixes
+```
+
+## Options
+
+### entrySourceFiles (required)
+
+An array of entry source files used to detect exported and external fields. This determines your public API surface.
+
+```typescript
+entrySourceFiles: ["./src/index.ts"]
+```
+
+### internalPrefix (optional, default: "$i$")
+
+Prefix for internal properties (not exported, but used across your codebase). These will be aggressively mangled by esbuild.
+
+```typescript
+internalPrefix: "$i$"  // default: myFunction → $i$myFunction
+```
+
+### privatePrefix (optional, default: "$p$")
+
+Prefix for private class members. These will be aggressively mangled by esbuild.
+
+```typescript
+privatePrefix: "$p$"  // default: this.private → this.$p$private
+```
+
+### publicJSDocTag (optional, default: "public")
+
+JSDoc tag that marks a class/interface/property and all its children as public/external. Set to empty string to disable.
+
+```typescript
+publicJSDocTag: "public"  // default
+
+class MyClass {
+  /** @public */
+  apiMethod() {}  // Treated as external, no prefix applied
+
+  internalHelper() {}  // Treated as internal, gets $i$ prefix
+}
+```
+
+### ignoreDecorated (optional, default: false)
+
+Whether decorated fields should be renamed. A field is "decorated" if itself or any parent (on type level) has a decorator.
+
+```typescript
+ignoreDecorated: true  // Don't rename decorated fields
+
+@Component({
+  selector: "app-root"
+})
+class AppComponent {
+  @Input() data: any;  // Decorated → not renamed with ignoreDecorated: true
+  private internal = 1;  // Still renamed to $p$internal
+}
+```
+
+### inlineConstEnums (optional, default: true)
+
+Whether to inline const enum values and remove const enum declarations.
+
+## Examples
+
+### Example 1: Simple Property Renaming
+
+```typescript
+// src/index.ts (before)
+class Calculator {
+  add(a: number, b: number): number {
+    return a + b;
+  }
+  logResult(value: number): void {
+    console.log(value);
+  }
+}
+
+export const calc = new Calculator();
+export { Calculator };
+
+// After transformer (before minifier)
+class Calculator {
+  add(a, b) { return a + b; }  // Exported method → no prefix
+  $i$logResult(value) {            // Internal method → $i$ prefix
+    console.log(value);
+  }
+}
+```
+
+### Example 2: JSDoc Public Annotation
+
+```typescript
+// src/index.ts (before)
+class API {
+  /** @public */
+  fetchData(url: string): Promise<Data> {
+    return fetch(url);
+  }
+
+  private cache = new Map();
+  internalTransform(data: Data): Processed {
+    // transformation logic
+  }
+}
+
+export const api = new API();
+
+// After transformer (before minifier)
+class API {
+  fetchData(url) { return fetch(url); }  // @public → no prefix
+  $p$cache = new Map();                // Private → $p$ prefix
+  $i$internalTransform(data) {          // Internal → $i$ prefix
+    // transformation logic
+  }
+}
+```
+
+### Example 3: Const Enum Inlining
+
+```typescript
+// src/index.ts (before)
+const enum LogLevel {
+  Debug = 0,
+  Info = 1,
+  Error = 2
+}
+
+function log(level: LogLevel, message: string): void {
+  console.log(`[${LogLevel[level]}] ${message}`);
+}
+
+export { log, LogLevel };
+
+// After transformer (before minifier)
+function log(level, message) {
+  console.log(`[${level}] ${message}`);
+}
+export { log };
+
+// After esbuild minifier
+function log(n,e){console.log(`[${n}]${e}`)}export{log};
+// LogLevel values inlined: LogLevel.Debug → 0, LogLevel.Info → 1, etc.
+// LogLevel enum declaration removed entirely
+```
+
+### Example 4: Complete Transformation + Minification
+
+```typescript
+// src/index.ts (before)
+const enum HttpStatus {
+  OK = 200,
+  NotFound = 404
+}
+
+class API {
+  private baseUrl = "https://api.example.com";
+  /** @public */
+  async get(path: string): Promise<Response> {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url);
+    return this.handleResponse(response);
+  }
+
+  private async handleResponse(response: Response): Promise<Response> {
+    return response;
+  }
+
+  logStatus(status: HttpStatus): void {
+    console.log(status);
+  }
+}
+
+export const api = new API();
+
+// After transformer (before minifier)
+class API {
+  $p$baseUrl = "https://api.example.com";
+  async get(path) {
+    const url = `${this.$p$baseUrl}${path}`;
+    const response = await fetch(url);
+    return this.$i$handleResponse(response);
+  }
+
+  $i$handleResponse(response) {
+    return response;
+  }
+
+  $i$logStatus(status) {
+    console.log(status);
+  }
+}
+
+// After esbuild minifier
+class t{a="https://api.example.com";async get(t){const n=`${this.a}${t}`;return await fetch(n)}b(t){return t}c(t){console.log(t)}}const s=new t;export{s};
+```
+
+## License
+
+MIT

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@eliasku/ts-transformers",
-  "description": "",
-  "version": "0.0.1",
+  "description": "TypeScript transformer for code optimization",
+  "version": "0.0.3",
   "license": "MIT",
   "type": "module",
   "scripts": {
     "test": "bun test",
     "format": "prettier --write **/*.{ts,json,md,yml}",
     "check": "tsc -p .",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "build:example": "cd example && bun run build.ts"
   },
   "dependencies": {
     "typescript": "^5"
@@ -20,11 +21,13 @@
     "@types/bun": "latest",
     "rollup": "latest",
     "@rollup/plugin-typescript": "latest",
-    "tslib": "latest"
+    "tslib": "latest",
+    "esbuild": "latest"
   },
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
   "exports": {
-    "./mangler": "./src/mangler/index.ts",
-    "./const-enum": "./src/const-enum/index.ts"
+    ".": "./src/index.ts"
   },
   "repository": {
     "type": "git",

package/src/const-enum/evaluator.ts

@@ -9,13 +9,9 @@ export interface EvaluationContext {
 
 export class EnumEvaluator {
   private lastImplicitValue = -1;
-  private enumType: "numeric" | "string" | "mixed" = "numeric";
-
-  constructor(private readonly typeChecker: ts.TypeChecker) {}
 
   reset(): void {
     this.lastImplicitValue = -1;
-    this.enumType = "numeric";
   }
 
   evaluate(expr: ts.Expression, context: EvaluationContext): EnumValue {
@@ -58,7 +54,6 @@ export class EnumEvaluator {
 
   private evaluateImplicitMember(member: ts.EnumMember): EnumValue {
     const name = ts.isIdentifier(member.name) ? member.name.text : `<computed>`;
-    // unused
     void name;
 
     if (this.lastImplicitValue === -1) {
@@ -104,12 +99,10 @@ export class EnumEvaluator {
     const left = this.evaluate(expr.left, context);
     const right = this.evaluate(expr.right, context);
 
-    // String concatenation
     if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === ts.SyntaxKind.PlusToken) {
       return left + right;
     }
 
-    // Numeric operations
     if (typeof left === "number" && typeof right === "number") {
       switch (expr.operatorToken.kind) {
         case ts.SyntaxKind.BarToken:

package/src/const-enum/registry.ts

@@ -1,8 +1,8 @@
 import ts from "typescript";
 import { EnumValue, EvaluationContext } from "./evaluator";
 import { EnumEvaluator } from "./evaluator";
-import { hasModifier, isConstEnumSymbol } from "./utils";
-import { LOGS } from "../config";
+import { isConstEnumSymbol } from "./utils";
+import { hasModifier } from "../typescript-helpers";
 
 export interface ConstEnumInfo {
   declaration: ts.EnumDeclaration;
@@ -20,13 +20,11 @@ export interface ConstEnumMemberInfo {
 export class ConstEnumRegistry {
   private readonly program: ts.Program;
   private readonly typeChecker: ts.TypeChecker;
-  private readonly entrySourceFiles: readonly string[];
   private readonly enumDeclarations: Map<string, ConstEnumInfo>;
 
-  constructor(program: ts.Program, entrySourceFiles?: readonly string[]) {
+  constructor(program: ts.Program) {
     this.program = program;
     this.typeChecker = program.getTypeChecker();
-    this.entrySourceFiles = entrySourceFiles || program.getRootFileNames();
     this.enumDeclarations = new Map();
     this.collectConstEnumsFromEntryPoints();
   }
@@ -56,29 +54,15 @@ export class ConstEnumRegistry {
   }
 
   private collectConstEnumsFromEntryPoints(): void {
-    if (LOGS) {
-      console.log(`[const-enum registry] Starting collection from ${this.entrySourceFiles.length} entry point(s)`);
-    }
-
-    // Collect all const enums from the entire program
     const sourceFiles = this.program.getSourceFiles();
-    if (LOGS) {
-      console.log(`[const-enum registry] Program has ${sourceFiles.length} source files`);
-    }
 
     for (const sourceFile of sourceFiles) {
-      // We are using typescript files from node_modules as well, so don't skip them
-      // but skip declaration files
       if (sourceFile.isDeclarationFile) {
         continue;
       }
 
       this.registerConstEnumFromSource(sourceFile);
     }
-
-    if (LOGS) {
-      console.log(`[const-enum registry] Found ${this.enumDeclarations.size} const enum declarations`);
-    }
   }
 
   private registerConstEnumFromSource(sourceFile: ts.SourceFile): void {
@@ -96,7 +80,6 @@ export class ConstEnumRegistry {
     const name = this.getEnumSymbolName(symbol);
 
     if (this.enumDeclarations.has(name)) {
-      // Already registered (might be from different import)
       return;
     }
 
@@ -126,7 +109,7 @@ export class ConstEnumRegistry {
   }
 
   private evaluateEnumMembers(enumInfo: ConstEnumInfo): void {
-    const evaluator = new EnumEvaluator(this.typeChecker);
+    const evaluator = new EnumEvaluator();
     evaluator.reset();
     const context: EvaluationContext = {
       localMembers: new Map(),

package/src/const-enum/utils.ts

@@ -1,13 +1,13 @@
 import ts from "typescript";
 
-export const hasModifier = (node: ts.Node, modifier: ts.SyntaxKind) =>
-  ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((mod: ts.Modifier) => mod.kind === modifier);
-
 export const isConstEnumSymbol = (symbol: ts.Symbol): boolean => (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
 
 export const isConstEnumType = (type: ts.Type | undefined): boolean => {
-  if (!type) return false;
-  const symbol = type.symbol || type.aliasSymbol;
-  if (!symbol) return false;
-  return (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
+  if (type) {
+    const symbol = type.symbol || type.aliasSymbol;
+    if (symbol) {
+      return (symbol.flags & ts.SymbolFlags.ConstEnum) !== 0;
+    }
+  }
+  return false;
 };

package/src/{mangler/exports → exports}/tracker.ts

@@ -8,7 +8,7 @@ import {
   getExportsForSourceFile,
   getDeclarationsForSymbol,
 } from "../utils/symbol-utils";
-import { LOGS } from "../../config";
+import { LOGS } from "../config";
 
 export class ExportsSymbolTree {
   private readonly program: ts.Program;
@@ -21,13 +21,12 @@ export class ExportsSymbolTree {
 
   public isSymbolAccessibleFromExports(symbol: ts.Symbol): boolean {
     symbol = this.getActualSymbol(symbol);
-
-    let result = false;
-    this.exportsTree.forEach((set: Set<ts.Symbol>) => {
-      result = result || set.has(symbol);
-    });
-
-    return result;
+    for (const [, set] of this.exportsTree) {
+      if (set.has(symbol)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   private computeTreeForExports(entrySourceFiles: readonly string[]): void {

package/src/{mangler/index.ts → index.ts}

@@ -1,4 +1,5 @@
 import ts from "typescript";
+export type { OptimizerOptions } from "./types";
 
 import { ExportsSymbolTree } from "./exports/tracker";
 import {
@@ -14,23 +15,26 @@ import {
   isNodeNamedDeclaration,
 } from "./utils/symbol-utils";
 import { getNodeJSDocComment } from "./utils/ast-utils";
-import { RenameOptions, defaultOptions, VisibilityType } from "./types";
-import { LOGS } from "../config";
+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 function propertiesRenameTransformer(
+export const optimizer = (
   program: ts.Program,
-  config?: Partial<RenameOptions>,
-): ts.TransformerFactory<ts.SourceFile> {
-  return createTransformerFactory(program, config);
-}
+  config?: Partial<OptimizerOptions>,
+): ts.TransformerFactory<ts.SourceFile> => createTransformerFactory(program, config);
 
 function createTransformerFactory(
   program: ts.Program,
-  options?: Partial<RenameOptions>,
+  options?: Partial<OptimizerOptions>,
 ): ts.TransformerFactory<ts.SourceFile> {
-  const fullOptions: RenameOptions = { ...defaultOptions, ...options };
+  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>();
 
@@ -40,17 +44,28 @@ function createTransformerFactory(
   }
 
   return (context: ts.TransformationContext) => {
-    function transformNodeAndChildren(node: ts.SourceFile, ctx: ts.TransformationContext): ts.SourceFile;
-    function transformNodeAndChildren(node: ts.Node, ctx: ts.TransformationContext): ts.Node;
-    function transformNodeAndChildren(node: ts.Node, ctx: ts.TransformationContext): ts.Node {
-      return ts.visitEachChild(
-        transformNode(node),
-        (childNode: ts.Node) => transformNodeAndChildren(childNode, ctx),
-        ctx,
-      );
-    }
+    function transformNode(node: ts.Node): ts.Node | undefined {
+      if (fullOptions.inlineConstEnums !== false) {
+        if (ts.isPropertyAccessExpression(node)) {
+          const inlined = tryInlineConstEnum(node);
+          if (inlined) return inlined;
+        }
+
+        if (ts.isImportSpecifier(node)) {
+          const removed = tryRemoveConstEnumImport(node);
+          if (removed === undefined) {
+            return undefined;
+          }
+        }
+
+        if (ts.isImportClause(node)) {
+          const removed = tryRemoveConstEnumImportClause(node);
+          if (removed === undefined) {
+            return undefined;
+          }
+        }
+      }
 
-    function transformNode(node: ts.Node): ts.Node {
       // const a = { node }
       if (ts.isShorthandPropertyAssignment(node)) {
         return handleShorthandPropertyAssignment(node);
@@ -60,9 +75,8 @@ function createTransformerFactory(
       if (ts.isBindingElement(node) && node.propertyName === undefined) {
         if (node.parent && ts.isObjectBindingPattern(node.parent)) {
           return handleShorthandObjectBindingElement(node);
-        } else {
-          console.warn("!!!", node);
         }
+        return node;
       }
 
       // is not supported:
@@ -538,7 +552,6 @@ function createTransformerFactory(
       }
 
       if (nodeSymbol.escapedName === "prototype") {
-        // accessing to prototype
         return putToCache(nodeSymbol, VisibilityType.External);
       }
 
@@ -637,6 +650,72 @@ function createTransformerFactory(
       return isSymbolClassMember(typeChecker.getSymbolAtLocation(node));
     }
 
-    return (sourceFile: ts.SourceFile) => transformNodeAndChildren(sourceFile, context);
+    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;
+
+      return enumEvaluator.createLiteral(memberValue);
+    }
+
+    function tryRemoveConstEnumImport(node: ts.ImportSpecifier): ts.ImportSpecifier | undefined {
+      const importedType = typeChecker.getTypeAtLocation(node);
+      if (isConstEnumType(importedType)) {
+        return undefined;
+      }
+      return node;
+    }
+
+    function tryRemoveConstEnumImportClause(node: ts.ImportClause): ts.ImportClause | undefined {
+      if (!node.name) return node;
+      const type = typeChecker.getTypeAtLocation(node.name);
+      if (isConstEnumType(type)) {
+        return undefined;
+      }
+      return node;
+    }
+
+    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 undefined;
+      }
+
+      function wrapTransformNode(node: ts.Node): ts.Node | undefined {
+        if (ts.isEnumDeclaration(node)) {
+          const result = handleEnumDeclaration(node);
+          if (result === undefined) {
+            return undefined;
+          }
+          if (result !== node) {
+            return result;
+          }
+        }
+        return transformNode(node);
+      }
+
+      const wrappedTransformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
+        ts.visitEachChild(wrapTransformNode(node), wrappedTransformNodeAndChildren, context);
+
+      return wrappedTransformNodeAndChildren(sourceFile) as ts.SourceFile;
+    };
   };
 }

package/src/{mangler/types.ts → types.ts}

@@ -1,4 +1,4 @@
-export interface RenameOptions {
+export interface OptimizerOptions {
   /**
    * An array of entry source files which will used to detect exported and internal fields.
    * Basically it should be entry point(s) of the library/project.
@@ -34,6 +34,11 @@ export interface RenameOptions {
    * 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 {
@@ -42,10 +47,11 @@ export const enum VisibilityType {
   External = 2,
 }
 
-export const defaultOptions: RenameOptions = {
+export const defaultOptions: OptimizerOptions = {
   entrySourceFiles: [],
   privatePrefix: "$p$",
   internalPrefix: "$i$",
   publicJSDocTag: "public",
   ignoreDecorated: false,
+  inlineConstEnums: true,
 };

package/src/{mangler/typescript-helpers.ts → typescript-helpers.ts}

@@ -139,8 +139,8 @@ function getModifiers(node: ts.Node): readonly ts.Modifier[] {
   return node.modifiers || [];
 }
 
-export const hasModifier = (node: ts.Node, modifier: ts.SyntaxKind) =>
-  getModifiers(node).some((mod) => mod.kind === modifier);
+export const hasModifier = (node: ts.Node, modifier: ts.SyntaxKind): boolean =>
+  ts.canHaveModifiers(node) && getModifiers(node)?.some((mod) => mod.kind === modifier);
 
 function getDecorators(node: ts.Node): readonly unknown[] {
   if (isBreakingTypeScriptApi(ts)) {

package/src/const-enum/index.ts

@@ -1,181 +0,0 @@
-import ts from "typescript";
-import { ConstEnumRegistry } from "./registry";
-import { EnumEvaluator } from "./evaluator";
-import { hasModifier, isConstEnumType } from "./utils";
-import { LOGS } from "../config";
-
-export const tsTransformConstEnums = (
-  program: ts.Program,
-  entrySourceFiles?: readonly string[],
-): ts.TransformerFactory<ts.SourceFile> => {
-  if (LOGS) {
-    console.log("[const-enum] tsTransformConstEnums called!");
-  }
-  const startTime = performance.now();
-  const registry = new ConstEnumRegistry(program, entrySourceFiles);
-  const typeChecker = program.getTypeChecker();
-  const evaluator = new EnumEvaluator(typeChecker);
-  if (LOGS) {
-    console.log(
-      `[const-enum] Found ${registry.getEnumCount()} const enum declarations in ${performance.now() - startTime}ms`,
-    );
-  }
-
-  return (context: ts.TransformationContext) => {
-    function transformNodeAndChildren(
-      node: ts.Node,
-      ctx: ts.TransformationContext,
-      sourceFile: ts.SourceFile,
-    ): ts.Node {
-      return ts.visitEachChild(
-        transformNode(node, sourceFile, ctx, registry, evaluator, typeChecker),
-        (childNode: ts.Node) => transformNodeAndChildren(childNode, ctx, sourceFile),
-        ctx,
-      );
-    }
-    return (sourceFile: ts.SourceFile) => transformNodeAndChildren(sourceFile, context, sourceFile) as ts.SourceFile;
-  };
-};
-
-function transformNode(
-  node: ts.Node,
-  sourceFile: ts.SourceFile,
-  ctx: ts.TransformationContext,
-  registry: ConstEnumRegistry,
-  evaluator: EnumEvaluator,
-  typeChecker: ts.TypeChecker,
-): ts.Node {
-  if (ts.isPropertyAccessExpression(node)) {
-    return transformPropertyAccess(node, ctx, registry, evaluator, typeChecker);
-  }
-
-  if (ts.isEnumDeclaration(node)) {
-    return transformEnumDeclaration(node, sourceFile, ctx);
-  }
-
-  if (ts.isImportSpecifier(node)) {
-    return transformImportSpecifier(node, ctx, registry, typeChecker);
-  }
-
-  if (ts.isImportClause(node)) {
-    return transformImportClause(node, ctx, registry, typeChecker);
-  }
-
-  return ts.visitEachChild(
-    node,
-    (child) => transformNode(child, sourceFile, ctx, registry, evaluator, typeChecker),
-    ctx,
-  );
-}
-
-function transformPropertyAccess(
-  node: ts.PropertyAccessExpression,
-  ctx: ts.TransformationContext,
-  registry: ConstEnumRegistry,
-  evaluator: EnumEvaluator,
-  typeChecker: ts.TypeChecker,
-): ts.Expression | ts.PropertyAccessExpression {
-  const expressionType = typeChecker.getTypeAtLocation(node.expression);
-
-  if (!isConstEnumType(expressionType)) {
-    return node;
-  }
-
-  const enumSymbol = expressionType.symbol || expressionType.aliasSymbol;
-  if (!enumSymbol) {
-    return node;
-  }
-
-  const enumInfo = registry.getEnumInfo(enumSymbol);
-  if (!enumInfo) {
-    if (LOGS) {
-      console.warn(`[const-enum] Could not find const enum ${enumSymbol.name}`);
-    }
-    return node;
-  }
-
-  const memberValue = enumInfo.members.get(node.name.text)?.value;
-  if (memberValue === undefined || memberValue === null) {
-    if (LOGS) {
-      console.warn(`[const-enum] Could not find member ${enumSymbol.name}.${node.name.text}`);
-    }
-    return node;
-  }
-
-  const literal = evaluator.createLiteral(memberValue);
-  if (LOGS) {
-    console.log(`[const-enum] Inline ${enumSymbol.name}.${node.name.text} → ${JSON.stringify(memberValue)}`);
-  }
-
-  return literal;
-}
-
-function transformEnumDeclaration(
-  node: ts.EnumDeclaration,
-  sourceFile: ts.SourceFile,
-  ctx: ts.TransformationContext,
-): ts.EnumDeclaration | undefined {
-  // unused
-  void ctx;
-
-  if (!hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
-    return node;
-  }
-
-  if (sourceFile.isDeclarationFile) {
-    if (LOGS) {
-      console.log(`[const-enum] Strip 'const' from ${node.name.text} in ${sourceFile.fileName}`);
-    }
-    return ts.factory.updateEnumDeclaration(
-      node,
-      node.modifiers?.filter((m) => m.kind !== ts.SyntaxKind.ConstKeyword),
-      node.name,
-      node.members,
-    );
-  }
-
-  if (LOGS) {
-    console.log(`[const-enum] Remove const enum declaration ${node.name.text} in ${sourceFile.fileName}`);
-  }
-  return undefined;
-}
-
-function transformImportSpecifier(
-  node: ts.ImportSpecifier,
-  ctx: ts.TransformationContext,
-  registry: ConstEnumRegistry,
-  typeChecker: ts.TypeChecker,
-): ts.ImportSpecifier | undefined {
-  const importedType = typeChecker.getTypeAtLocation(node);
-
-  if (isConstEnumType(importedType)) {
-    if (LOGS) {
-      console.log(`[const-enum] Remove import of const enum ${importedType.symbol?.name}`);
-    }
-    return undefined;
-  }
-
-  return node;
-}
-
-function transformImportClause(
-  node: ts.ImportClause,
-  ctx: ts.TransformationContext,
-  registry: ConstEnumRegistry,
-  typeChecker: ts.TypeChecker,
-): ts.ImportClause | undefined {
-  if (!node.name) {
-    return node;
-  }
-
-  const type = typeChecker.getTypeAtLocation(node.name);
-
-  if (isConstEnumType(type)) {
-    if (LOGS) {
-      console.log(`[const-enum] Remove import clause for const enum ${type.symbol?.name}`);
-    }
-    return undefined;
-  }
-
-  return node;
-}