@eliasku/ts-transformers 0.0.2 → 0.0.4

package/README.md

@@ -1,44 +1,191 @@
 # @eliasku/ts-transformers
 
-TypeScript transformer for code optimization.
+TypeScript transformer for aggressive code minification through type-aware property renaming and const enum inlining.
+
+## Important Requirement
+
+**You must compile ALL your code from TypeScript files.**
+
+- No pre-transpiled `.js` files in source
+- Transformer requires TypeScript type information
+- Applicable for application builds, not libraries
+
+## Core Concept
+
+Two-phase optimization pipeline:
+
+1. **This Transformer**: Analyzes TypeScript types, marks renamable properties with special prefixes
+2. **Minifier (esbuild)**: Aggressively mangles prefixed properties while preserving public API
+
+### Visibility Levels
+
+Based on type analysis, properties are categorized as:
+
+- **Public (External)**: Exported from entry points → **no prefix** (preserved)
+- **Private**: Everything else → prefixed with `$_` (mangled by minifier)
+
+**Example:**
+```typescript
+// Before
+class MyClass {
+  /** @public - keeps name */
+  publicApi() {}
+
+  method() {}        // Private → $_method
+  private secret = 1; // Private → $_secret
+}
+
+// After transformer (before minifier)
+class MyClass {
+  publicApi() {}
+  $_method() {}
+  $_secret = 1;
+}
+
+// After esbuild minifier
+class A{publicApi(){},a(){},b=1}
+```
+
+### Const Enum Inlining
+
+Replaces const enum accesses with literal values and removes declarations.
+
+```typescript
+// Before
+const enum Status { Active = 1, Inactive = 0 }
+const status = Status.Active;
+
+// After transformer + minifier
+const status = 1;
+```
 
 ## Usage
 
 ```typescript
 import { optimizer } from "@eliasku/ts-transformers";
-
-transformers: (program) => ({
-  before: [
-    optimizer(program, {
-      entrySourceFiles: ["./src/index.ts"],
-      inlineConstEnums: true,
+import typescript from "@rollup/plugin-typescript";
+import { rollup } from "rollup";
+import { build } from "esbuild";
+
+// Phase 1: Type-aware optimization
+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
+await build({
+  entryPoints: ["./dist/bundle.js"],
+  outfile: "./dist/bundle.min.js",
+  minify: true,
+  mangleProps: /^\$_/,  // Match your privatePrefix
+  mangleQuoted: false,
+  keepNames: false,
+});
 ```
 
 ## Options
 
 ### entrySourceFiles (required)
 
-An array of entry source files which will be used to detect exported and internal fields. Basically it should be entry point(s) of the library/project.
+Entry points defining your public API surface.
 
-### inlineConstEnums (optional, default: true)
+```typescript
+entrySourceFiles: ["./src/index.ts"]
+```
 
-Whether to inline const enum values and remove const enum declarations.
+### privatePrefix (optional, default: "$_")
 
-### privatePrefix (optional, default: "$p$")
+Prefix for private properties that will be mangled by esbuild.
 
-Prefix of generated names for private fields.
+```typescript
+privatePrefix: "$_"  // myFunction → $_myFunction
+```
 
-### internalPrefix (optional, default: "$i$")
+### publicJSDocTag (optional, default: "public")
 
-Prefix of generated names for internal fields.
+JSDoc tag marking types/properties as public. Set to empty string to disable.
 
-### publicJSDocTag (optional, default: "public")
+```typescript
+publicJSDocTag: "public"
 
-Comment which will treat a class/interface/type/property/etc and all its children as "public". Set it to empty string to disable using JSDoc comment to detect "visibility level".
+class MyClass {
+  /** @public */
+  apiMethod() {}  // Public, no prefix
+
+  internalHelper() {}  // Private, gets $_ prefix
+}
+```
 
 ### ignoreDecorated (optional, default: false)
 
-Whether fields that were decorated should be renamed. A field is treated as "decorated" if itself or any its parent (on type level) has a decorator.
+Skip renaming decorated fields.
+
+```typescript
+ignoreDecorated: true
+
+@Component({ selector: "app-root" })
+class AppComponent {
+  @Input() data: any;  // Not renamed
+  private internal = 1;  // Renamed to $_internal
+}
+```
+
+### inlineConstEnums (optional, default: true)
+
+Inline const enum values and remove declarations.
+
+## Complete Example
+
+```typescript
+// src/index.ts (before)
+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;
+  }
+}
+
+export const api = new API();
+
+// After transformer
+class API {
+  $_baseUrl = "https://api.example.com";
+  async get(path) {
+    const url = `${this.$_baseUrl}${path}`;
+    const response = await fetch(url);
+    return this.$_handleResponse(response);
+  }
+
+  $_handleResponse(response) {
+    return response;
+  }
+}
+
+// After esbuild minifier
+class A{a="https://api.example.com";async get(t){const n=`${this.a}${t}`;return await fetch(n)}b(t){return t}}const s=new A;export{s};
+```

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@eliasku/ts-transformers",
   "description": "TypeScript transformer for code optimization",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "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,7 +21,8 @@
     "@types/bun": "latest",
     "rollup": "latest",
     "@rollup/plugin-typescript": "latest",
