Generate enum type from polyvar?

[adnelson]

If I have some code like this:

[@genType]
type color = [ | `Red | `Blue ];

then gentype will create a binding like

export type color = 
    "Red"
  | "Blue";

I was looking at the options and I'm not sure if I missed it but is there a way to generate an enum like

export enum color {
  "Red" = "Red",
  "Blue" = "Blue"
};

?

[cristianoc]

@adnelson there are no options to generate enums.

[adnelson]

Would this be desirable? The use case I'm looking at now is the nexus graphql schema library, which can take a JS enum and produce a graphql enum type.

Hypothetically:

[@genType.enum]
type color = [ | `Red | `Blue ];

Or alternatively, via a flag in gentypeconfig like

{
  "gentypeconfig": {
    "variantStyle": "enum"
  }
}

If this is something you might be interested in, I can try my hand at implementing it.

[cristianoc]

@adnelson how about starting by exploring the design, then see how that fits.

A couple of first questions:

• What variants map to enums? Only variants without payload?
• When looking at enums, I see things like Up = "UP", not identical "UP" = "UP". And more in general, only a subset of enums will be representable.
• Is there any runtime conversion required to operate with enums?
• What about the Flow back-end.

[adnelson]

I'll circle back on the design, my initial thoughts regarding your Q's:

• Only variants without a payload supported
• Simplest would be to only support enums where the field name and the value match -- this is how all of our enums look anyway, but if need be, a ppx annotation could solve that (e.g. pseudo: | [@genType.as "UP"] `Up)
• I don't think so. Given code like this:

export enum MyEnum {
  Foo = "Foo",
  Bar = "BAR",
};

tsc will emit code like this

var MyEnum;
(function (MyEnum) {
    MyEnum["Foo"] = "Foo";
    MyEnum["Bar"] = "BAR";
})(MyEnum || (MyEnum = {}));
;

Which means that at runtime MyEnum.Foo === "Foo".

• I think flow only supports the union syntax, so flow users simply wouldn't need this feature. But if desired, code such as described here could be generated

const myEnumValues = {
  Foo: "Foo",
  Bar: "BAR",
};

type MyEnum = $Keys<typeof myEnumValues>;

[cristianoc]

Looks like in TS a value of enum type also has union type, but not the other way round. Not sure why that is the case if the runtime representation is the same.

[cristianoc]

OK looks like color.Red is nominally typed, so it's a different type than "Red".

[cristianoc]

Poly variants are structurally typed, so mapping them to a nominal type has a few footguns, e.g. you can't rely on type inference. E.g. if you export @genType let red = `Red it won't have type color.

[cristianoc]

@adnelson could you explain the use case with nexus graphql a bit more in detail? And whether there are other use cases.

[cristianoc]

If the use case is worth it, it could be an experimental feature.

[cristianoc]

Happy to continue the convo if there's still interest? Or we can close this otherwise.

[ryyppy]

This repository is being archived. If you feel like the issue still relevant, please re-create it in the compiler repo. Thanks!