@eliasku/ts-transformers 0.0.1

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@eliasku/ts-transformers",
+  "description": "",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "test": "bun test",
+    "format": "prettier --write **/*.{ts,json,md,yml}",
+    "check": "tsc -p .",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "typescript": "^5"
+  },
+  "optionalDependencies": {
+    "prettier": "latest",
+    "eslint": "latest",
+    "typescript-eslint": "latest",
+    "@types/bun": "latest",
+    "rollup": "latest",
+    "@rollup/plugin-typescript": "latest",
+    "tslib": "latest"
+  },
+  "exports": {
+    "./mangler": "./src/mangler/index.ts",
+    "./const-enum": "./src/const-enum/index.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eliasku/ts-transformers.git"
+  },
+  "author": "Ilya Kuzmichev",
+  "keywords": [
+    "typescript",
+    "ts",
+    "plugin",
+    "transformer",
+    "minify",
+    "const-enum",
+    "treeshake",
+    "mangle"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src"
+  ]
+}

package/src/config.ts

@@ -0,0 +1 @@
+export const LOGS = false;

package/src/const-enum/evaluator.ts

@@ -0,0 +1,165 @@
+import ts from "typescript";
+
+export type EnumValue = string | number;
+
+export interface EvaluationContext {
+  localMembers: Map<string, EnumValue>;
+  allowEnumReferences: boolean;
+}
+
+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 {
+    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>`;
+    // unused
+    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);
+
+    // 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:
+          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/index.ts

@@ -0,0 +1,181 @@
+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;
+}

package/src/const-enum/registry.ts

@@ -0,0 +1,169 @@
+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;
+  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 entrySourceFiles: readonly string[];
+  private readonly enumDeclarations: Map<string, ConstEnumInfo>;
+
+  constructor(program: ts.Program, entrySourceFiles?: readonly string[]) {
+    this.program = program;
+    this.typeChecker = program.getTypeChecker();
+    this.entrySourceFiles = entrySourceFiles || program.getRootFileNames();
+    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 {
+    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 {
+    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)) {
+      // Already registered (might be from different import)
+      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(this.typeChecker);
+    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

@@ -0,0 +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;
+};