Aufzählung innerhalb der Klasse (TypeScript-Definitionsdatei)

Ich habe mich umgesehen, kann aber anscheinend keine Antwort darauf finden. Hoffentlich können Sie helfen. Wie kann ich Image eine Aufzählung hinzufügen? Dies ist, was ich idealerweise möchte, aber ich bekomme eine Fehlermeldung.

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();

    }

  }

}

Wenn ich State in das Grafikmodul verschiebe, funktioniert es, aber jetzt gehört State zu Graphics ... was falsch ist, muss es Teil von Image sein.

Irgendwelche Ideen? Vielen Dank

Ich denke, das Folgende ist eine Verbesserung der KoenT-Lösung:

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

    state: Image.State;
}

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

Der Vorteil ist, dass Sie benannte Importe nutzen können:

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

Hier ist meine Lösung.

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);
    }
}

Verwendung:

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

program.status = Program.Status.New;

oder

program.status = program.Status.New;

Zusätzlicher Vorteil für Angular 2+ -Benutzer: Dies kann in Vorlagen verwendet werden

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

Ich bin kürzlich auch auf dieses Problem gestoßen. Folgendes verwende ich derzeit als Lösung:

// 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;

Dann an der Stelle, an der ich die Klasse und ihre Aufzählung verwende:

import Image = require("Image");

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

Dies scheint gut zu funktionieren (obwohl ich es nicht als den erwarteten Weg betrachte, so etwas zu tun).

Hoffentlich gibt es in TypeScript eine Möglichkeit, dies folgendermaßen zu tun:

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

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

    state: State;
}

export = Image;

Ich denke, dass dieses Zeug mit Modulerweiterung eine sehr hackige und nicht intuitive * Art ist, Dinge zu tun, also bedenken Sie Folgendes:

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;

Das heißt, deklarieren Sie einfach die Aufzählung im Bereich der Klasse, zu der Sie sie hinzufügen möchten, ohne sie zu exportieren, und machen Sie sie dann über ein Mitglied der Klasse verfügbar.

_{* Was in Bezug auf Strukturierung und Organisation von Code schlecht ist, auch wenn es technisch funktioniert.}

Aktualisieren

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;

Dann tippen Sie wie folgt:

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

Ich glaube, ich habe vielleicht eine Lösung gefunden ... ob es sich um gültiges TypeScript handelt, weiß ich nicht, aber es funktioniert und verursacht keine Kompilierungsfehler. Es ist eine Kombination der obigen Antworten.

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();
    }

  }

}

Kann jemand mögliche Probleme damit erkennen, die ich nicht bemerkt habe?

Ich bin mir nicht sicher, was Sie vorhaben, aber ich hätte erwartet, dass Sie enumdie möglichen Statuswerte darstellen und dann ein stateMitglied auf dem Bild, um den aktuellen Status des Bildes anzuzeigen.

declare module 'Lib' {
    export module Graphics {

        enum State {
            STATE_IDLE,
            STATE_LOADING,
            STATE_READY,
            STATE_ERROR
        }

        export class Image {
            public state: State;

            constructor();
        }

    }
}

Es hört sich so an, als ob Sie eine Klasse mit enumähnlichen Mitgliedern deklarieren möchten, anstatt eine Enumeration innerhalb einer Klasse zu deklarieren. dh:

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();
        }
    }
}

Sie können ein Modul und eine Klasse mit demselben Namen erstellen. Es kann auch hilfreich sein, Ihre Aufzählung umzubenennen, damit Sie nicht Statezweimal sagen müssen :

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

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