Class Map

src/lualib/Map.ts:1–177

export class Map<K extends AnyNotNil, V> {
    public static [Symbol.species] = Map;
    public [Symbol.toStringTag] = "Map";

    private items = new LuaTable<K, V>();
    public size = 0;

    // Key-order variables
    private firstKey: K | undefined;
    private lastKey: K | undefined;
    private nextKey = new LuaTable<K, K>();
    private previousKey = new LuaTable<K, K>();

    constructor(entries?: Iterable<readonly [K, V]> | Array<readonly [K, V]>) {
        if (entries === undefined) return;

        const iterable = entries as Iterable<[K, V]>;
        if (iterable[Symbol.iterator]) {
            // Iterate manually because Map is compiled with ES5 which doesn't support Iterables in for...of
            const iterator = iterable[Symbol.iterator]();
            while (true) {
                const result = iterator.next();
                if (result.done) {
                    break;
                }

                const value: [K, V] = result.value; // Ensures index is offset when tuple is accessed
                this.set(value[0], value[1]);
            }
        } else {
            const array = entries as Array<[K, V]>;
            for (const kvp of array) {
                this.set(kvp[0], kvp[1]);
            }
        }
    }

    public clear(): void {
        this.items = new LuaTable();
        this.nextKey = new LuaTable();
        this.previousKey = new LuaTable();
        this.firstKey = undefined;
        this.lastKey = undefined;
        this.size = 0;
    }

    public delete(key: K): boolean {
        const contains = this.has(key);
        if (contains) {
            this.size--;

            // Do order bookkeeping
            const next = this.nextKey.get(key);
            const previous = this.previousKey.get(key);
            if (next !== undefined && previous !== undefined) {
                this.nextKey.set(previous, next);
                this.previousKey.set(next, previous);
            } else if (next !== undefined) {
                this.firstKey = next;
                this.previousKey.set(next, undefined!);