@eliasku/ts-transformers 0.0.3 → 0.0.5

package/README.md

@@ -1,114 +1,81 @@
+[![NPM Version](https://img.shields.io/npm/v/%40eliasku%2Fts-transformers)](https://www.npmjs.com/package/@eliasku/ts-transformers)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/eliasku/ts-transformers/ci.yml)
+
 # @eliasku/ts-transformers
 
-TypeScript transformer for code optimization and preparation for aggressive minification.
+TypeScript transformer for aggressive code minification through type-aware property renaming and const enum inlining.
 
-## ⚠️ Important Requirement
+## 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.
+- No pre-transpiled `.js` files in source
+- Transformer requires TypeScript type information
+- Applicable for application builds, not libraries
 
-## Approach
+## Core Concept
 
-This transformer prepares your code for aggressive minification by analyzing TypeScript types and applying two main optimizations:
+Two-phase optimization pipeline:
 
-### 1. Property Renaming with Detectable Prefixes
+1. **This Transformer**: Analyzes TypeScript types, marks renamable properties with special prefixes
+2. **Minifier (esbuild)**: Aggressively mangles prefixed properties while preserving public API
 
-Based on type analysis, properties are categorized into three visibility levels:
+### 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`)
+Based on type analysis, properties are categorized as:
 
-The special prefixes make these properties easily detectable by downstream minifiers (like **esbuild** or **terser**) for aggressive mangling, while preserving your public API surface.
+- **Public (External)**: Exported from entry points → **no prefix** (preserved)
+- **Private**: Everything else → prefixed with `$_` (mangled by minifier)
 
 **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
+  /** @public - keeps name */
+  publicApi() {}
+
+  method() {}        // Private → $_method
+  private secret = 1; // Private → $_secret
 }
 
 // After transformer (before minifier)
 class MyClass {
   publicApi() {}
-  $i$apiMethod() {}
-  $i$internalHelper() {}
-  $p$secret = 1;
+  $_method() {}
+  $_secret = 1;
 }
 
-// After esbuild minifier (aggressive property mangling)
-class A{publicApi(){},a(){},b(){},c=1}
+// After esbuild minifier
+class A{publicApi(){},a(){},b=1}
 ```
 
-### 2. Const Enum Inlining
+### Const Enum Inlining
 
-Const enums are compile-time constants that should never exist at runtime. This transformer:
+Replaces const enum accesses with literal values and removes declarations.
 
-- 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
+  Inactive = 0,
 }
+const status = Status.Active;
 
-const status = Status.Active;  // Access
-
-// After transformer (and minifier)
+// After transformer + 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
+// Phase 1: Type-aware optimization
 const bundle = await rollup({
-  /// ...
   input: "./src/index.ts",
   plugins: [
     typescript({
@@ -125,193 +92,79 @@ const bundle = await rollup({
 });
 
 await bundle.write({
-  /// ...
   file: "./dist/bundle.js",
   format: "es",
 });
 
-// Phase 2: Aggressive minification with esbuild
+// Phase 2: Aggressive minification
 await build({
   entryPoints: ["./dist/bundle.js"],
   outfile: "./dist/bundle.min.js",
   minify: true,
-  mangleProps: /^\$[ip]\$/, // <- Match your custom prefixes here
+  mangleProps: /^\$_/, // Match your privatePrefix
   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.
+Entry points defining your public API surface.
 
 ```typescript
-entrySourceFiles: ["./src/index.ts"]
+entrySourceFiles: ["./src/index.ts"];
 ```
 
-### internalPrefix (optional, default: "$i$")
+### privatePrefix (optional, default: "$\_")
 
-Prefix for internal properties (not exported, but used across your codebase). These will be aggressively mangled by esbuild.
+Prefix for private properties that will be 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
+privatePrefix: "$_"; // myFunction → $_myFunction
 ```
 
 ### 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.
+JSDoc tag marking types/properties as public. Set to empty string to disable.
 
 ```typescript
-publicJSDocTag: "public"  // default
+publicJSDocTag: "public";
 
 class MyClass {
   /** @public */
-  apiMethod() {}  // Treated as external, no prefix applied
+  apiMethod() {} // Public, no prefix
 
-  internalHelper() {}  // Treated as internal, gets $i$ prefix
+  internalHelper() {} // Private, gets $_ 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.
+Skip renaming decorated fields.
 
 ```typescript
-ignoreDecorated: true  // Don't rename decorated fields
+ignoreDecorated: true;
 
-@Component({
-  selector: "app-root"
-})
+@Component({ selector: "app-root" })
 class AppComponent {
-  @Input() data: any;  // Decorated → not renamed with ignoreDecorated: true
-  private internal = 1;  // Still renamed to $p$internal
+  @Input() data: any; // Not renamed
+  private internal = 1; // Renamed to $_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
-  }
-}
-```
+Inline const enum values and remove declarations.
 
-### Example 3: Const Enum Inlining
+## Complete Example
 
 ```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}`;
@@ -322,36 +175,35 @@ class API {
   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)
+// After transformer
 class API {
-  $p$baseUrl = "https://api.example.com";
+  $_baseUrl = "https://api.example.com";
   async get(path) {
-    const url = `${this.$p$baseUrl}${path}`;
+    const url = `${this.$_baseUrl}${path}`;
     const response = await fetch(url);
-    return this.$i$handleResponse(response);
+    return this.$_handleResponse(response);
   }
 
-  $i$handleResponse(response) {
+  $_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};
+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 };
 ```
-
-## License
-
-MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eliasku/ts-transformers",
   "description": "TypeScript transformer for code optimization",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "license": "MIT",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -53,7 +53,7 @@ function createTransformerFactory(
 
         if (ts.isImportSpecifier(node)) {
           const removed = tryRemoveConstEnumImport(node);
-          if (removed === undefined) {
+          if (removed === undefined || node.isTypeOnly) {
             return undefined;
           }
         }
@@ -160,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
@@ -270,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 {
@@ -603,7 +601,7 @@ function createTransformerFactory(
         }
       }
 
-      return putToCache(nodeSymbol, VisibilityType.Internal);
+      return putToCache(nodeSymbol, VisibilityType.Private);
     }
 
     function getShorthandObjectBindingElementSymbol(element: ts.BindingElement): ts.Symbol | null {

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,