semantic-typescript 2.0.0 → 2.0.1

package/dist/asynchronous/collectable.js

@@ -3,6 +3,7 @@ import { isFunction, isNumber, isBigInt, isObject, isString, isAsynchronousColle
 import { useCompare } from "#semantic/hook";
 import { AsynchronousOrderedCollectableSymbol, AsynchronousCollectableSymbol, AsynchronousUnorderedCollectableSymbol } from "#semantic/symbol";
 import { invalidate, validate } from "#semantic/utility";
+import { readonlyMap } from "#semantic/readonly-map";
 const SURROGATE_BASE = 1n << 96n;
 export class AsynchronousCollectable {
     AsynchronousCollectable = AsynchronousCollectableSymbol;
@@ -591,10 +592,15 @@ export class AsynchronousUnorderedCollectable extends AsynchronousCollectable {
         }
         this.ready = (async () => {
             let surrogate = 0n;
-            await generator((element, index) => {
-                let key = this.buffer.has(index) ? SURROGATE_BASE + (surrogate++) : index;
-                this.buffer.set(key, element);
-            }, () => false);
+            try {
+                await generator((element, index) => {
+                    let key = this.buffer.has(index) ? SURROGATE_BASE + (surrogate++) : index;
+                    this.buffer.set(key, element);
+                }, () => false);
+            }
+            finally {
+                this.buffer = readonlyMap(this.buffer);
+            }
         })();
         void this.ready.catch(() => { });
         Object.defineProperty(this, "AsynchronousUnorderedCollectable", {

package/dist/optional.js

@@ -120,4 +120,3 @@ export class Optional {
 ;
 Object.freeze(Optional);
 Object.freeze(Optional.prototype);
-Object.freeze(Object.getPrototypeOf(Optional));

package/dist/readonly-map.d.ts

@@ -0,0 +1 @@
+export declare const readonlyMap: <K, V>(source: Map<K, V>) => ReadonlyMap<K, V>;

package/dist/readonly-map.js

@@ -0,0 +1,26 @@
+export const readonlyMap = (source) => {
+    const target = new Map(source);
+    const mutators = new Set(["set", "delete", "clear"]);
+    let facade;
+    facade = new Proxy(target, {
+        get(map, property) {
+            if (mutators.has(property)) {
+                return () => { throw new TypeError("This Map is read-only."); };
+            }
+            if (property === "forEach") {
+                return (callback, thisArg) => {
+                    map.forEach((value, key) => callback.call(thisArg, value, key, facade));
+                };
+            }
+            if (property === "valueOf") {
+                return () => facade;
+            }
+            const value = Reflect.get(map, property, map);
+            return typeof value === "function" ? value.bind(map) : value;
+        },
+        set() { return false; },
+        defineProperty() { return false; },
+        deleteProperty() { return false; }
+    });
+    return facade;
+};

package/dist/synchronous/collectable.js

@@ -3,6 +3,7 @@ import { isFunction, isNumber, isBigInt, isObject, isString, isSynchronousCollec
 import { useCompare } from "#semantic/hook";
 import { SynchronousOrderedCollectableSymbol, SynchronousCollectableSymbol, SynchronousUnorderedCollectableSymbol } from "#semantic/symbol";
 import { invalidate, validate } from "#semantic/utility";
+import { readonlyMap } from "#semantic/readonly-map";
 import { SynchronousCollector } from "#semantic/synchronous/collector";
 import { Optional } from "#semantic/optional";
 const SURROGATE_BASE = 1n << 96n;
@@ -600,7 +601,7 @@ export class SynchronousUnorderedCollectable extends SynchronousCollectable {
                 let key = this.buffer.has(index) ? SURROGATE_BASE + (surrogate++) : index;
                 this.buffer.set(key, element);
             }, () => false);
-            Object.freeze(this.buffer);
+            this.buffer = readonlyMap(this.buffer);
             Object.defineProperties(this, {
                 "SynchronousUnorderedCollectable": {
                     value: SynchronousUnorderedCollectableSymbol,

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/eloyhere"
   },
   "description": "A modern type-safe stream processing library inspired by JavaScript Generator, Java Stream, and MySQL Index. Supports lazy evaluation, async streams, statistics, and IO-like operations.",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "readme": "readme.md",
   "main": "dist/index.js",