Variations of javascript's "Map"

Maps.ts

/**
 * Like a normal {@link Map}, but if you get a key that doesn't exist, it will automatically make it exist.
 */
export class AutoMap<K, V> extends Map<K, V> {
    /**
     * @param computer Instantiates default value for keys that don't exist
     */
    public constructor( private computer: (key: K) => V ){ super(); }

    public override get(key: K): V {
        let value = super.get(key);
        if( value === undefined ){
            value = this.computer(key);
            super.set(key, value);
        }
        return value;
    }
}

/**
 * Like a normal {@link WeakMap}, but if you get a key that doesn't exist, it will automatically make it exist.
 */
export class WeakAutoMap<K extends object, V> extends WeakMap<K, V> {
    /**
     * @param computer Instantiates default value for keys that don't exist
     */
    public constructor( private computer: (key: K) => V ){ super(); }

    public override get(key: K): V {
        let value = super.get(key);
        if( value === undefined ){
            value = this.computer(key);
            super.set(key, value);
        }
        return value;
    }
}

function isPrimitive(val: unknown): boolean {
    return val !== null && typeof val !== "object" && typeof val !== "function"
}

/**
 * Like a normal {@link WeakMap}, but you can store primitives on it.
 */
export class SemiWeakMap<K, V> extends WeakMap<any, V> {

    private primitives = new Map<K, V>();

    public override get(key: K): V | undefined {
        return isPrimitive(key) ? this.primitives.get(key) : super.get(key);
    }

    public override set(key: K, value: V): this {
        isPrimitive(key) ? this.primitives.set(key, value) : super.set(key, value);
        return this;
    }

    public override has(key: K): boolean {
        return isPrimitive(key) ? this.primitives.has(key) : super.has(key);
    }

    public override delete(key: K): boolean {
        return isPrimitive(key) ? this.primitives.delete(key) : super.delete(key);
    }

}