-    "tslib": "latest"
+    "tslib": "latest",
+    "esbuild": "latest"
   },
   "module": "./src/index.ts",
   "types": "./src/index.ts",

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 {

package/src/const-enum/registry.ts

@@ -1,7 +1,8 @@
 import ts from "typescript";
 import { EnumValue, EvaluationContext } from "./evaluator";
 import { EnumEvaluator } from "./evaluator";
-import { hasModifier, isConstEnumSymbol } from "./utils";
+import { isConstEnumSymbol } from "./utils";
+import { hasModifier } from "../typescript-helpers";
 
 export interface ConstEnumInfo {
   declaration: ts.EnumDeclaration;
@@ -19,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();
   }
@@ -110,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/exports/tracker.ts

@@ -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/index.ts

@@ -1,4 +1,5 @@
 import ts from "typescript";
+export type { OptimizerOptions } from "./types";
 
 import { ExportsSymbolTree } from "./exports/tracker";
 import {
@@ -32,8 +33,8 @@ function createTransformerFactory(
   const fullOptions: OptimizerOptions = { ...defaultOptions, ...options };
   const typeChecker = program.getTypeChecker();
   const exportsSymbolTree = new ExportsSymbolTree(program, fullOptions.entrySourceFiles);
-  const constEnumRegistry = new ConstEnumRegistry(program, fullOptions.entrySourceFiles);
-  const enumEvaluator = new EnumEvaluator(typeChecker);
+  const constEnumRegistry = new ConstEnumRegistry(program);
+  const enumEvaluator = new EnumEvaluator();
 
   const cache = new Map<ts.Symbol, VisibilityType>();
 
@@ -43,7 +44,7 @@ function createTransformerFactory(
   }
 
   return (context: ts.TransformationContext) => {
-    function transformNode(node: ts.Node): ts.Node {
+    function transformNode(node: ts.Node): ts.Node | undefined {
       if (fullOptions.inlineConstEnums !== false) {
         if (ts.isPropertyAccessExpression(node)) {
           const inlined = tryInlineConstEnum(node);
@@ -52,12 +53,16 @@ function createTransformerFactory(
 
         if (ts.isImportSpecifier(node)) {
           const removed = tryRemoveConstEnumImport(node);
-          if (removed === undefined) return undefined;
+          if (removed === undefined) {
+            return undefined;
+          }
         }
 
         if (ts.isImportClause(node)) {
           const removed = tryRemoveConstEnumImportClause(node);
-          if (removed === undefined) return undefined;
+          if (removed === undefined) {
+            return undefined;
+          }
         }
       }
 
@@ -70,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:
@@ -156,7 +160,7 @@ function createTransformerFactory(
         return node;
       }
 
-      return createNewNode(propertyName, VisibilityType.Internal, context.factory.createStringLiteral);
+      return createNewNode(propertyName, VisibilityType.Private, context.factory.createStringLiteral);
     }
 
     // obj.node
@@ -266,14 +270,12 @@ function createTransformerFactory(
       type: VisibilityType,
       createNode: (newName: string) => T,
     ): T {
-      const newPropertyName = getNewName(oldPropertyName, type);
+      const newPropertyName = getNewName(oldPropertyName);
       return createNode(newPropertyName);
     }
 
-    function getNewName(originalName: string, type: VisibilityType): string {
-      return `${
-        type === VisibilityType.Private ? fullOptions.privatePrefix : fullOptions.internalPrefix
-      }${originalName}`;
+    function getNewName(originalName: string): string {
+      return `${fullOptions.privatePrefix}${originalName}`;
     }
 
     function getActualSymbol(symbol: ts.Symbol): ts.Symbol {
@@ -548,7 +550,6 @@ function createTransformerFactory(
       }
 
       if (nodeSymbol.escapedName === "prototype") {
-        // accessing to prototype
         return putToCache(nodeSymbol, VisibilityType.External);
       }
 
@@ -600,7 +601,7 @@ function createTransformerFactory(
         }
       }
 
-      return putToCache(nodeSymbol, VisibilityType.Internal);
+      return putToCache(nodeSymbol, VisibilityType.Private);
     }
 
     function getShorthandObjectBindingElementSymbol(element: ts.BindingElement): ts.Symbol | null {
@@ -696,22 +697,21 @@ function createTransformerFactory(
         return undefined;
       }
 
-      function wrapTransformNode(node: ts.Node): ts.Node {
+      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;
+          if (result === undefined) {
+            return undefined;
+          }
+          if (result !== node) {
+            return result;
+          }
         }
         return transformNode(node);
       }
 
-      function wrappedTransformNodeAndChildren(node: ts.Node): ts.Node {
-        return ts.visitEachChild(
-          wrapTransformNode(node),
-          (childNode: ts.Node) => wrappedTransformNodeAndChildren(childNode),
-          context,
-        );
-      }
+      const wrappedTransformNodeAndChildren = (node: ts.Node): ts.Node | undefined =>
+        ts.visitEachChild(wrapTransformNode(node), wrappedTransformNodeAndChildren, context);
 
       return wrappedTransformNodeAndChildren(sourceFile) as ts.SourceFile;
     };

package/src/types.ts

@@ -8,18 +8,11 @@ export interface OptimizerOptions {
 
   /**
    * Prefix of generated names for private fields
-   * @example '_private_' // default
-   * @example '$p$'
+   * @example '_private_'
+   * @example '$_' // default
    */
   privatePrefix: string;
 
-  /**
-   * Prefix of generated names for internal fields
-   * @example '_internal_' // default
-   * @example '$i$'
-   */
-  internalPrefix: string;
-
   /**
    * Comment which will treat a class/interface/type/property/etc and all its children as "public".
    * Set it to empty string to disable using JSDoc comment to detecting "visibility level".
@@ -42,15 +35,13 @@ export interface OptimizerOptions {
 }
 
 export const enum VisibilityType {
-  Internal = 0,
-  Private = 1,
-  External = 2,
+  Private = 0,
+  External = 1,
 }
 
 export const defaultOptions: OptimizerOptions = {
   entrySourceFiles: [],
-  privatePrefix: "$p$",
-  internalPrefix: "$i$",
+  privatePrefix: "$_",
   publicJSDocTag: "public",
   ignoreDecorated: false,
   inlineConstEnums: true,

package/src/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)) {