feat: implement this project

Author: Fonger

.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+dist

.eslintrc

@@ -0,0 +1,14 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "rules": {
+    "@typescript-eslint/no-unused-vars": ["error", { "args": "none" }]
+  }
+}

.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+
+*.log
+*.swp
+.DS_Store

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+  "recommendations": [
+    "dprint.dprint"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+  "editor.formatOnSave": true,
+  "[javascript]": {
+    "editor.defaultFormatter": "dprint.dprint"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "dprint.dprint"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "dprint.dprint"
+  },
+  "dprint.path": "./node_modules/dprint/bin.js",
+}

README.md

@@ -0,0 +1,55 @@
+# ts-transformer-optimize-const-enum
+
+A typescript transpiler that transform exported const enum into object literal! This is just like the one from [@babel/preset-typescript or @babel/plugin-transform-typescript with optimizeConstEnums: true](https://babeljs.io/docs/en/babel-preset-typescript#optimizeconstenums) but it works for typescript compiler.
+
+This will transform exported const enum from
+
+```ts
+export const enum MyEnum {
+  A,
+  B,
+  C
+  D = 10,
+  D = C * 200
+}
+```
+
+into object literal like this
+
+```ts
+export const MyEnum {
+  A: 0,
+  B: 1,
+  C: 2,
+  D: 10,
+  E: 400
+}
+```
+
+while stripping const in declaration file, to make your code compatible with `--isolatedModules`
+
+```ts
+declare enum MyEnum { ... }
+```
+
+## Why?
+WIP
+
+# Usage
+
+WIP
+
+# Caveats
+
+Currently, only immediate export const enum works. For example:
+This will be fixed in later version.
+
+```ts
+// The following works
+export const enum WorkingEnum {}
+
+// The following doesn't work
+const enum FailingEnum {}
+export FailEnum;
+```
+

dprint.json

@@ -0,0 +1,22 @@
+{
+  "incremental": true,
+  "indentWidth": 2,
+  "typescript": {
+    "arrowFunction.useParentheses": "preferNone",
+    "quoteStyle": "preferSingle"
+  },
+  "json": {
+  },
+  "markdown": {
+  },
+  "includes": ["**/*.{ts,tsx,js,jsx,cjs,mjs,json,md}"],
+  "excludes": [
+    "**/node_modules",
+    "**/*-lock.json"
+  ],
+  "plugins": [
+    "https://plugins.dprint.dev/typescript-0.62.2.wasm",
+    "https://plugins.dprint.dev/json-0.14.1.wasm",
+    "https://plugins.dprint.dev/markdown-0.12.2.wasm"
+  ]
+}

package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ts-transformer-optimize-const-enum",
+  "version": "0.0.1",
+  "description": "A TypeScript transformer that optimize exported const enum into object literal",
+  "main": "dist/cjs/index.js",
+  "module": "dist/ejs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "repository": "git@github.com:Fonger/ts-transformer-optimize-const-enum.git",
+  "author": "Fonger <5862369+Fonger@users.noreply.github.com>",
+  "license": "MIT",
+  "keywords": [
+    "typescript",
+    "typescript-transformer",
+    "transformer",
+    "optimize",
+    "const-enum",
+    "object-literal",
+    "ttypescript"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && yarn build:cjs && yarn build:ejs",
+    "build:cjs": "tsc --outDir dist/cjs --declaration",
+    "build:ejs": "tsc --outDir dist/ejs --module es6"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.10.2",
+    "@typescript-eslint/parser": "^5.10.2",
+    "dprint": "^0.22.0",
+    "eslint": "^8.8.0",
+    "ttypescript": "^1.5.13",
+    "typescript": "^4.5.5"
+  },
+  "peerDependencies": {
+    "typescript": ">=3.2.2"
+  }
+}

src/index.ts

@@ -0,0 +1 @@
+export { default as transform } from './transform';

src/transform.ts

@@ -0,0 +1,109 @@
+import ts from 'typescript';
+import { evaluate, hasModifier } from './utils';
+
+export default function(program: ts.Program, pluginOptions: unknown) {
+  return (ctx: ts.TransformationContext) => {
+    return (sourceFile: ts.SourceFile) => {
+      const ambient = sourceFile.isDeclarationFile;
+
+      return ts.visitEachChild(sourceFile, visitor, ctx);
+
+      function visitor(node: ts.Node): ts.Node {
+        if (!ts.isEnumDeclaration(node)) {
+          return ts.visitEachChild(node, visitor, ctx);
+        }
+        if (
+          !hasModifier(node, ts.SyntaxKind.ExportKeyword)
+          || !hasModifier(node, ts.SyntaxKind.ConstKeyword)
+        ) {
+          return node;
+        }
+
+        if (ambient) {
+          return ts.visitEachChild(node, stripConstKeyword, ctx);
+        }
+
+        return transformEnum(node);
+      }
+    };
+  };
+
+  function stripConstKeyword(node: ts.Node) {
+    return node.kind === ts.SyntaxKind.ConstKeyword ? undefined : node;
+  }
+
+  function transformEnum(node: ts.EnumDeclaration) {
+    const members = node.members;
+    const known = new Map<string, number | string>();
+    const ast = [];
+    let lastValue: string | number = -1;
+
+    for (const member of members) {
+      if (!ts.isIdentifier(member.name)) {
+        throw new Error('The name of enum member must be an identifier');
+      }
+      const name = member.name.getText();
+      let value: string | number;
+
+      if (member.initializer) {
+        value = evaluate(member.initializer, known);
+        let valueExpr: ts.Expression;
+        if (typeof value === 'number') {
+          valueExpr = ts.factory.createNumericLiteral(value);
+          lastValue = value;
+        } else if (typeof value === 'string') {
+          valueExpr = ts.factory.createStringLiteral(value);
+          lastValue = value;
+        } else throw new Error('Unsupported member value');
+
+        ast.push(ts.factory.createPropertyAssignment(name, valueExpr));
+      } else {
+        if (typeof lastValue === 'string') {
+          throw new Error('Invalid enum');
+        }
+        /**
+         * last known value+1
+         * enum MyEnum {
+         *   A = 5,
+         *   B, // implicit 6
+         *   C, // implicit 7,
+         *   D = 1000,
+         *   E, // implicit 1001
+         * }
+         */
+        value = ++lastValue;
+        ast.push(
+          ts.factory.createPropertyAssignment(
+            name,
+            ts.factory.createNumericLiteral(value),
+          ),
+        );
+      }
+      known.set(name, value);
+    }
+
+    return ts.factory.createVariableStatement(
+      [
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+        ts.factory.createModifier(ts.SyntaxKind.ConstKeyword),
+      ],
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            node.name,
+            undefined,
+            undefined,
+            ts.factory.createAsExpression(
+              ts.factory.createObjectLiteralExpression(ast, true),
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createIdentifier('const'),
+                undefined,
+              ),
+            ),
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+  }
+}