@eliasku/ts-transformers 0.0.6 → 0.0.8

package/README.md

@@ -52,7 +52,7 @@ class A{publicApi(){},a(){},b=1}
 
 ### Const Enum Inlining
 
-Replaces const enum accesses with literal values and removes declarations.
+Replaces const enum accesses with literal values and transforms declarations to remove codegen, but keep symbol to preserve default import/export flow.
 
 ```typescript
 // Before
@@ -60,10 +60,14 @@ const enum Status {
   Active = 1,
   Inactive = 0,
 }
-const status = Status.Active;
+export const status = Status.Active;
 
-// After transformer + minifier
-const status = 1;
+// After transformer
+export let Status: {};
+export const status = 1;
+
+// After minifier
+export const status=1;
 ```
 
 ## Usage
@@ -79,11 +83,16 @@ const bundle = await rollup({
   input: "./src/index.ts",
   plugins: [
     typescript({
+      compilerOptions: {
+        target: "ESNext",
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        lib: ["DOM", "ESNext"],
+      },
       transformers: (program) => ({
         before: [
           optimizer(program, {
-            entrySourceFiles: ["./src/index.ts"],
-            inlineConstEnums: true,
+            entrySourceFiles: ["src/index.ts"],
           }),
         ],
       }),
@@ -107,6 +116,8 @@ await build({
 });
 ```
 
+**Note**: This plugin uses `@rollup/plugin-typescript`. The transformer receives a TypeScript `Program` object directly.
+
 ## Options
 
 ### entrySourceFiles (required)
@@ -156,7 +167,7 @@ class AppComponent {
 
 ### inlineConstEnums (optional, default: true)
 
-Inline const enum values and remove declarations.
+Inline const enum values and transform declarations to preserve export/import flow.
 
 ## Complete Example
 

package/package.json

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

package/src/const-enum/registry.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 import { EnumValue, EvaluationContext } from "./evaluator";
 import { EnumEvaluator } from "./evaluator";
 import { isConstEnumSymbol } from "./utils";
-import { hasModifier } from "../typescript-helpers";
+import { hasModifier } from "../utils/symbol-utils";
 
 export interface ConstEnumInfo {
   declaration: ts.EnumDeclaration;

package/src/index.ts

@@ -48,27 +48,9 @@ function createTransformerFactory(
       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 || node.isTypeOnly) {
-            return undefined;
-          }
-        }
-
-        if (ts.isExportSpecifier(node)) {
-          const removed = tryRemoveConstEnumExport(node);
-          if (removed === undefined || node.isTypeOnly) {
-            return undefined;
-          }
-        }
-
-        if (ts.isImportClause(node)) {
-          const removed = tryRemoveConstEnumImportClause(node);
-          if (removed === undefined) {
-            return undefined;
+          if (inlined) {
+            ts.setOriginalNode(inlined, node);
+            return inlined;
           }
         }
       }
@@ -575,7 +557,6 @@ function createTransformerFactory(
               return putToCache(nodeSymbol, VisibilityType.External);
             }
 
-            // TODO: mute enum renames
             if (ts.isEnumDeclaration(currentNode)) {
               return putToCache(nodeSymbol, VisibilityType.External);
             }
@@ -667,39 +648,22 @@ function createTransformerFactory(
 
       const memberValue = enumInfo.members.get(node.name.text)?.value;
       if (memberValue === undefined || memberValue === null) return null;
+      const newNode = enumEvaluator.createLiteral(memberValue);
 
-      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 tryRemoveConstEnumExport(node: ts.ExportSpecifier): ts.ExportSpecifier | 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;
+      const r = ts.setOriginalNode(newNode, node);
+      ts.setSourceMapRange(newNode, ts.getSourceMapRange(node));
+      (newNode as any).symbol = (node as any).symbol; // eslint-disable-line @typescript-eslint/no-explicit-any
+      return r;
     }
 
     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 (fullOptions.inlineConstEnums === false) {
+          return node;
+        }
+        if (!hasModifier(node, ts.SyntaxKind.ConstKeyword)) {
+          return node;
+        }
 
         if (sourceFile.isDeclarationFile) {
           return ts.factory.updateEnumDeclaration(
@@ -709,16 +673,30 @@ function createTransformerFactory(
             node.members,
           );
         }
-        return undefined;
+
+        return ts.factory.createVariableStatement(
+          [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          ts.factory.createVariableDeclarationList(
+            [
+              ts.factory.createVariableDeclaration(
+                node.name, // Reuse enum name
+                undefined,
+                ts.factory.createTypeLiteralNode([]), // Empty object type: {}
+                undefined, // No initializer (empty declaration)
+              ),
+            ],
+            ts.NodeFlags.Let, // Sets the 'const' modifier
+          ),
+        ) as unknown as ts.EnumDeclaration;
       }
 
       function wrapTransformNode(node: ts.Node): ts.Node | undefined {
         if (ts.isEnumDeclaration(node)) {
           const result = handleEnumDeclaration(node);
-          if (result === undefined) {
-            return undefined;
-          }
           if (result !== node) {
+            if (result) {
+              return transformNode(result);
+            }
             return result;
           }
         }

package/src/typescript-helpers.ts

@@ -1,204 +0,0 @@
-import ts from "typescript";
-
-const namedDeclarationKinds = [
-  ts.SyntaxKind.InterfaceDeclaration,
-  ts.SyntaxKind.ClassDeclaration,
-  ts.SyntaxKind.EnumDeclaration,
-  ts.SyntaxKind.TypeAliasDeclaration,
-  ts.SyntaxKind.ModuleDeclaration,
-  ts.SyntaxKind.FunctionDeclaration,
-  ts.SyntaxKind.VariableDeclaration,
-  ts.SyntaxKind.PropertySignature,
-  ts.SyntaxKind.Parameter,
-];
-
-export const isNodeNamedDeclaration = (node: ts.Node): node is ts.NamedDeclaration =>
-  namedDeclarationKinds.indexOf(node.kind) !== -1;
-
-export function getActualSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): ts.Symbol {
-  if (symbol.flags & ts.SymbolFlags.Alias) {
-    symbol = typeChecker.getAliasedSymbol(symbol);
-  }
-
-  return symbol;
-}
-
-export function splitTransientSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): ts.Symbol[] {
-  // actually I think we even don't need to operate/use "Transient" symbols anywhere
-  // it's kind of aliased symbol, but just merged
-  // but it's hard to refractor everything to use array of symbols instead of just symbol
-  // so let's fix it for some places
-  if ((symbol.flags & ts.SymbolFlags.Transient) === 0) {
-    return [symbol];
-  }
-
-  // "Transient" symbol is kinda "merged" symbol
-  // I don't really know is this way to "split" is correct
-  // but it seems that it works for now ¯\_(ツ)_/¯
-  const declarations = getDeclarationsForSymbol(symbol);
-  const result: ts.Symbol[] = [];
-  for (const declaration of declarations) {
-    if (!isNodeNamedDeclaration(declaration) || declaration.name === undefined) {
-      continue;
-    }
-
-    const sym = typeChecker.getSymbolAtLocation(declaration.name);
-    if (sym === undefined) {
-      continue;
-    }
-
-    result.push(getActualSymbol(sym, typeChecker));
-  }
-
-  return result;
-}
-
-export function getDeclarationsForSymbol(symbol: ts.Symbol): ts.Declaration[] {
-  const result: ts.Declaration[] = [];
-
-  if (symbol.declarations !== undefined) {
-    result.push(...symbol.declarations);
-  }
-
-  if (symbol.valueDeclaration !== undefined) {
-    // push valueDeclaration might be already in declarations array
-    // so let's check first to avoid duplication nodes
-    if (!result.includes(symbol.valueDeclaration)) {
-      result.push(symbol.valueDeclaration);
-    }
-  }
-
-  return result;
-}
-
-export function getExportsForSourceFile(typeChecker: ts.TypeChecker, sourceFileSymbol: ts.Symbol): ts.Symbol[] {
-  if (sourceFileSymbol.exports !== undefined) {
-    const commonJsExport = sourceFileSymbol.exports.get(ts.InternalSymbolName.ExportEquals);
-    if (commonJsExport !== undefined) {
-      return [getActualSymbol(commonJsExport, typeChecker)];
-    }
-  }
-
-  const result: ts.Symbol[] = typeChecker.getExportsOfModule(sourceFileSymbol);
-
-  if (sourceFileSymbol.exports !== undefined) {
-    const defaultExportSymbol = sourceFileSymbol.exports.get(ts.InternalSymbolName.Default);
-    if (defaultExportSymbol !== undefined) {
-      if (!result.includes(defaultExportSymbol)) {
-        // it seems that default export is always returned by getExportsOfModule
-        // but let's add it to be sure add if there is no such export
-        result.push(defaultExportSymbol);
-      }
-    }
-  }
-
-  return result.map((symbol: ts.Symbol) => getActualSymbol(symbol, typeChecker));
-}
-
-export type ClassMember =
-  | ts.MethodDeclaration
-  | ts.PropertyDeclaration
-  | ts.GetAccessorDeclaration
-  | ts.SetAccessorDeclaration;
-
-export const isClassMember = (node: ts.Node): node is ClassMember =>
-  ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node);
-
-export function getClassOfMemberSymbol(
-  nodeSymbol: ts.Symbol,
-): ts.ClassLikeDeclaration | ts.ObjectLiteralExpression | ts.TypeLiteralNode | ts.InterfaceDeclaration | null {
-  const classMembers = getClassMemberDeclarations(nodeSymbol);
-  if (classMembers.length !== 0) {
-    // we need any member to get class' declaration
-    const classMember = classMembers[0];
-    if (isConstructorParameter(classMember)) {
-      return (classMember.parent as ts.ConstructorDeclaration).parent;
-    }
-
-    // we're sure that it is a class, not interface
-    return classMember.parent as ts.ClassLikeDeclaration | ts.ObjectLiteralExpression;
-  }
-
-  return null;
-}
-
-export const hasPrivateKeyword = (node: ClassMember | ts.ParameterDeclaration) =>
-  hasModifier(node, ts.SyntaxKind.PrivateKeyword);
-
-function getModifiers(node: ts.Node): readonly ts.Modifier[] {
-  if (isBreakingTypeScriptApi(ts)) {
-    if (!ts.canHaveModifiers(node)) {
-      return [];
-    }
-
-    return ts.getModifiers(node) || [];
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  return node.modifiers || [];
-}
-
-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)) {
-    if (!ts.canHaveDecorators(node)) {
-      return [];
-    }
-
-    return ts.getDecorators(node) || [];
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  return node.decorators || [];
-}
-
-export const hasDecorators = (node: ts.Node) => getDecorators(node).length !== 0;
-
-export const isConstructorParameter = (node: ts.Node): node is ts.ParameterDeclaration =>
-  ts.isParameter(node) &&
-  ts.isConstructorDeclaration(node.parent as ts.Node) &&
-  (hasModifier(node, ts.SyntaxKind.PublicKeyword) ||
-    hasModifier(node, ts.SyntaxKind.ProtectedKeyword) ||
-    hasModifier(node, ts.SyntaxKind.PrivateKeyword) ||
-    hasModifier(node, ts.SyntaxKind.ReadonlyKeyword));
-
-function getClassMemberDeclarations(symbol: ts.Symbol | undefined): (ClassMember | ts.ParameterDeclaration)[] {
-  if (symbol === undefined) {
-    return [];
-  }
-
-  const declarations = symbol.getDeclarations();
-  if (declarations === undefined) {
-    return [];
-  }
-
-  return declarations.filter((x: ts.Declaration): x is ClassMember | ts.ParameterDeclaration => {
-    return isClassMember(x) || isConstructorParameter(x);
-  });
-}
-
-export const isSymbolClassMember = (symbol: ts.Symbol | undefined) => getClassMemberDeclarations(symbol).length !== 0;
-
-export const isPrivateClassMember = (symbol: ts.Symbol | undefined) =>
-  getClassMemberDeclarations(symbol).some(hasPrivateKeyword);
-
-export function getNodeJSDocComment(node: ts.Node): string {
-  const start = node.getStart();
-  const jsDocStart = node.getStart(undefined, true);
-  return node.getSourceFile().getFullText().substring(jsDocStart, start).trim();
-}
-
-// decorators and modifiers-related api added in ts 4.8
-interface BreakingTypeScriptApi {
-  canHaveDecorators(node: ts.Node): boolean;
-  getDecorators(node: ts.Node): readonly ts.Decorator[] | undefined;
-  canHaveModifiers(node: ts.Node): boolean;
-  getModifiers(node: ts.Node): readonly ts.Modifier[] | undefined;
-}
-
-const isBreakingTypeScriptApi = (compiler: object): compiler is BreakingTypeScriptApi =>
-  "canHaveDecorators" in compiler;