conset/dist/conset.js

An ordered conditional set (you can provide your own hash) for typescript/javascript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("./utils");
const create = (hashFunction, initialItems = []) => {
    let conset = {
        map: {},
        order: [],
        hashFunction: hashFunction
    };
    initialItems.forEach((item) => {
        add(conset, item);
    });
    return conset;
};
exports.create = create;
const iter = function* (conset) {
    for (let i = 0; i < conset.order.length; i++) {
        yield conset.map[conset.order[i]];
    }
};
exports.iter = iter;
const remove = (conset, item) => {
    let itemIdx = conset.order.indexOf(conset.hashFunction(item));
    let hasItem = itemIdx > -1;
    if (hasItem) {
        delete conset.map[conset.hashFunction(item)];
        conset.order = utils_1.removeArrayItem(conset.order, itemIdx);
    }
    return conset;
};
exports.remove = remove;
const add = (conset, item) => {
    remove(conset, item);
    conset.map[conset.hashFunction(item)] = item;
    conset.order.push(conset.hashFunction(item));
    return conset;
};
exports.add = add;
const contains = (conset, item) => {
    return conset.map[conset.hashFunction(item)] !== undefined;
};
exports.contains = contains;
const getItems = (conset) => {
    let res = [];
    let items = iter(conset);
    for (let item of items) {
        res.push(item);
    }
    return res;
};
exports.getItems = getItems;
const size = (conset) => {
    return conset.order.length;
};
exports.size = size;
const intersect = (smaller, larger) => {
    let intersection = create(smaller.hashFunction);
    if (size(smaller) > size(larger)) {
        ;
        [smaller, larger] = [larger, smaller];
    }
    for (let item of iter(smaller)) {
        if (contains(larger, item)) {
            add(intersection, item);
        }
    }
    return intersection;
};
exports.intersect = intersect;
const copy = (conset) => {
    return Object.assign({}, conset);
};
exports.copy = copy;
const union = (smaller, larger) => {
    if (size(smaller) > size(larger)) {
        ;
        [smaller, larger] = [larger, smaller];
    }
    let union = copy(larger);
    for (let item of iter(smaller)) {
        add(union, item);
    }
    return union;
};
exports.union = union;