mcbe-ipc 3.1.3 → 3.2.0

package/README.md

@@ -1,6 +1,6 @@
 # MCBE-IPC 📡
 
-An IPC[^1] system for Minecraft Bedrock Edition Script API projects
+An IPC[^1] system for MCBE Script API projects
 
 ## 🔗 Dependencies
 
@@ -23,4 +23,4 @@ npm install mcbe-ipc
 
 
 
-[^1]: Inter-Pack Communication
+[^1]: Inter-Pack Communication

package/dist/ipc.d.ts

@@ -27,6 +27,7 @@ export declare namespace PROTO {
         serialize(value: T, stream: Buffer): Generator<void, void, void>;
         deserialize(stream: Buffer): Generator<void, T, void>;
     }
+    type Infer<S> = S extends PROTO.Serializable<infer T> ? T : never;
     class Buffer {
         private _buffer;
         private _data_view;
@@ -36,8 +37,12 @@ export declare namespace PROTO {
         get front(): number;
         get data_view(): DataView;
         constructor(size?: number);
-        write(...values: number[]): void;
-        read(amount?: number): number[];
+        reserve(amount: number): number;
+        consume(amount: number): number;
+        write(byte: number): void;
+        write(bytes: Uint8Array): void;
+        read(): number;
+        read(amount: number): Uint8Array;
         ensure_capacity(size: number): void;
         static from_uint8array(array: Uint8Array): Buffer;
         to_uint8array(): Uint8Array;
@@ -56,22 +61,23 @@ export declare namespace PROTO {
     const UInt16: PROTO.Serializable<number>;
     const UInt32: PROTO.Serializable<number>;
     const UVarInt32: PROTO.Serializable<number>;
+    const VarInt32: PROTO.Serializable<number>;
     const Float32: PROTO.Serializable<number>;
     const Float64: PROTO.Serializable<number>;
     const String: PROTO.Serializable<string>;
     const Boolean: PROTO.Serializable<boolean>;
     const UInt8Array: PROTO.Serializable<Uint8Array>;
     const Date: PROTO.Serializable<Date>;
-    function Object<T extends object>(obj: {
+    function Object<T extends object>(s: {
         [K in keyof T]: PROTO.Serializable<T[K]>;
     }): PROTO.Serializable<T>;
-    function Array<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
-    function Tuple<T extends any[]>(...values: {
+    function Array<T>(s: PROTO.Serializable<T>): PROTO.Serializable<T[]>;
+    function Tuple<T extends any[]>(...s: {
         [K in keyof T]: PROTO.Serializable<T[K]>;
     }): PROTO.Serializable<T>;
-    function Optional<T>(value: PROTO.Serializable<T>): PROTO.Serializable<T | undefined>;
-    function Map<K, V>(key: PROTO.Serializable<K>, value: PROTO.Serializable<V>): PROTO.Serializable<Map<K, V>>;
-    function Set<V>(value: PROTO.Serializable<V>): PROTO.Serializable<Set<V>>;
+    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>>;
     type Endpoint = string;
     type Header = {
         guid: string;
@@ -86,19 +92,19 @@ export declare namespace NET {
     let FRAG_MAX: number;
     function serialize(buffer: PROTO.Buffer, max_size?: number): Generator<void, string[], void>;
     function deserialize(strings: string[]): Generator<void, PROTO.Buffer, void>;
-    function emit<S extends PROTO.Serializable<T>, T>(endpoint: string, serializer: S & PROTO.Serializable<T>, value: T): Generator<void, void, void>;
-    function listen<T, S extends PROTO.Serializable<T>>(endpoint: string, serializer: S & PROTO.Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => void;
+    function emit<S extends PROTO.Serializable<any>>(endpoint: string, serializer: S, value: PROTO.Infer<S>): Generator<void, void, void>;
+    function listen<S extends PROTO.Serializable<any>>(endpoint: string, serializer: S, callback: (value: PROTO.Infer<S>) => Generator<void, void, void>): () => void;
 }
 export declare namespace IPC {
     /** Sends a message with `args` to `channel` */
-    function send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+    function send<S extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    function invoke<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, serializer: TS & PROTO.Serializable<T>, value: T, deserializer: RS & PROTO.Serializable<R>): Promise<R>;
+    function invoke<S extends PROTO.Serializable<any>, D extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>, deserializer: D): Promise<PROTO.Infer<D>>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function on<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
     /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    function once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function once<D extends PROTO.Serializable<any>>(channel: string, deserializer: D, listener: (value: PROTO.Infer<D>) => void): () => void;
     /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    function handle<TS extends PROTO.Serializable<T>, T, RS extends PROTO.Serializable<R>, R>(channel: string, deserializer: TS & PROTO.Serializable<T>, serializer: RS & PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+    function handle<D extends PROTO.Serializable<any>, S extends PROTO.Serializable<any>>(channel: string, deserializer: D, serializer: S, listener: (value: PROTO.Infer<D>) => PROTO.Infer<S>): () => void;
 }
 export default IPC;

package/dist/ipc.js

@@ -41,20 +41,39 @@ export var PROTO;
             this._length = 0;
             this._offset = 0;
         }
-        write(...values) {
-            this.ensure_capacity(values.length);
-            this._buffer.set(values, this.end);
-            this._length += values.length;
-        }
-        read(amount = 1) {
-            if (this._length > 0) {
-                const max_amount = amount > this._length ? this._length : amount;
-                const values = this._buffer.subarray(this._offset, this._offset + max_amount);
-                this._length -= max_amount;
-                this._offset += max_amount;
-                return globalThis.Array.from(values);
+        reserve(amount) {
+            this.ensure_capacity(amount);
+            const end = this.end;
+            this._length += amount;
+            return end;
+        }
+        consume(amount) {
+            if (amount > this._length)
+                throw new Error('not enough bytes');
+            const front = this.front;
+            this._length -= amount;
+            this._offset += amount;
+            return front;
+        }
+        write(input) {
+            if (typeof input === 'number') {
+                const offset = this.reserve(1);
+                this._buffer[offset] = input;
+            }
+            else {
+                const offset = this.reserve(input.length);
+                this._buffer.set(input, offset);
+            }
+        }
+        read(amount) {
+            if (amount === undefined) {
+                const offset = this.consume(1);
+                return this._buffer[offset];
+            }
+            else {
+                const offset = this.consume(amount);
+                return this._buffer.slice(offset, offset + amount);
             }
-            return [];
         }
         ensure_capacity(size) {
             if (this.end + size > this._buffer.length) {
@@ -125,120 +144,98 @@ export var PROTO;
     };
     PROTO.Int8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt8(stream.end - length, value);
+            stream.data_view.setInt8(stream.reserve(1), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt8(stream.front);
-            stream.read(1);
-            return value;
+            return stream.data_view.getInt8(stream.consume(1));
         }
     };
     PROTO.Int16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt16(stream.end - length, value);
+            stream.data_view.setInt16(stream.reserve(2), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt16(stream.front);
-            stream.read(2);
-            return value;
+            return stream.data_view.getInt16(stream.consume(2));
         }
     };
     PROTO.Int32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setInt32(stream.end - length, value);
+            stream.data_view.setInt32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getInt32(stream.front);
-            stream.read(4);
-            return value;
+            return stream.data_view.getInt32(stream.consume(4));
         }
     };
     PROTO.UInt8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint8(stream.end - length, value);
+            stream.data_view.setUint8(stream.reserve(1), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint8(stream.front);
-            stream.read(1);
-            return value;
+            return stream.data_view.getUint8(stream.consume(1));
         }
     };
     PROTO.UInt16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint16(stream.end - length, value);
+            stream.data_view.setUint16(stream.reserve(2), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint16(stream.front);
-            stream.read(2);
-            return value;
+            return stream.data_view.getUint16(stream.consume(2));
         }
     };
     PROTO.UInt32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setUint32(stream.end - length, value);
+            stream.data_view.setUint32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getUint32(stream.front);
-            stream.read(4);
-            return value;
+            return stream.data_view.getUint32(stream.consume(4));
         }
     };
     PROTO.UVarInt32 = {
         *serialize(value, stream) {
+            value >>>= 0;
             while (value >= 0x80) {
                 stream.write((value & 0x7f) | 0x80);
-                value >>= 7;
+                value >>>= 7;
                 yield;
             }
             stream.write(value);
         },
         *deserialize(stream) {
             let value = 0;
-            let size = 0;
-            let byte;
-            do {
-                byte = stream.read()[0];
+            for (let size = 0; size < 5; size++) {
+                const byte = stream.read();
                 value |= (byte & 0x7f) << (size * 7);
-                size += 1;
                 yield;
-            } while ((byte & 0x80) !== 0 && size < 10);
-            return value;
+                if ((byte & 0x80) == 0)
+                    break;
+            }
+            return value >>> 0;
+        }
+    };
+    PROTO.VarInt32 = {
+        *serialize(value, stream) {
+            const zigzag = (value << 1) ^ (value >> 31);
+            yield* PROTO.UVarInt32.serialize(zigzag, stream);
+        },
+        *deserialize(stream) {
+            const zigzag = yield* PROTO.UVarInt32.deserialize(stream);
+            return (zigzag >>> 1) ^ -(zigzag & 1);
         }
     };
     PROTO.Float32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setFloat32(stream.end - length, value);
+            stream.data_view.setFloat32(stream.reserve(4), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getFloat32(stream.front);
-            stream.read(4);
-            return value;
+            return stream.data_view.getFloat32(stream.consume(4));
         }
     };
     PROTO.Float64 = {
         *serialize(value, stream) {
-            const length = 8;
-            stream.write(...globalThis.Array(length).fill(0));
-            stream.data_view.setFloat64(stream.end - length, value);
+            stream.data_view.setFloat64(stream.reserve(8), value);
         },
         *deserialize(stream) {
-            const value = stream.data_view.getFloat64(stream.front);
-            stream.read(8);
-            return value;
+            return stream.data_view.getFloat64(stream.consume(8));
         }
     };
     PROTO.String = {
@@ -264,18 +261,17 @@ export var PROTO;
             stream.write(value ? 1 : 0);
         },
         *deserialize(stream) {
-            const value = stream.read()[0];
-            return value === 1;
+            return stream.read() !== 0;
         }
     };
     PROTO.UInt8Array = {
         *serialize(value, stream) {
             yield* PROTO.UVarInt32.serialize(value.length, stream);
-            stream.write(...value);
+            stream.write(value);
         },
         *deserialize(stream) {
             const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return new Uint8Array(stream.read(length));
+            return stream.read(length);
         }
     };
     PROTO.Date = {
@@ -286,92 +282,91 @@ export var PROTO;
             return new globalThis.Date(yield* PROTO.Float64.deserialize(stream));
         }
     };
