@eliasku/ts-transformers 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,44 @@
+# @eliasku/ts-transformers
+
+TypeScript transformer for code optimization.
+
+## Usage
+
+```typescript
+import { optimizer } from "@eliasku/ts-transformers";
+
+transformers: (program) => ({
+  before: [
+    optimizer(program, {
+      entrySourceFiles: ["./src/index.ts"],
+      inlineConstEnums: true,
+    }),
+  ],
+});
+```
+
+## 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.
+
+### inlineConstEnums (optional, default: true)
+
+Whether to inline const enum values and remove const enum declarations.
+
+### privatePrefix (optional, default: "$p$")
+
+Prefix of generated names for private fields.
+
+### internalPrefix (optional, default: "$i$")
+
+Prefix of generated names for internal fields.
+
+### publicJSDocTag (optional, default: "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".
+
+### 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.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eliasku/ts-transformers",
-  "description": "",
-  "version": "0.0.1",
+  "description": "TypeScript transformer for code optimization",
+  "version": "0.0.2",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -22,9 +22,10 @@
     "@rollup/plugin-typescript": "latest",
     "tslib": "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

@@ -58,7 +58,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 +103,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

@@ -2,7 +2,6 @@ import ts from "typescript";
 import { EnumValue, EvaluationContext } from "./evaluator";
 import { EnumEvaluator } from "./evaluator";
 import { hasModifier, isConstEnumSymbol } from "./utils";
-import { LOGS } from "../config";
 
 export interface ConstEnumInfo {
   declaration: ts.EnumDeclaration;
@@ -56,29 +55,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 +81,6 @@ export class ConstEnumRegistry {
     const name = this.getEnumSymbolName(symbol);
 
     if (this.enumDeclarations.has(name)) {
-      // Already registered (might be from different import)
       return;
     }
 

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;

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

@@ -14,23 +14,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, fullOptions.entrySourceFiles);
+  const enumEvaluator = new EnumEvaluator(typeChecker);
 
   const cache = new Map<ts.Symbol, VisibilityType>();
 
@@ -40,17 +43,24 @@ 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 {
+      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;
+        }
+      }
+
       // const a = { node }
       if (ts.isShorthandPropertyAssignment(node)) {
         return handleShorthandPropertyAssignment(node);
@@ -637,6 +647,73 @@ 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 {
+        if (ts.isEnumDeclaration(node)) {
+          const result = handleEnumDeclaration(node);
+          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,
+        );
+      }
+
+      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/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;
-}