hamok/lib/common/Collections.js

Lightweight Distributed Object Storage on RAFT consensus algorithm

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EMPTY_SET = exports.EMPTY_MAP = void 0;
exports.unmodifiableMap = unmodifiableMap;
exports.emptyMap = emptyMap;
exports.equalMaps = equalMaps;
exports.mapOf = mapOf;
exports.mapFrom = mapFrom;
exports.concatMaps = concatMaps;
exports.reduceMaps = reduceMaps;
exports.splitMap = splitMap;
exports.unmodifiableSet = unmodifiableSet;
exports.setOf = setOf;
exports.setFrom = setFrom;
exports.emptySet = emptySet;
exports.equalSets = equalSets;
exports.concatSet = concatSet;
exports.reduceSet = reduceSet;
exports.splitSet = splitSet;
exports.collectEntriesByKeys = collectEntriesByKeys;
exports.collectEntriesByNotInKeys = collectEntriesByNotInKeys;
exports.groupArrayBy = groupArrayBy;
function unmodifiableMap(map) {
    return map;
}
/* eslint-disable @typescript-eslint/no-explicit-any */
exports.EMPTY_MAP = unmodifiableMap(new Map());
function emptyMap() {
    return exports.EMPTY_MAP;
}
function equalMaps(mapA, ...maps) {
    if (maps.length < 1)
        return true;
    const mapB = maps[0];
    for (const [key, valueA] of mapA) {
        const valueB = mapB.get(key);
        if (valueB !== valueA)
            return false;
    }
    for (const [key, valueB] of mapB) {
        const valueA = mapA.get(key);
        if (valueB !== valueA)
            return false;
    }
    return equalMaps(mapB, ...maps.slice(1));
}
function mapOf(...args) {
    return new Map([...args]);
}
function mapFrom(...iterables) {
    const result = new Map();
    for (const iterable of iterables) {
        for (const item of iterable) {
            result.set(...item);
        }
    }
    return result;
}
function concatMaps(result, ...iterables) {
    for (const iterable of iterables) {
        for (const item of iterable) {
            result.set(...item);
        }
    }
    return result;
}
function reduceMaps(result, duplicateListened, ...iterables) {
    for (const iterable of iterables) {
        for (const item of iterable) {
            const [key, value1] = item;
            const value2 = result.get(key);
            if (value2) {
                duplicateListened(key, value1, value2);
            }
            result.set(...item);
        }
    }
    return result;
}
function splitMap(source, size, defaultProvider) {
    if (size < 1) {
        if (!defaultProvider) {
            throw new Error('size to split source cannot be less than 1');
        }
        return defaultProvider();
    }
    const result = [];
    let chunk;
    for (const [key, value] of source) {
        if (!chunk) {
            chunk = new Map();
        }
        chunk.set(key, value);
        if (chunk.size < size) {
            continue;
        }
        result.push(chunk);
        chunk = undefined;
    }
    if (chunk) {
        result.push(chunk);
    }
    return result;
}
function unmodifiableSet(set) {
    return set;
}
/* eslint-disable @typescript-eslint/no-explicit-any */
exports.EMPTY_SET = unmodifiableSet(new Set());
function setOf(...args) {
    return new Set([...args]);
}
function setFrom(...iterables) {
    const result = new Set();
    for (const iterable of iterables) {
        for (const item of iterable) {
            result.add(item);
        }
    }
    return result;
}
function emptySet() {
    return exports.EMPTY_SET;
}
function equalSets(setA, ...sets) {
    if (sets.length < 1)
        return true;
    const setB = sets[0];
    for (const item of setA) {
        if (!setB.has(item))
            return false;
    }
    for (const item of setB) {
        if (!setA.has(item))
            return false;
    }
    return equalSets(setB, ...sets.slice(1));
}
function concatSet(result, ...iterables) {
    for (const iterable of iterables) {
        for (const item of iterable) {
            result.add(item);
        }
    }
    return result;
}
function reduceSet(result, duplicateListened, ...iterables) {
    for (const iterable of iterables) {
        for (const item of iterable) {
            if (result.has(item)) {
                duplicateListened(item);
            }
            result.add(item);
        }
    }
    return result;
}
function splitSet(source, size, defaultProvider) {
    if (size < 1) {
        if (!defaultProvider) {
            throw new Error('size to split source cannot be less than 1');
        }
        return defaultProvider();
    }
    const result = [];
    let chunk;
    for (const item of source) {
        if (!chunk) {
            chunk = new Set();
        }
        chunk.add(item);
        if (chunk.size < size) {
            continue;
        }
        result.push(chunk);
        chunk = undefined;
    }
    if (chunk) {
        result.push(chunk);
    }
    return result;
}
function collectEntriesByKeys(entries, keys) {
    const result = new Map();
    for (const key of keys) {
        const value = entries.get(key);
        if (value)
            result.set(key, value);
    }
    return result;
}
function collectEntriesByNotInKeys(entries, keys) {
    const result = new Map();
    for (const [key, value] of entries) {
        if (keys.has(key))
            continue;
        result.set(key, value);
    }
    return result;
}
function groupArrayBy(list, getKey, filter) {
    const result = new Map();
    for (const item of list) {
        if (filter && !filter(item))
            continue;
        const key = getKey(item);
        if (key === undefined)
            continue;
        result.get(key)?.push(item) ?? result.set(key, [item]);
    }
    return result;
}