@opensumi/ide-core-common 2.17.9 → 2.18.1

package/lib/map.js

@@ -1,819 +0,0 @@
-"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()) {
-                    const [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;
-        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