What do I specify if I intend to accept an Enum as a parameter/type parameter?

[ornate crystal]

nop#2745

Playground Link

Preview:```ts
enum Perm {
Read = 0b01,
Write = 0b11,
}

class EnumWrapper<
O extends Record<string, number> &
Record<number, string>

{
constructor(public o: O) {
//
}

toNumber(p: string | number): number {
if (typeof p === number) {
return
...```

You can choose specific lines to embed by selecting them before copying the link.

[untold bison]

Record<string, number> & Record<number, string>

[urban mica]

!closed

[ornate crystal]

@untold bison
Because your issue seemed to be resolved, this post was marked as resolved by @urban mica.
If your issue is not resolved, you can reopen this post by running !reopen.
If you have a different question, make a new post in #1057653400046674112.

[untold bison]

@urban micawhat is Enum's type?

[urban mica]

@untold bison Oh, I closed the thread because the original message was deleted and thought your message was an answer.

!reopen

[untold bison]

no worries

[sterile ruin]

the issue here is that number index signatures are actually string index signatures too

so idk if there's a way to solve this perfectly

[untold bison]

whats the type for enums when its a numeric enum

I intend users to pass in a numeric enum

since it does bit operations

[sterile ruin]

the type is basically right

it's just that the string index signature must also contain the number index signature

[ornate crystal]

n_n#2622

Playground Link

Preview:ts // 8< ...

[sterile ruin]

!ts

[ornate crystal]

// 8<
enum Perm {
  Read = 0b01,
  Write = 0b11,
}


class EnumWrapper<O extends Record<string, number | string> & Record<number, string>> {
  constructor(public o: O) {
    //
  }

  toNumber(p: string | number): number {
    if (typeof p === `number`) {
      return p;
    }
    return this.o[p] as number;
  }
}

const p = new EnumWrapper(Perm)

[untold bison]

whtas 8< btw? i see you putting that alot

[untold bison]

this is so weird though
implications can be

1. typescript does not differentiate between string and number enums
2. all enums are heterogeneous enums
3. typescript allows runtime safety?

so, Record<string, number | string> & Record<number, string> is the correct type?

also, why doesn't the typescript handbook explain this

[lilac sun]

enum Perm {
  Read = 0b01,
  Write = 0b11,
}


class EnumWrapper<O extends Record<string, any>> {
  constructor(public o: O) {}

  toNumber(p: string | number): number {
    if (typeof p === `number`) {
      return p;
    }
    return this.o[p];
  }
}

const p = new EnumWrapper(Perm)

[sterile ruin]

ascii art scissors

[untold bison]

looks cool

[untold bison]

any here is unnecessary and bad

[sterile ruin]

i (sometimes) select it before copying if i want to !ts

[untold bison]

does !ts recognize // 8<

[sterile ruin]

idk why, i guess i just think !ts output looks better sometimes

[sterile ruin]

nah. but if you have anything selected, the bot displays only your selection

[sterile ruin]

(see here)

[lilac sun]

Enum process to tsc will be compiled to object, so it's good to use Record<string, any>

[untold bison]

that is interesting

[untold bison]

id rather use unknown if i need any

[sterile ruin]

i'm not sure if there are better solutions btw - i was trying something to do with

function permGet(k: keyof typeof Perm) { return Perm[k]; }

but that's hard to constrain

wait

[lilac sun]

sure, that's just a generic

[untold bison]

Perm[string] SHOULD work or else typescript needs enum rewrite

[lilac sun]

no real type when using the function

[ornate crystal]

n_n#2622

Playground Link

Preview:ts // 8< ...

[sterile ruin]

!ts

[ornate crystal]

// 8<
enum Perm {
  Read = 0b01,
  Write = 0b11,
}

class EnumWrapper<O extends Record<string, number | string> & Record<number, string>> {
  constructor(public o: O, private get_: (k: keyof O) => number) {
    //
  }

  toNumber(p: string | number): number {
    if (typeof p === `number`) {
      return p;
    }
    return this.get_(p);
  }
}

const p = new EnumWrapper(Perm, k => Perm[k]);

[sterile ruin]

no type errors :D

of course, the issue is that you'd have to type out the function every time

[ornate crystal]

n_n#2622

Playground Link

Preview:ts ... enum EmptyEnum {} class EnumWrapper<O extends typeof EmptyEnum> { const ...

[sterile ruin]

wait

oh no

[sterile ruin]

idk why get_ doesn't error here

very mysterious

[sterile ruin]

this errors on get_, which i'm pretty sure is correct

[lilac sun]

enum is a literal object

[urban mica]

@sterile ruin FYI you can now 'escape' playground ulrs with < > to omit the preview entirely (e.g. if you're already pasting the code into the chat)

[ornate crystal]

Retsam19#2505

Playground Link

[sterile ruin]

oh

very cool

[untold bison]

wait so like put url in <>

[sterile ruin]

yea

<https://playground url here>

[untold bison]

ok