@opensumi/ide-core-common 2.12.1-next-079c1930

package/lib/map.js

@@ -0,0 +1,819 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CaseInsensitiveMap = exports.SetMap = exports.LRUCache = exports.LinkedMap = exports.ResourceMap = exports.TernarySearchTree = exports.PathIterator = exports.StringIterator = exports.serializableToMap = exports.mapToSerializable = exports.setToString = exports.mapToString = exports.getOrSet = exports.keys = exports.values = void 0;
+const vscode_uri_1 = require("vscode-uri");
+const iterator_1 = require("./iterator");
+function values(forEachable) {
+    const result = [];
+    forEachable.forEach(value => result.push(value));
+    return result;
+}
+exports.values = values;
+function keys(map) {
+    const result = [];
+    map.forEach((value, key) => result.push(key));
+    return result;
+}
+exports.keys = keys;
+function getOrSet(map, key, value) {
+    let result = map.get(key);
+    if (result === undefined) {
+        result = value;
+        map.set(key, result);
+    }
+    return result;
+}
+exports.getOrSet = getOrSet;
+function mapToString(map) {
+    const entries = [];
+    map.forEach((value, key) => {
+        entries.push(`${key} => ${value}`);
+    });
+    return `Map(${map.size}) {${entries.join(', ')}}`;
+}
+exports.mapToString = mapToString;
+function setToString(set) {
+    const entries = [];
+    set.forEach(value => {
+        entries.push(value);
+    });
+    return `Set(${set.size}) {${entries.join(', ')}}`;
+}
+exports.setToString = setToString;
+function mapToSerializable(map) {
+    const serializable = [];
+    map.forEach((value, key) => {
+        serializable.push([key, value]);
+    });
+    return serializable;
+}
+exports.mapToSerializable = mapToSerializable;
+function serializableToMap(serializable) {
+    const items = new Map();
+    for (const [key, value] of serializable) {
+        items.set(key, value);
+    }
+    return items;
+}
+exports.serializableToMap = serializableToMap;
+class StringIterator {
+    constructor() {
+        this._value = '';
+        this._pos = 0;
+    }
+    reset(key) {
+        this._value = key;
+        this._pos = 0;
+        return this;
+    }
+    next() {
+        this._pos += 1;
+        return this;
+    }
+    hasNext() {
+        return this._pos < this._value.length - 1;
+    }
+    cmp(a) {
+        const aCode = a.charCodeAt(0);
+        const thisCode = this._value.charCodeAt(this._pos);
+        return aCode - thisCode;
+    }
+    value() {
+        return this._value[this._pos];
+    }
+}
+exports.StringIterator = StringIterator;
+class PathIterator {
+    reset(key) {
+        this._value = key.replace(/\\$|\/$/, '');
+        this._from = 0;
+        this._to = 0;
+        return this.next();
+    }
+    hasNext() {
+        return this._to < this._value.length;
+    }
+    next() {
+        // this._data = key.split(/[\\/]/).filter(s => !!s);
+        this._from = this._to;
+        let justSeps = true;
+        for (; this._to < this._value.length; this._to++) {
+            const ch = this._value.charCodeAt(this._to);
+            if (ch === 47 /* Slash */ || ch === 92 /* Backslash */) {
+                if (justSeps) {
+                    this._from++;
+                }
+                else {
+                    break;
+                }
+            }
+            else {
+                justSeps = false;
+            }
+        }
+        return this;
+    }
+    cmp(a) {
+        let aPos = 0;
+        const aLen = a.length;
+        let thisPos = this._from;
+        while (aPos < aLen && thisPos < this._to) {
+            const cmp = a.charCodeAt(aPos) - this._value.charCodeAt(thisPos);
+            if (cmp !== 0) {
+                return cmp;
+            }
+            aPos += 1;
+            thisPos += 1;
+        }
+        if (aLen === this._to - this._from) {
+            return 0;
+        }
+        else if (aPos < aLen) {
+            return -1;
+        }
+        else {
+            return 1;
+        }
+    }
+    value() {
+        return this._value.substring(this._from, this._to);
+    }
+}
+exports.PathIterator = PathIterator;
+class TernarySearchTreeNode {
+    isEmpty() {
+        return !this.left && !this.mid && !this.right && !this.value;
+    }
+}
+class TernarySearchTree {
+    constructor(segments) {
+        this._iter = segments;
+    }
+    static forPaths() {
+        return new TernarySearchTree(new PathIterator());
+    }
+    static forStrings() {
+        return new TernarySearchTree(new StringIterator());
+    }
+    clear() {
+        this._root = undefined;
+    }
+    set(key, element) {
+        const iter = this._iter.reset(key);
+        let node;
+        if (!this._root) {
+            this._root = new TernarySearchTreeNode();
+            this._root.segment = iter.value();
+        }
+        node = this._root;
+        while (true) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                // left
+                if (!node.left) {
+                    node.left = new TernarySearchTreeNode();
+                    node.left.segment = iter.value();
+                }
+                node = node.left;
+            }
+            else if (val < 0) {
+                // right
+                if (!node.right) {
+                    node.right = new TernarySearchTreeNode();
+                    node.right.segment = iter.value();
+                }
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                // mid
+                iter.next();
+                if (!node.mid) {
+                    node.mid = new TernarySearchTreeNode();
+                    node.mid.segment = iter.value();
+                }
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        const oldElement = node.value;
+        node.value = element;
+        node.key = key;
+        return oldElement;
+    }
+    get(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                // left
+                node = node.left;
+            }
+            else if (val < 0) {
+                // right
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                // mid
+                iter.next();
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        return node ? node.value : undefined;
+    }
+    delete(key) {
+        const iter = this._iter.reset(key);
+        const stack = [];
+        let node = this._root;
+        // find and unset node
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                // left
+                stack.push([1, node]);
+                node = node.left;
+            }
+            else if (val < 0) {
+                // right
+                stack.push([-1, node]);
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                // mid
+                iter.next();
+                stack.push([0, node]);
+                node = node.mid;
+            }
+            else {
+                // remove element
+                node.value = undefined;
+                // clean up empty nodes
+                while (stack.length > 0 && node.isEmpty()) {
+                    let [dir, parent] = stack.pop();
+                    switch (dir) {
+                        case 1:
+                            parent.left = undefined;
+                            break;
+                        case 0:
+                            parent.mid = undefined;
+                            break;
+                        case -1:
+                            parent.right = undefined;
+                            break;
+                    }
+                    node = parent;
+                }
+                break;
+            }
+        }
+    }
+    findSubstr(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        let candidate = undefined;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                // left
+                node = node.left;
+            }
+            else if (val < 0) {
+                // right
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                // mid
+                iter.next();
+                candidate = node.value || candidate;
+                node = node.mid;
+            }
+            else {
+                break;
+            }
+        }
+        return node && node.value || candidate;
+    }
+    findSuperstr(key) {
+        const iter = this._iter.reset(key);
+        let node = this._root;
+        while (node) {
+            const val = iter.cmp(node.segment);
+            if (val > 0) {
+                // left
+                node = node.left;
+            }
+            else if (val < 0) {
+                // right
+                node = node.right;
+            }
+            else if (iter.hasNext()) {
+                // mid
+                iter.next();
+                node = node.mid;
+            }
+            else {
+                // collect
+                if (!node.mid) {
+                    return undefined;
+                }
+                else {
+                    return this._nodeIterator(node.mid);
+                }
+            }
+        }
+        return undefined;
+    }
+    _nodeIterator(node) {
+        let res;
+        let idx;
+        let data;
+        const next = () => {
+            if (!data) {
+                // lazy till first invocation
+                data = [];
+                idx = 0;
+                this._forEach(node, value => data.push(value));
+            }
+            if (idx >= data.length) {
+                return iterator_1.FIN;
+            }
+            if (!res) {
+                res = { done: false, value: data[idx++] };
+            }
+            else {
+                res.value = data[idx++];
+            }
+            return res;
+        };
+        return { next };
+    }
+    forEach(callback) {
+        this._forEach(this._root, callback);
+    }
+    _forEach(node, callback) {
+        if (node) {
+            // left
+            this._forEach(node.left, callback);
+            // node
+            if (node.value) {
+                // callback(node.value, this._iter.join(parts));
+                callback(node.value, node.key);
+            }
+            // mid
+            this._forEach(node.mid, callback);
+            // right
+            this._forEach(node.right, callback);
+        }
+    }
+}
+exports.TernarySearchTree = TernarySearchTree;
+class ResourceMap {
+    constructor() {
+        this.map = new Map();
+        this.ignoreCase = false; // in the future this should be an uri-comparator
+    }
+    set(resource, value) {
+        this.map.set(this.toKey(resource), value);
+    }
+    get(resource) {
+        return this.map.get(this.toKey(resource));
+    }
+    has(resource) {
+        return this.map.has(this.toKey(resource));
+    }
+    get size() {
+        return this.map.size;
+    }
+    clear() {
+        this.map.clear();
+    }
+    delete(resource) {
+        return this.map.delete(this.toKey(resource));
+    }
+    forEach(clb) {
+        this.map.forEach(clb);
+    }
+    values() {
+        return values(this.map);
+    }
+    toKey(resource) {
+        let key = resource.toString();
+        if (this.ignoreCase) {
+            key = key.toLowerCase();
+        }
+        return key;
+    }
+    keys() {
+        return keys(this.map).map(k => vscode_uri_1.URI.parse(k));
+    }
+    clone() {
+        const resourceMap = new ResourceMap();
+        this.map.forEach((value, key) => resourceMap.map.set(key, value));
+        return resourceMap;
+    }
+}
+exports.ResourceMap = ResourceMap;
+class LinkedMap {
+    constructor() {
+        this._map = new Map();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+    }
+    clear() {
+        this._map.clear();
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+    }
+    isEmpty() {
+        return !this._head && !this._tail;
+    }
+    get size() {
+        return this._size;
+    }
+    has(key) {
+        return this._map.has(key);
+    }
+    get(key, touch = 0 /* None */) {
+        const item = this._map.get(key);
+        if (!item) {
+            return undefined;
+        }
+        if (touch !== 0 /* None */) {
+            this.touch(item, touch);
+        }
+        return item.value;
+    }
+    set(key, value, touch = 0 /* None */) {
+        let item = this._map.get(key);
+        if (item) {
+            item.value = value;
+            if (touch !== 0 /* None */) {
+                this.touch(item, touch);
+            }
+        }
+        else {
+            item = { key, value, next: undefined, previous: undefined };
+            switch (touch) {
+                case 0 /* None */:
+                    this.addItemLast(item);
+                    break;
+                case 1 /* AsOld */:
+                    this.addItemFirst(item);
+                    break;
+                case 2 /* AsNew */:
+                    this.addItemLast(item);
+                    break;
+                default:
+                    this.addItemLast(item);
+                    break;
+            }
+            this._map.set(key, item);
+            this._size++;
+        }
+    }
+    delete(key) {
+        return !!this.remove(key);
+    }
+    remove(key) {
+        const item = this._map.get(key);
+        if (!item) {
+            return undefined;
+        }
+        this._map.delete(key);
+        this.removeItem(item);
+        this._size--;
+        return item.value;
+    }
+    shift() {
+        if (!this._head && !this._tail) {
+            return undefined;
+        }
+        if (!this._head || !this._tail) {
+            throw new Error('Invalid list');
+        }
+        const item = this._head;
+        this._map.delete(item.key);
+        this.removeItem(item);
+        this._size--;
+        return item.value;
+    }
+    forEach(callbackfn, thisArg) {
+        let current = this._head;
+        while (current) {
+            if (thisArg) {
+                callbackfn.bind(thisArg)(current.value, current.key, this);
+            }
+            else {
+                callbackfn(current.value, current.key, this);
+            }
+            current = current.next;
+        }
+    }
+    values() {
+        const result = [];
+        let current = this._head;
+        while (current) {
+            result.push(current.value);
+            current = current.next;
+        }
+        return result;
+    }
+    keys() {
+        const result = [];
+        let current = this._head;
+        while (current) {
+            result.push(current.key);
+            current = current.next;
+        }
+        return result;
+    }
+    /* VS Code / Monaco editor runs on es5 which has no Symbol.iterator
+    keys(): IterableIterator<K> {
+        const current = this._head;
+        const iterator: IterableIterator<K> = {
+            [Symbol.iterator]() {
+                return iterator;
+            },
+            next():IteratorResult<K> {
+                if (current) {
+                    const result = { value: current.key, done: false };
+                    current = current.next;
+                    return result;
+                } else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+
+    values(): IterableIterator<V> {
+        const current = this._head;
+        const iterator: IterableIterator<V> = {
+            [Symbol.iterator]() {
+                return iterator;
+            },
+            next():IteratorResult<V> {
+                if (current) {
+                    const result = { value: current.value, done: false };
+                    current = current.next;
+                    return result;
+                } else {
+                    return { value: undefined, done: true };
+                }
+            }
+        };
+        return iterator;
+    }
+    */
+    trimOld(newSize) {
+        if (newSize >= this.size) {
+            return;
+        }
+        if (newSize === 0) {
+            this.clear();
+            return;
+        }
+        let current = this._head;
+        let currentSize = this.size;
+        while (current && currentSize > newSize) {
+            this._map.delete(current.key);
+            current = current.next;
+            currentSize--;
+        }
+        this._head = current;
+        this._size = currentSize;
+        if (current) {
+            current.previous = undefined;
+        }
+    }
+    addItemFirst(item) {
+        // First time Insert
+        if (!this._head && !this._tail) {
+            this._tail = item;
+        }
+        else if (!this._head) {
+            throw new Error('Invalid list');
+        }
+        else {
+            item.next = this._head;
+            this._head.previous = item;
+        }
+        this._head = item;
+    }
+    addItemLast(item) {
+        // First time Insert
+        if (!this._head && !this._tail) {
+            this._head = item;
+        }
+        else if (!this._tail) {
+            throw new Error('Invalid list');
+        }
+        else {
+            item.previous = this._tail;
+            this._tail.next = item;
+        }
+        this._tail = item;
+    }
+    removeItem(item) {
+        if (item === this._head && item === this._tail) {
+            this._head = undefined;
+            this._tail = undefined;
+        }
+        else if (item === this._head) {
+            // This can only happend if size === 1 which is handle
+            // by the case above.
+            if (!item.next) {
+                throw new Error('Invalid list');
+            }
+            item.next.previous = undefined;
+            this._head = item.next;
+        }
+        else if (item === this._tail) {
+            // This can only happend if size === 1 which is handle
+            // by the case above.
+            if (!item.previous) {
+                throw new Error('Invalid list');
+            }
+            item.previous.next = undefined;
+            this._tail = item.previous;
+        }
+        else {
+            const next = item.next;
+            const previous = item.previous;
+            if (!next || !previous) {
+                throw new Error('Invalid list');
+            }
+            next.previous = previous;
+            previous.next = next;
+        }
+        item.next = undefined;
+        item.previous = undefined;
+    }
+    touch(item, touch) {
+        if (!this._head || !this._tail) {
+            throw new Error('Invalid list');
+        }
+        if ((touch !== 1 /* AsOld */ && touch !== 2 /* AsNew */)) {
+            return;
+        }
+        if (touch === 1 /* AsOld */) {
+            if (item === this._head) {
+                return;
+            }
+            const next = item.next;
+            const previous = item.previous;
+            // Unlink the item
+            if (item === this._tail) {
+                // previous must be defined since item was not head but is tail
+                // So there are more than on item in the map
+                previous.next = undefined;
+                this._tail = previous;
+            }
+            else {
+                // Both next and previous are not undefined since item was neither head nor tail.
+                next.previous = previous;
+                previous.next = next;
+            }
+            // Insert the node at head
+            item.previous = undefined;
+            item.next = this._head;
+            this._head.previous = item;
+            this._head = item;
+        }
+        else if (touch === 2 /* AsNew */) {
+            if (item === this._tail) {
+                return;
+            }
+            const next = item.next;
+            const previous = item.previous;
+            // Unlink the item.
+            if (item === this._head) {
+                // next must be defined since item was not tail but is head
+                // So there are more than on item in the map
+                next.previous = undefined;
+                this._head = next;
+            }
+            else {
+                // Both next and previous are not undefined since item was neither head nor tail.
+                next.previous = previous;
+                previous.next = next;
+            }
+            item.next = undefined;
+            item.previous = this._tail;
+            this._tail.next = item;
+            this._tail = item;
+        }
+    }
+    toJSON() {
+        const data = [];
+        this.forEach((value, key) => {
+            data.push([key, value]);
+        });
+        return data;
+    }
+    fromJSON(data) {
+        this.clear();
+        for (const [key, value] of data) {
+            this.set(key, value);
+        }
+    }
+}
+exports.LinkedMap = LinkedMap;
+class LRUCache extends LinkedMap {
+    constructor(limit, ratio = 1) {
+        super();
+        this._limit = limit;
+        this._ratio = Math.min(Math.max(0, ratio), 1);
+    }
+    get limit() {
+        return this._limit;
+    }
+    set limit(limit) {
+        this._limit = limit;
+        this.checkTrim();
+    }
+    get ratio() {
+        return this._ratio;
+    }
+    set ratio(ratio) {
+        this._ratio = Math.min(Math.max(0, ratio), 1);
+        this.checkTrim();
+    }
+    get(key) {
+        return super.get(key, 2 /* AsNew */);
+    }
+    peek(key) {
+        return super.get(key, 0 /* None */);
+    }
+    set(key, value) {
+        super.set(key, value, 2 /* AsNew */);
+        this.checkTrim();
+    }
+    checkTrim() {
+        if (this.size > this._limit) {
+            this.trimOld(Math.round(this._limit * this._ratio));
+        }
+    }
+}
+exports.LRUCache = LRUCache;
+class SetMap {
+    constructor() {
+        this.map = new Map();
+    }
+    add(key, value) {
+        let values = this.map.get(key);
+        if (!values) {
+            values = new Set();
+            this.map.set(key, values);
+        }
+        values.add(value);
+    }
+    delete(key, value) {
+        const values = this.map.get(key);
+        if (!values) {
+            return;
+        }
+        values.delete(value);
+        if (values.size === 0) {
+            this.map.delete(key);
+        }
+    }
+    forEach(key, fn) {
+        const values = this.map.get(key);
+        if (!values) {
+            return;
+        }
+        values.forEach(fn);
+    }
+}
+exports.SetMap = SetMap;
+class CaseInsensitiveMap extends Map {
+    set(key, value) {
+        if (typeof key === 'string') {
+            key = key.toLowerCase();
+        }
+        return super.set(key, value);
+    }
+    get(key) {
+        if (typeof key === 'string') {
+            key = key.toLowerCase();
+        }
+        return super.get(key);
+    }
+    has(key) {
+        if (typeof key === 'string') {
+            key = key.toLowerCase();
+        }
+        return super.has(key);
+    }
+}
+exports.CaseInsensitiveMap = CaseInsensitiveMap;
+//# sourceMappingURL=map.js.map