Les génériques, cela n'est pas automatique !

Bonjour,

Je rencontre des problèmes pour utiliser correctement les génériquezs de TypeScript sur des types de base tels que les Maps ES2015 ou des types personnalisés comme des classes. Je précise que j'utilise TYpeScript dansune application Vite (vanilla TS)

Si j'écris:

Code:

1
2
3
4
5
 
const m: Map <number, number> = new Map()
 
// le compilateur laisse passer cela:
m.set('abcd', 'efgh')

Peut être y'a til une option de tsconfig.json mal positionnée ?

Le pire vient quand je tente d'encapsuler une liste d'items portant des données et ayant un UID (string 5 caractères alphanumériques minuscule + '_' = 37 valeurs possibles) avec un Map de lookup:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
import { MWCRand } from './MWCRand.ts'
import { TDRUID, key2values, values2key  } from 'TDRUID.ts'
import { TDataBlock } from './TDataBlock.ts'
 
export class DataBlocksRepo <T> {
    // PNRG
    protected _generator = new MWCRand')
 
    // liste pouir le stockage d'items et les filtrages/map/reduce
    protected _entries: TBataBlock<T>[] = []
 
    // table d'accès en O(1) sur les items
    protected _lokkups: Map <TDRUID, TBataBlock<T>> = new Map()
 
    constructor () { 
        this._generator = new MWCRand({
            multiplier: 34567,
            modulus: 37,
            length: 5
        })
 
        this._generator.init([3, 4, 5, 6, 7])
 
// ou...
//        this._generator.init(key2values('_uid_'))
    }
 
    add (datum: T): TDRUID {
        let uid: TDRUID
        let block: TDataBlock <T>
 
        do {
            // tant que le générateur génçre une collision 
            // on calcule un autre UID
 
            // MWC produit 93% de valeurs distinctes quand on l'applique  1M fois
            // nombre de clés possibles = Math.pow(37, 5) ~ 69M
 
            uid = values2key(this._generator.step())
        } while (this._lookups.has(uid))
 
        block = {
            uid, datum, marked: false
        }
 
        this._entries.push(block)
        this._lookups.set(uid, block)
 
    console.log('add:', datum, 'typeof', typeof datum)
 
        return uid
    }
 
    get (uid: TDRUID): T {
        const block = this._lookups.get(uid)
 
        console.log({ block })
 
        return block.datum
    }    
}

Et quand on fait invoque tout cela cela ne fonctionne pas bien non plus:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
type TData = {
    [key: string]: string
}
 
const dbr: DataBlocksRepo <TData> = new TDataBlocksRepo()
 
// cela fonctionne
const uid0 = dbr.add({ 'abcd', 'efgh' })
 
// cela fonctionne aussi, MAIS cela ne drait pas le faire
const uid1 = dbr.add({ 'xyzw', null })
const uid2 = dbr.add(null)

Comment cela se fait-il que les génériques ne semblent pas faire leur travail correctement, en bloquant le projet à laz phase de compilation de TypeSCript ?