template - Enum inside class(archivo de definición de TypeScript)

typescript template

Question

He buscado pero no puedo encontrar una respuesta para esto, espero que puedas ayudar. ¿Cómo puedo agregar una enumeración a la imagen? Esto es lo que me gustaría idealmente, pero me sale un error.

declare module ''Lib'' {

  export module Graphics {

    export class Image {

      enum State {}

      static STATE_IDLE: State;
      static STATE_LOADING: State;
      static STATE_READY: State;
      static STATE_ERROR: State;

      constructor();

    }

  }

}

Si muevo estado al módulo de gráficos, funciona, pero ahora el estado pertenece a Graphics ... que es incorrecto, necesita ser parte de Image.

¿Algunas ideas? Gracias

Answer 1

Aquí está mi solución.

program.ts:

enum Status {
    Deleting,
    Editing,
    Existing,
    New
}

export class Program {
    static readonly Status = Status;
    readonly Status = Program.Status;

    title: string;

    status: Status;

    constructor(init?: Partial<Program>) {
        Object.assign(this, init);
    }
}

Uso:

let program = new Program({ title: `some title` });

program.status = Program.Status.New;

o

program.status = program.Status.New;

Beneficio adicional para usuarios de Angular 2+: esto se puede usar en plantillas

<div *ngIf="program.status === program.Status.New">
  Only display if status of the program is New
</div>

Answer 2

Creo que estas cosas con el aumento de módulos es una forma muy hacky y no intuitiva * de hacer las cosas, así que ten en cuenta esto:

export module Graphics
{
    enum State
    {
        STATE_IDLE,
        STATE_LOADING,
        STATE_READY,
        STATE_ERROR
    }

    export class Image
    {
        constructor() { }
        public static readonly State = State;
    }
}

//...

let imgState = Graphics.Image.State.STATE_ERROR;

Es decir, solo declare la enumeración en el alcance de la clase a la que desea agregarla sin exportarla, luego expongala a través de un miembro de la clase.

_{* Que en lo que respecta a la estructuración y organización del código es MALO, incluso si funciona técnicamente.}

Actualizar

declare module Lib
{
    enum State
    {
        STATE_IDLE,
        STATE_LOADING,
        STATE_READY,
        STATE_ERROR
    }

    class ImageClass
    {
        constructor();
        public Prop: any;
    }

    export interface Graphics
    {
        Image: typeof State & ImageClass & (new () => typeof State & ImageClass);
    }
}

declare var Graphics: Lib.Graphics;

Luego escribes como:

var someEnum = Graphics.Image.STATE_ERROR;
var image = new Graphics.Image();
var anotherEnum = image.STATE_IDLE;

Answer 3

Creo que lo siguiente es una mejora en la solución más votado:

export class Image
{
    constructor ()
    {
        this.state = Image.State.Idle;
    }

    state: Image.State;
}

export namespace Image
{
    export enum State
    {
        Idle,
        Loading,
        Ready,
        Error
    }
}

La ventaja es que puede aprovechar importaciones con nombre:

import {Image} from ''./image'';
let img = new Image()
img.state = Image.State.Error

Answer 4

Creo que puedo haber encontrado una solución ... si es un TypeScript válido, no lo sé, pero funciona y no causa ningún error de compilación. Es una combinación de las respuestas anteriores.

declare module ''Lib'' {

  module Graphics {

    module Image {
      enum State { }
      var STATE_IDLE: State;
      var STATE_LOADING: State;
      var STATE_READY: State;
      var STATE_ERROR: State;
    }

    class Image {
      constructor();
    }

  }

}

¿Alguien puede detectar posibles problemas con esto que no haya notado?

Answer 5

No estoy seguro de lo que pretende hacer, pero hubiera esperado que quisiera una enum para representar los valores de estado posibles, y luego un miembro de state en la imagen para indicar el estado actual de la imagen.

declare module ''Lib'' {
    export module Graphics {

        enum State {
            STATE_IDLE,
            STATE_LOADING,
            STATE_READY,
            STATE_ERROR
        }

        export class Image {
            public state: State;

            constructor();
        }

    }
}

Parece que desea declarar una clase que tiene miembros enumáticos, en lugar de declarar una enumeración dentro de una clase. es decir:

declare module ''Lib'' {

    export module Graphics {

        export class Image {
            static STATE_IDLE: number;
            static STATE_LOADING: number;
            static STATE_READY: number;
            static STATE_ERROR: number;

            constructor();
        }
    }
}

Answer 6

Podría crear un módulo y una clase con el mismo nombre. También podría ser útil cambiar el nombre de tu enumeración para que no tengas que decirlo dos veces:

declare module ''Lib'' {
    export module Graphics {
        export class Image {
            constructor();
        }

        export module Image {
            export enum State {
                Idle,
                Loading,
                Ready,
                Error
            }
        }
    }
}

Answer 7

También me topé con este problema recientemente. Esto es lo que estoy usando actualmente como una solución:

// File: Image.ts

class Image
{
    constructor()
    {
        this.state = Image.State.Idle;
    }

    state: Image.State;
}

module Image
{
    export enum State
    {
        Idle,
        Loading,
        Ready,
        Error
    }
}

export = Image;

Luego, en el lugar donde estoy usando la clase y su enum:

import Image = require("Image");

let state = Image.State.Idle;
let image = new Image();
state = image.state;

Esto parece funcionar bien (aunque no lo considero como la forma esperada de hacer este tipo de cosas).

Esperemos que haya una forma en TypeScript de hacerlo de esta manera:

class Image
{
    enum State
    {
        Idle,
        Loading,
        Ready,
        Error
    }

    constructor()
    {
        this.state = State.Idle;
    }

    state: State;
}

export = Image;