mcbe-ipc 3.3.0 → 3.4.0

package/dist/ipc.d.ts

@@ -81,6 +81,7 @@ export declare namespace PROTO {
     function Optional<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
     function Map<K, V>(kS: PROTO.Serializable<K>, vS: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
     function Set<V>(s: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
+    function Cached<V>(s: PROTO.Serializable<V>, depth?: number): PROTO.Serializable<V>;
 }
 export declare namespace NET {
     type Meta = {
@@ -96,7 +97,10 @@ export declare namespace NET {
         metaOverride?: Partial<Meta>;
     }
     export function emit<S>(endpoint: string, serializer: PROTO.Serializer<S>, value: NoInfer<S>, options?: EmitOptions): Generator<void, void, void>;
-    export function listen<D>(endpoint: string, deserializer: PROTO.Deserializer<D>, callback: (value: NoInfer<D>, meta: Meta) => Generator<void, void, void>): () => void;
+    export interface ListenOptions {
+        filter?: (meta: Meta) => boolean;
+    }
+    export function listen<D>(endpoint: string, deserializer: PROTO.Deserializer<D>, callback: (value: NoInfer<D>, meta: Meta) => Generator<void, void, void>, options?: ListenOptions): () => void;
     export {};
 }
 export declare namespace IPC {

package/dist/ipc.js

@@ -402,6 +402,34 @@ export var PROTO;
         };
     }
     PROTO.Set = Set;
+    function Cached(s, depth = 16) {
+        const cache = new globalThis.Map();
+        return {
+            *serialize(value, stream) {
+                const hit = cache.get(value);
+                if (hit !== undefined) {
+                    stream.write(hit);
+                    cache.delete(value);
+                    cache.set(value, hit);
+                }
+                else {
+                    const buffer = new PROTO.Buffer();
+                    yield* s.serialize(value, buffer);
+                    const bytes = buffer.to_uint8array();
+                    stream.write(bytes);
+                    cache.set(value, bytes);
+                    if (cache.size > depth) {
+                        const first = cache.keys().next().value;
+                        cache.delete(first);
+                    }
+                }
+            },
+            *deserialize(stream) {
+                return yield* s.deserialize(stream);
+            }
+        };
+    }
+    PROTO.Cached = Cached;
 })(PROTO || (PROTO = {}));
 export var NET;
 (function (NET) {
@@ -481,9 +509,9 @@ export var NET;
                 const header_stream = yield* PROTO.MIPS.deserialize(serialized_header);
                 const header = yield* Header.deserialize(header_stream);
                 const errors = [];
-                for (let i = 0; i < listeners.length; i++) {
+                for (const listener of [...listeners]) {
                     try {
-                        yield* listeners[i](header, event.message);
+                        yield* listener(header, event.message);
                     }
                     catch (e) {
                         errors.push(e);
@@ -533,21 +561,28 @@ export var NET;
         }
     }
     NET.emit = emit;
-    function listen(endpoint, deserializer, callback) {
+    function listen(endpoint, deserializer, callback, options) {
         const buffer = new Map();
-        const listener = function* (header, serialized_packet) {
-            let fragment = buffer.get(header.meta.guid);
-            if (!fragment) {
-                fragment = { size: -1, serialized_packets: [], data_size: 0 };
-                buffer.set(header.meta.guid, fragment);
+        const listener = function* (header, fragment) {
+            let packet = buffer.get(header.meta.guid);
+            if (packet === undefined) {
+                if (options?.filter?.(header.meta) === false)
+                    return;
+                packet = { size: -1, fragments: [], received: 0 };
+                buffer.set(header.meta.guid, packet);
             }
             if (header.final) {
-                fragment.size = header.index + 1;
+                packet.size = header.index + 1;
+            }
+            if (packet.fragments[header.index] === undefined) {
+                packet.fragments[header.index] = fragment;
+                packet.received++;
+            }
+            else {
+                throw new Error(`received duplicate fragment ${header.index} for packet ${header.meta.guid}`);
             }
-            fragment.serialized_packets[header.index] = serialized_packet;
-            fragment.data_size += header.index + 1;
-            if (fragment.size !== -1 && fragment.data_size === (fragment.size * (fragment.size + 1)) / 2) {
-                const stream = yield* deserialize(fragment.serialized_packets);
+            if (packet.size !== -1 && packet.size === packet.received) {
+                const stream = yield* deserialize(packet.fragments);
                 const value = yield* deserializer.deserialize(stream);
                 yield* callback(value, header.meta);
                 buffer.delete(header.meta.guid);
@@ -573,6 +608,8 @@ export var IPC;
                     return;
                 resolve(value);
                 terminate();
+            }, {
+                filter: meta => !meta.signature.includes(`+correlation`) || meta.guid === id
             });
             system.runJob(NET.emit(`ipc:${channel}:invoke`, serializer, value, {
                 metaOverride: {

package/package.json

@@ -3,7 +3,7 @@
   "author": "OmniacDev",
   "description": "IPC system for MCBE Script API projects",
   "license": "MIT",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OmniacDev/MCBE-IPC.git"