ts-transformer-optimize-const-enum
A typescript transformer that convert exported const enum into object literal.
This is just like the one from @babel/preset-typescript with optimizeConstEnums: true but it works for typescript compiler.
This will transform exported const enum from
export const enum MyEnum {
A,
B,
C,
D = 10,
E = C * 200,
}into object literal like this
export const MyEnum = {
A: 0,
B: 1,
C: 2,
D: 10,
E: 400,
} as const;and it also strips const in declaration file, to make your code compatible with --isolatedModules
// my-enum.d.ts
declare enum MyEnum { A: 0, ... }Why?
Const enum can only works in the same file. It works by inlining the exact value into code.
if (cond === MyEnum.A) { /*...*/ }will compile to the following code. That's a great inline optimization.
if (cond === 0 /* A */) { /*...*/ }However, const enums only work in the same file with isolateModules. Therefore, you can't use the exported const enum. The solution is to enable preserveConstEnums option to convert const enums to regular enums.
And the regular enum compiles to
export var MyEnum;
(function(MyEnum) {
MyEnum[MyEnum['A'] = 0] = 'A';
MyEnum[MyEnum['B'] = 1] = 'B';
MyEnum[MyEnum['C'] = 2] = 'C';
MyEnum[MyEnum['D'] = 10] = 'D';
MyEnum[MyEnum['E'] = 400] = 'E';
})(MyEnum || (MyEnum = {}));which is verbose. Not only can't you take advantage of enum inlining, but it also wastes a lot of bytes. That's the reason why this transform is made.
Although keys of object literals can't be tree-shaken by webpack, however, the exported object literals have no side effects like enums do. If one of your code-splitting chunks does not use it, it will be completely erased.
Installation
npm install ts-transformer-optimize-const-enum --save-devUsage
If you use vanilla TypeScript compiler, you can use this with ttypescript and compile with ttsc instead of tsc
ttypescript
// tsconfig.json
{
"compilerOptions": {
// ...
"plugins": [
{ "transform": "ts-transformer-optimize-const-enum" },
{ "transform": "ts-transformer-optimize-const-enum", "afterDeclarations": true },
]
},
// ...
}The afterDeclarations part is to strip out const keyword from declaration file.
webpack (with ts-loader or awesome-typescript-loader)
// webpack.config.js
const optimizeConstEnum = require('ts-transformer-optimize-const-enum').default;
module.exports = {
// ...
module: {
rules: [
{
test: /\.ts$/,
loader: 'ts-loader', // or 'awesome-typescript-loader'
options: {
getCustomTransformers: program => ({
before: [
optimizeConstEnum(program),
],
afterDeclarations: [
optimizeConstEnum(program),
],
}),
},
},
],
},
};Rollup (with @rollup/plugin-typescript or rollup-plugin-typescript2)
// rollup.config.js
import typescript from '@rollup/plugin-typescript';
import optimizeConstEnum from 'ts-transformer-optimize-const-enum';
export default {
// ...
plugins: [
typescript({
transformers: [service => ({
before: [
optimizeConstEnum(service.getProgram()),
],
afterDeclarations: [
optimizeConstEnum(service.getProgram()),
],
})],
}),
],
};