javascript - Starkt typade Immutable.js Records i TypeScript

Jag kan inte hitta en bra resurs för denna fråga. I princip vill jag beskriva typer för mina data med ett gränssnitt i TypeScript, men mina data är Immutable.js-poster vilket verkar komplicera saker, se mitt exempel nedan.

interface tree extends Immutable.Map<string, any> {
  readonly id: number,
  readonly type: number
}

let trees = Immutable.List<tree[]>([
  Map<tree>({
     id: 101,
     type: 1
  }),
  Map<tree>({
     id: 201,
     type: 3
  })
])

Frågor med det ovanstående:

1. Varför måste jag upprepa typen för varje karta i min lista? Borde inte typen helt enkelt deklareras av <tree[]> när listan skapas? Och sedan ska varje karta som läggs till i listan typkontrolleras mot detta?
2. För närvarande ger detta exempel fel, vilket säger att "egenskapen 'id' är inkompatibel med indexsignaturen. Typen 'number' kan inte tilldelas typen 'tree'". Vilket är förståeligt! Men när jag läser dokumentationen kan jag inte lista ut hur jag ska få det att fungera? När jag läser dokumentationen står det att jag behöver ett ID, men jag vill ha en array av mappar, min signatur i detta fall är bara standard array-ID:n om jag inte har fel?

Jag har arbetat med det här i flera dagar och jag kan helt enkelt inte få det att fungera, det borde vara så här enkelt enligt allt jag har läst.

All hjälp skulle uppskattas mycket.

Svar #1

Du skapar en List av arrays av trees, vilket är en utökad Map. Så här ska det se ut:

let trees = Immutable.List<tree[]>(
    [ // List
        [ // Array
            <tree>Immutable.Map<any>({
                id: 101,
                type: 1
            }),
            <tree>Immutable.Map<any>({
                id: 201,
                type: 3
            })
        ]
    ]
);

Att svara på dina frågor:

1. Du upprepar inte typen av varje karta. Faktiskt, du anropar en metod Map som bygger en karta från ett objekt. Jag lade till <tree> typen eftersom det är en array av trees, inte kartor.

2. Du försöker något som:

   var singleTree: tree = Immutable.Map<tree>(
       { id: 101, type: 1 }
   );
   

   Men ditt träd är en karta av typen any. Så här är den rätta syntaxen:

   let singleTree: tree = <tree>Immutable.Map<any>(
       { id: 101, type: 1 }
   );
   

För koden ovan kan vi förenkla och tvinga en typkontroll om vi skapar en tree-funktion för att omsluta Map-funktionen, så den slutliga lösningen skulle vara:

function tree(obj: { [key: string]: any, id: number, type: number }): tree {
    return <tree>Immutable.Map<any>(obj);
}

let trees = Immutable.List<tree[]>(
    [ // List
        [ // Array
            tree({
                id: 101,
                type: 1
            }),
            tree({
                id: 201,
                type: 3
            })
        ]
    ]
);