Enum de Typescript que encapsula un valor booleano por instancia de enum

En Typescript, ¿cuál es la manera idiomática de tener un valor booleano asignado para cada instancia de un enum?

Supongamos que tengo un enum para varios códigos de error. Para cada uno de los códigos de error, tengo un booleano que indica si el error debe ser expuesto al usuario final o no. En Java, lo haría así,

enum MyError {
    ERROR1(true),
    ERROR2(false),
    ERROR3(false);

    private boolean expose;

    public boolean shouldExpose() {
        return expose;
    }

    MyError(boolean expose) {
        this.expose = expose;
    }
}

Aquí, la información booleana (si el error debe ser mostrado al usuario o no) está encapsulada dentro del propio enum.

 MyError myError = MyError.ERROR1;
 System.out.println(myError.shouldExpose()); //true

¿Cómo puedo hacer esto en Typescript ya que TS no permite valores booleanos en enums? ¿Debería usar una clase o un tipo aquí?

El objetivo es tener la información booleana contenida en el enum/clase/tipo. Por lo tanto, no quiero crear un tipo envoltorio como

{
    error: MyError
    expose: boolean
}

ya que puede llevar a configuraciones/mapeos incorrectos (se vuelve posible tener MyError.ERROR1 con expose como falso o viceversa para otros errores).

Respuesta #1

Podrías querer renunciar a los enums reales y, en su lugar, crear tu propio conjunto de constantes. Es más prolijo, pero podría satisfacer tus necesidades.

const MyError = {
  error1: {
    name: 'ERROR1',
    expose: true
  },
  error2: {
    name: 'ERROR2',
    expose: false
  },
  error3: {
    name: 'ERROR3',
    expose: false
  }
} as const;

type MyError = typeof MyError[keyof typeof MyError]


function x(err: MyError) {
  console.log(err);
}

x(MyError.error1);
x({name: 'ERROR1', expose: true});
x({name: 'ERROR1', expose: false}); // EXPECTED ERROR

function getError(): MyError {
  return MyError.error1;
}

var e: MyError = getError();
console.log(MyError.error1 == e);  // true
console.log(MyError.error2 == e);  // false

Enlace del parque

Respuesta #2

Si no te importa el orden numérico, entonces podrías aprovechar los enumerados numéricos, por ejemplo.

enum MyError  {
  ERROR1 = 1,
  ERROR2 = 0,
  ERROR3 = 0,
}

console.log(MyError.ERROR1); // 1 == true
console.log(MyError.ERROR2); // 0 == false
console.log(MyError.ERROR3); // 0 == false

console.log(Boolean(MyError.ERROR1)); // true
console.log(Boolean(MyError.ERROR2)); // false
console.log(Boolean(MyError.ERROR3)); // false

EDITAR :

Podrías usar la fusión de espacios de nombres, por ejemplo.

namespace MyError {
    export function shouldExpose(error:MyError) {
        return Boolean(error);
    }
}

console.log(MyError.shouldExpose(MyError.ERROR1)); // true