-    function Object(obj) {
+    function Object(s) {
         return {
             *serialize(value, stream) {
-                for (const key in obj) {
-                    yield* obj[key].serialize(value[key], stream);
+                for (const key in s) {
+                    yield* s[key].serialize(value[key], stream);
                 }
             },
             *deserialize(stream) {
                 const result = {};
-                for (const key in obj) {
-                    result[key] = yield* obj[key].deserialize(stream);
+                for (const key in s) {
+                    result[key] = yield* s[key].deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Object = Object;
-    function Array(value) {
+    function Array(s) {
         return {
-            *serialize(array, stream) {
-                yield* PROTO.UVarInt32.serialize(array.length, stream);
-                for (const item of array) {
-                    yield* value.serialize(item, stream);
+            *serialize(value, stream) {
+                yield* PROTO.UVarInt32.serialize(value.length, stream);
+                for (const item of value) {
+                    yield* s.serialize(item, stream);
                 }
             },
             *deserialize(stream) {
                 const result = [];
                 const length = yield* PROTO.UVarInt32.deserialize(stream);
                 for (let i = 0; i < length; i++) {
-                    result[i] = yield* value.deserialize(stream);
+                    result[i] = yield* s.deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Array = Array;
-    function Tuple(...values) {
+    function Tuple(...s) {
         return {
-            *serialize(tuple, stream) {
-                for (let i = 0; i < values.length; i++) {
-                    yield* values[i].serialize(tuple[i], stream);
+            *serialize(value, stream) {
+                for (let i = 0; i < s.length; i++) {
+                    yield* s[i].serialize(value[i], stream);
                 }
             },
             *deserialize(stream) {
                 const result = [];
-                for (let i = 0; i < values.length; i++) {
-                    result[i] = yield* values[i].deserialize(stream);
+                for (let i = 0; i < s.length; i++) {
+                    result[i] = yield* s[i].deserialize(stream);
                 }
                 return result;
             }
         };
     }
     PROTO.Tuple = Tuple;
-    function Optional(value) {
+    function Optional(s) {
         return {
-            *serialize(optional, stream) {
-                yield* PROTO.Boolean.serialize(optional !== undefined, stream);
-                if (optional !== undefined) {
-                    yield* value.serialize(optional, stream);
-                }
+            *serialize(value, stream) {
+                const def = value !== undefined;
+                yield* PROTO.Boolean.serialize(def, stream);
+                if (def)
+                    yield* s.serialize(value, stream);
             },
             *deserialize(stream) {
-                const defined = yield* PROTO.Boolean.deserialize(stream);
-                if (defined) {
-                    return yield* value.deserialize(stream);
-                }
+                const def = yield* PROTO.Boolean.deserialize(stream);
+                if (def)
+                    return yield* s.deserialize(stream);
                 return undefined;
             }
         };
     }
     PROTO.Optional = Optional;
-    function Map(key, value) {
+    function Map(kS, vS) {
         return {
-            *serialize(map, stream) {
-                yield* PROTO.UVarInt32.serialize(map.size, stream);
-                for (const [k, v] of map.entries()) {
-                    yield* key.serialize(k, stream);
-                    yield* value.serialize(v, stream);
+            *serialize(value, stream) {
+                yield* PROTO.UVarInt32.serialize(value.size, stream);
+                for (const [k, v] of value) {
+                    yield* kS.serialize(k, stream);
+                    yield* vS.serialize(v, stream);
                 }
             },
             *deserialize(stream) {
                 const size = yield* PROTO.UVarInt32.deserialize(stream);
                 const result = new globalThis.Map();
                 for (let i = 0; i < size; i++) {
-                    const k = yield* key.deserialize(stream);
-                    const v = yield* value.deserialize(stream);
+                    const k = yield* kS.deserialize(stream);
+                    const v = yield* vS.deserialize(stream);
                     result.set(k, v);
                 }
                 return result;
@@ -379,19 +374,19 @@ export var PROTO;
         };
     }
     PROTO.Map = Map;
-    function Set(value) {
+    function Set(s) {
         return {
             *serialize(set, stream) {
                 yield* PROTO.UVarInt32.serialize(set.size, stream);
-                for (const [_, v] of set.entries()) {
-                    yield* value.serialize(v, stream);
+                for (const v of set) {
+                    yield* s.serialize(v, stream);
                 }
             },
             *deserialize(stream) {
                 const size = yield* PROTO.UVarInt32.deserialize(stream);
                 const result = new globalThis.Set();
                 for (let i = 0; i < size; i++) {
-                    const v = yield* value.deserialize(stream);
+                    const v = yield* s.deserialize(stream);
                     result.add(v);
                 }
                 return result;
@@ -465,16 +460,26 @@ export var NET;
     NET.deserialize = deserialize;
     system.afterEvents.scriptEventReceive.subscribe(event => {
         system.runJob((function* () {
+            if (event.sourceType !== ScriptEventSource.Server)
+                return;
             const [serialized_endpoint, serialized_header] = event.id.split(':');
             const endpoint_stream = yield* PROTO.MIPS.deserialize(serialized_endpoint);
             const endpoint = yield* PROTO.Endpoint.deserialize(endpoint_stream);
             const listeners = ENDPOINTS.get(endpoint);
-            if (event.sourceType === ScriptEventSource.Server && listeners) {
+            if (listeners !== undefined) {
                 const header_stream = yield* PROTO.MIPS.deserialize(serialized_header);
                 const header = yield* PROTO.Header.deserialize(header_stream);
+                const errors = [];
                 for (let i = 0; i < listeners.length; i++) {
-                    yield* listeners[i](header, event.message);
+                    try {
+                        yield* listeners[i](header, event.message);
+                    }
+                    catch (e) {
+                        errors.push(e);
+                    }
                 }
+                if (errors.length > 0)
+                    throw new AggregateError(errors, 'one or more listeners failed');
             }
         })());
     });

package/package.json

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