@blackglory/structures 0.9.0 → 0.10.0

package/dist/es2018/index.umd.js

@@ -9658,6 +9658,9 @@
         [Symbol.iterator]() {
             return this.indexToValue[Symbol.iterator]();
         }
+        values() {
+            return this.indexToValue[Symbol.iterator]();
+        }
         has(value) {
             // 跟一般的实现不同, 不需要访问values数组.
             return value in this.valueToIndex;
@@ -9749,6 +9752,116 @@
         }
     }
 
+    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 } = {}) {
@@ -9756,7 +9869,7 @@
             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;
         }
@@ -9835,131 +9948,40 @@
         }
     }
     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 TypedSparseMap {
-        constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
-            this.indexToValue = new DynamicTypedArray(typedArrayConstructor, { capacity, growthFactor });
-            this.keyToIndex = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
-            this.indexToKey = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
-        }
-        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;
                 }
-            }
-        }
-    }
-
-    class TypedSparseSet {
-        constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
-            this.indexToValue = new DynamicTypedArray(typedArrayConstructor, { capacity, growthFactor });
-            this.valueToIndex = new DynamicTypedArray(Uint32Array, { capacity, growthFactor });
-        }
-        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;
+                else {
+                    let newCapacity = oldCapacity;
+                    while (true) {
+                        const temp = newCapacity / growthFactor;
+                        if (temp < targetLength) {
+                            break;
+                        }
+                        else {
+                            newCapacity = temp;
+                        }
+                    }
+                    return Math.floor(newCapacity);
                 }
             }
         }