@blackglory/structures 0.7.0 → 0.10.0

package/dist/es2018/index.mjs

@@ -9641,6 +9641,221 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
     }
 }
 
+class SparseSet {
+    constructor() {
+        this.indexToValue = [];
+        this.valueToIndex = [];
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    [Symbol.iterator]() {
+        return this.indexToValue[Symbol.iterator]();
+    }
+    values() {
+        return this.indexToValue[Symbol.iterator]();
+    }
+    has(value) {
+        // 跟一般的实现不同, 不需要访问values数组.
+        return value in this.valueToIndex;
+    }
+    add(value) {
+        if (!this.has(value)) {
+            const index = this.indexToValue.length;
+            this.indexToValue.push(value);
+            this.valueToIndex[value] = index;
+        }
+    }
+    delete(value) {
+        if (this.has(value)) {
+            const lastValue = this.indexToValue.pop();
+            if (value === lastValue) {
+                delete this.valueToIndex[value];
+            }
+            else {
+                const index = this.valueToIndex[value];
+                this.indexToValue[index] = lastValue;
+                this.valueToIndex[lastValue] = index;
+                // 跟一般的实现不同, 直接删除值的索引.
+                delete this.valueToIndex[value];
+            }
+        }
+    }
+}
+
+class SparseMap {
+    constructor() {
+        this.keyToIndex = [];
+        this.indexToKey = [];
+        this.indexToValue = [];
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    *entries() {
+        for (let i = 0; i < this.indexToKey.length; i++) {
+            yield [this.indexToKey[i], this.indexToValue[i]];
+        }
+    }
+    keys() {
+        return this.indexToKey.values();
+    }
+    values() {
+        return this.indexToValue.values();
+    }
+    has(key) {
+        // 跟一般的稀疏集实现不同, 不需要访问values数组.
+        return key in this.keyToIndex;
+    }
+    get(key) {
+        if (this.has(key)) {
+            const index = this.keyToIndex[key];
+            return this.indexToValue[index];
+        }
+        else {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        if (this.has(key)) {
+            const index = this.keyToIndex[key];
+            this.indexToValue[index] = value;
+        }
+        else {
+            const index = this.indexToKey.length;
+            this.indexToKey.push(key);
+            this.indexToValue.push(value);
+            this.keyToIndex[key] = index;
+        }
+    }
+    delete(key) {
+        if (this.has(key)) {
+            const lastKey = this.indexToKey.pop();
+            const lastValue = this.indexToValue.pop();
+            if (key === lastKey) {
+                delete this.keyToIndex[key];
+            }
+            else {
+                const index = this.keyToIndex[key];
+                this.indexToKey[index] = lastKey;
+                this.indexToValue[index] = lastValue;
+                this.keyToIndex[key] = index;
+                delete this.keyToIndex[key];
+            }
+        }
+    }
+}
+
+class TypedSparseMap {
+    constructor(array) {
+        this.keyToIndex = [];
+        this.indexToKey = [];
+        es2018$d.assert(array.length === 0, 'array should be empty');
+        this.indexToValue = array;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    *entries() {
+        for (let i = 0; i < this.indexToKey.length; i++) {
+            yield [
+                this.indexToKey[i],
+                this.indexToValue.internalTypedArray[i]
+            ];
+        }
+    }
+    keys() {
+        return this.indexToKey.values();
+    }
+    *values() {
+        for (let i = 0; i < this.indexToKey.length; i++) {
+            yield this.indexToValue.internalTypedArray[i];
+        }
+    }
+    has(key) {
+        const index = this.keyToIndex[key];
+        return this.indexToKey[index] === key;
+    }
+    get(key) {
+        const index = this.keyToIndex[key];
+        if (this.indexToKey[index] === key) {
+            return this.indexToValue.internalTypedArray[index];
+        }
+        else {
+            return undefined;
+        }
+    }
+    set(key, value) {
+        const index = this.keyToIndex[key];
+        if (this.indexToKey[index] === key) {
+            this.indexToValue.internalTypedArray[index] = value;
+        }
+        else {
+            const index = this.indexToKey.length;
+            this.indexToKey.push(key);
+            this.indexToValue.push(value);
+            this.keyToIndex[key] = index;
+        }
+    }
+    delete(key) {
+        const index = this.keyToIndex[key];
+        if (this.indexToKey[index] === key) {
+            const lastKey = this.indexToKey.pop();
+            const lastValue = this.indexToValue.pop();
+            if (key !== lastKey) {
+                this.indexToKey[index] = lastKey;
+                this.indexToValue.internalTypedArray[index] = lastValue;
+                this.keyToIndex[lastKey] = index;
+            }
+        }
+    }
+}
+
+class TypedSparseSet {
+    constructor(array) {
+        const valueToIndex = [];
+        if (array.length > 0) {
+            for (const [index, value] of array.internalTypedArray.entries()) {
+                valueToIndex[value] = index;
+            }
+        }
+        this.indexToValue = array;
+        this.valueToIndex = valueToIndex;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    *values() {
+        for (let i = 0; i < this.indexToValue.length; i++) {
+            yield this.indexToValue.internalTypedArray[i];
+        }
+    }
+    has(value) {
+        const index = this.valueToIndex[value];
+        return this.indexToValue.internalTypedArray[index] === value;
+    }
+    add(value) {
+        if (!this.has(value)) {
+            const index = this.indexToValue.length;
+            this.indexToValue.push(value);
+            this.valueToIndex[value] = index;
+        }
+    }
+    delete(value) {
+        const index = this.valueToIndex[value];
+        if (this.indexToValue.internalTypedArray[index] === value) {
+            const lastValue = this.indexToValue.pop();
+            if (value !== lastValue) {
+                this.indexToValue.internalTypedArray[index] = lastValue;
+                this.valueToIndex[lastValue] = index;
+            }
+        }
+    }
+}
+
 // 相关提案: https://github.com/tc39/proposal-resizablearraybuffer
 class DynamicTypedArray {
     constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
@@ -9648,7 +9863,7 @@ class DynamicTypedArray {
         this._length = 0;
         es2018$d.assert(Number.isInteger(capacity), 'capacity must be an integer');
         es2018$d.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
-        es2018$d.assert(growthFactor > 1, 'growthFactory must be greater than or equal to 1');
+        es2018$d.assert(growthFactor >= 1, 'growthFactory must be greater than or equal to 1');
         this.array = new typedArrayConstructor(capacity);
         this.growthFactor = growthFactor;
     }
@@ -9727,135 +9942,44 @@ class DynamicTypedArray {
     }
 }
 function computeNewCapacity(oldCapacity, targetLength, growthFactor) {
-    if (oldCapacity === targetLength) {
+    if (growthFactor === 1) {
         return targetLength;
     }
-    else if (oldCapacity < targetLength) {
-        // 增加容量以适配targetLength
-        let newCapacity = Math.max(oldCapacity, 1);
-        while (newCapacity < targetLength) {
-            newCapacity *= growthFactor;
-        }
-        return Math.floor(newCapacity);
-    }
     else {
-        // 尝试减少容量以适配targetLength
-        // `targetLength = 0`是特殊情况,
-        // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
-        if (targetLength === 0) {
-            return 0;
+        if (oldCapacity === targetLength) {
+            return targetLength;
         }
-        else {
-            let newCapacity = oldCapacity;
-            while (true) {
-                const temp = newCapacity / growthFactor;
-                if (temp < targetLength) {
-                    break;
-                }
-                else {
-                    newCapacity = temp;
-                }
+        else if (oldCapacity < targetLength) {
+            // 增加容量以适配targetLength
+            let newCapacity = Math.max(oldCapacity, 1);
+            while (newCapacity < targetLength) {
+                newCapacity *= growthFactor;
             }
             return Math.floor(newCapacity);
         }
-    }
-}
-
-class SparseSet {
-    constructor() {
-        this.indexToValue = new DynamicTypedArray(Uint32Array);
-        this.valueToIndex = new DynamicTypedArray(Uint32Array);
-    }
-    get [Symbol.toStringTag]() {
-        return this.constructor.name;
-    }
-    [Symbol.iterator]() {
-        return this.indexToValue.internalTypedArray[Symbol.iterator]();
-    }
-    has(value) {
-        const index = this.valueToIndex.internalTypedArray[value];
-        return this.indexToValue.internalTypedArray[index] === value;
-    }
-    add(value) {
-        if (!this.has(value)) {
-            const index = this.indexToValue.length;
-            this.indexToValue.push(value);
-            this.valueToIndex.set(value, index);
-        }
-    }
-    delete(value) {
-        const index = this.valueToIndex.internalTypedArray[value];
-        if (this.indexToValue.internalTypedArray[index] === value) {
-            const lastValue = this.indexToValue.pop();
-            if (value !== lastValue) {
-                this.indexToValue.internalTypedArray[index] = lastValue;
-                this.valueToIndex.internalTypedArray[lastValue] = index;
-            }
-        }
-    }
-}
-
-class SparseMap {
-    constructor() {
-        this.keyToIndex = new DynamicTypedArray(Uint32Array);
-        this.indexToKey = new DynamicTypedArray(Uint32Array);
-        this.indexToValue = new DynamicTypedArray(Uint32Array);
-    }
-    get [Symbol.toStringTag]() {
-        return this.constructor.name;
-    }
-    *entries() {
-        for (let i = 0; i < this.indexToKey.length; i++) {
-            yield [
-                this.indexToKey.internalTypedArray[i],
-                this.indexToValue.internalTypedArray[i]
-            ];
-        }
-    }
-    keys() {
-        return this.indexToKey.internalTypedArray.values();
-    }
-    values() {
-        return this.indexToValue.internalTypedArray.values();
-    }
-    has(key) {
-        const index = this.keyToIndex.internalTypedArray[key];
-        return this.indexToKey.internalTypedArray[index] === key;
-    }
-    get(key) {
-        const index = this.keyToIndex.internalTypedArray[key];
-        if (this.indexToKey.internalTypedArray[index] === key) {
-            return this.indexToValue.internalTypedArray[index];
-        }
-        else {
-            return undefined;
-        }
-    }
-    set(key, value) {
-        const index = this.keyToIndex.internalTypedArray[key];
-        if (this.indexToKey.internalTypedArray[index] === key) {
-            this.indexToValue.internalTypedArray[index] = value;
-        }
         else {
-            const index = this.indexToKey.length;
-            this.indexToKey.push(key);
-            this.indexToValue.push(value);
-            this.keyToIndex.set(key, index);
-        }
-    }
-    delete(key) {
-        const index = this.keyToIndex.internalTypedArray[key];
-        if (this.indexToKey.internalTypedArray[index] === key) {
-            const lastKey = this.indexToKey.pop();
-            const lastValue = this.indexToValue.pop();
-            if (key !== lastKey) {
-                this.indexToKey.internalTypedArray[index] = lastKey;
-                this.indexToValue.internalTypedArray[index] = lastValue;
-                this.keyToIndex.internalTypedArray[lastKey] = index;
+            // 尝试减少容量以适配targetLength
+            // `targetLength = 0`是特殊情况,
+            // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
+            if (targetLength === 0) {
+                return 0;
+            }
+            else {
+                let newCapacity = oldCapacity;
+                while (true) {
+                    const temp = newCapacity / growthFactor;
+                    if (temp < targetLength) {
+                        break;
+                    }
+                    else {
+                        newCapacity = temp;
+                    }
+                }
+                return Math.floor(newCapacity);
             }
         }
     }
 }
 
-export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseMap, SparseSet, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
+export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseMap, SparseSet, TLRUMap, TrieMap, TypedSparseMap, TypedSparseSet, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map