Hacker News Reader

Const objects really are better than enums, in every way except declaration brevity.

They're erasable syntax, so they work in environments that just strip types. Their emit is just what you write without the types. They can be composed in a type-safe way with standard JS operations.

You can still write JS docs for values, deprecated the, mark them as internal, etc.

    type ValueOf<T> = T[keyof T];

    const Foo = {
      /**
       * A one digit
       * @deprecated
       */
      one: '1',
      two: '2',
      three: '3'
    } as const;
    type Foo = ValueOf<typeof Foo>;

    const Bar = {
      blue: 'blue',
    } as const;
    type Bar = ValueOf<typeof Bar>;

    // You can union enum objects:
    const FooOrBar = {...Foo, ...Bar};
    // And get union of their values:
    type FooOrBar = ValueOf<typeof FooOrBar>;

    const doSomething = (foo: Foo) => {}

    // You can reference values just like enums:
    doSomething(Foo.two);

    // You can also type-safely reference enum values by their
    // key name:
    doSomething(Foo['two']);

Given the TypeScript team's stance on new non-erasable syntax, I have to think this is how they would have gone if they had `as const` from the beginning. Ron Buckton of the TS team is championing an enum proposal for JS: https://github.com/rbuckton/proposal-enum Hopefully that goes somewhere and improves the declaration side of thigns too.

View on HN

const PossibleStates = ["test", "me"] as const type SumTypeFromArray = (typeof PossibleStates)[number] let x: SumTypeFromArray = "this string triggers a type error as it is neither 'test' nor 'me'"

type A = { type: { name: "A" } a: number, b: undefined, } type B = { type: { name: "B" } b: number, a: undefined, } const aOrB: A | B = { type: { name: "A" }, a: 1, b: undefined }; // error as expect if (aOrB.type.name === "B") { console.log(aOrB.b) // Error } function hasTypeName<Name extends string>(a: { type: { name: string }}, name: Name): a is { type: { name: Name }} { return a.type.name === name } if (hasTypeName(aOrB, "B")) { console.log(aOrB.b) // no error } if (hasTypeName(aOrB, "A")) { console.log(aOrB.a) // no error here as well }

type Enum<T> = { [K in keyof T]: T[K] & {__brand: never}; } const _Foo = { one: '1', two: '2', three: '3' } as const; const Foo = _Foo as Enum<typeof _Foo>; type Foo = ValueOf<typeof Foo>;

enum Bar { No = 'No', Yes = 'Yes', } function doSomethingBar(message: Bar): void { } // no type error doSomethingBar(Bar.No); // type error doSomethingBar('No'); enum Bar2 { No = 'No', Yes = 'Yes', } // type error doSomethingBar(Bar2.No);

import { Foo as Foo2, doSomething } from './enums' // And now, this will work: doSomething(Foo2.two); // But this will error: doSomething('2'); // this is also an error since the type is not exported doSomething('2' as Foo2); type Enum<T> = { [K in keyof T]: T[K] & {__brand: T}; } const _Foo = { one: '1', two: '2', three: '3' } as const; export const Foo = _Foo as Enum<typeof _Foo>; type ValueOf<X> = X[keyof X]; type Foo = ValueOf<typeof Foo>; // no type error doSomething(Foo.two);

const Foo: unique symbol = Symbol("Foo"); const Bar: unique symbol = Symbol("Bar"); const MyEnum = { Foo, Bar, } as const; declare namespace MyEnum { type Foo = typeof MyEnum.Foo; type Bar = typeof MyEnum.Bar; } type MyEnum = typeof MyEnum[keyof typeof MyEnum]; export {MyEnum};