¿Declarar constantes estáticas en clases ES6?

Estoy usando babel y la siguiente sintaxis está funcionando para mí:

class MyClass {
    static constant1 = 33;
    static constant2 = {
       case1: 1,
       case2: 2,
    };
    // ...
}

MyClass.constant1 === 33
MyClass.constant2.case1 === 1

Tenga en cuenta que necesita el preset "stage-0".
Para instalarlo:

npm install --save-dev babel-preset-stage-0

// in .babelrc
{
    "presets": ["stage-0"]
}

Actualización:

Utilice actualmente stage-2

En este documento dice:

No existe (intencionalmente) una forma declarativa directa de definir propiedades de clase de datos prototipo (que no sean métodos) o propiedades de instancia

Esto significa que es intencionalmente así.

Tal vez usted puede definir una variable en el constructor?

constructor(){
    this.key = value
}

También es posible usar Object.freeze en su objeto class(es6)/constructor function(es5) para hacerlo inmutable:

class MyConstants {}
MyConstants.staticValue = 3;
MyConstants.staticMethod = function() {
  return 4;
}
Object.freeze(MyConstants);
// after the freeze, any attempts of altering the MyConstants class will have no result
// (either trying to alter, add or delete a property)
MyConstants.staticValue === 3; // true
MyConstants.staticValue = 55; // will have no effect
MyConstants.staticValue === 3; // true

MyConstants.otherStaticValue = "other" // will have no effect
MyConstants.otherStaticValue === undefined // true

delete MyConstants.staticMethod // false
typeof(MyConstants.staticMethod) === "function" // true

Tratar de alterar la clase le dará un soft-fail (no lanzará ningún error, simplemente no tendrá ningún efecto).

Como https://stackoverflow.com/users/2784136/rodrigo-botti dijo, creo que estás buscando Object.freeze(). He aquí un ejemplo de una clase con estática inmutable:

class User {
  constructor(username, age) {
    if (age < User.minimumAge) {
      throw new Error('You are too young to be here!');
    }
    this.username = username;
    this.age = age;
    this.state = 'active';
  }
}

User.minimumAge = 16;
User.validStates = ['active', 'inactive', 'archived'];

deepFreeze(User);

function deepFreeze(value) {
  if (typeof value === 'object' && value !== null) {
    Object.freeze(value);
    Object.getOwnPropertyNames(value).forEach(property => {
      deepFreeze(value[property]);
    });
  }
  return value;
}

class Whatever {
    static get MyConst() { return 10; }
}

let a = Whatever.MyConst;

Parece funcionar para mí.

Puede crear una forma de definir constantes estáticas en una clase utilizando una característica impar de las clases ES6. Dado que las estáticas son heredadas por sus subclases, puede hacer lo siguiente:

const withConsts = (map, BaseClass = Object) => {
  class ConstClass extends BaseClass { }
  Object.keys(map).forEach(key => {
    Object.defineProperty(ConstClass, key, {
      value: map[key],
      writable : false,
      enumerable : true,
      configurable : false
    });
  });
  return ConstClass;
};

class MyClass extends withConsts({ MY_CONST: 'this is defined' }) {
  foo() {
    console.log(MyClass.MY_CONST);
  }
}

Aquí hay una forma más que puedes hacer

/*
one more way of declaring constants in a class,
Note - the constants have to be declared after the class is defined
*/
class Auto{
   //other methods
}
Auto.CONSTANT1 = "const1";
Auto.CONSTANT2 = "const2";

console.log(Auto.CONSTANT1)
console.log(Auto.CONSTANT2);

Nota-el Orden es importante, no puede tener las constantes anteriores

Uso consola.log (Auto.CONSTANTE 1);