mcbe-ipc 3.1.4 → 3.2.0

package/dist/ipc.d.ts

@@ -37,10 +37,12 @@ export declare namespace PROTO {
         get front(): number;
         get data_view(): DataView;
         constructor(size?: number);
-        write_byte(byte: number): void;
-        write_bytes(bytes: Uint8Array): void;
-        read_byte(): number;
-        read_bytes(amount: number): Uint8Array;
+        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;
@@ -59,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;
@@ -96,7 +99,7 @@ export declare namespace IPC {
     /** Sends a message with `args` to `channel` */
     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<S extends PROTO.Serializable<any>, D extends PROTO.Serializable<any>>(channel: string, serializer: S, value: PROTO.Infer<S>, deserializer: S): Promise<PROTO.Infer<D>>;
+    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<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. */

package/dist/ipc.js

@@ -41,31 +41,39 @@ export var PROTO;
             this._length = 0;
             this._offset = 0;
         }
-        write_byte(byte) {
-            this.ensure_capacity(1);
-            this._buffer[this.end] = byte;
-            this._length++;
-        }
-        write_bytes(bytes) {
-            this.ensure_capacity(bytes.length);
-            this._buffer.set(bytes, this.end);
-            this._length += bytes.length;
-        }
-        read_byte() {
-            const byte = this._buffer[this._offset];
-            this._length--;
-            this._offset++;
-            return byte;
-        }
-        read_bytes(amount) {
-            if (this._length > 0) {
-                const max_amount = amount > this._length ? this._length : amount;
-                const values = this._buffer.slice(this._offset, this._offset + max_amount);
-                this._length -= max_amount;
-                this._offset += max_amount;
-                return 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 new Uint8Array();
         }
         ensure_capacity(size) {
             if (this.end + size > this._buffer.length) {
@@ -109,7 +117,7 @@ export var PROTO;
                 const hex_str = str.slice(3, str.length - 1);
                 for (let i = 0; i < hex_str.length; i++) {
                     const hex = hex_str[i] + hex_str[++i];
-                    buffer.write_byte(parseInt(hex, 16));
+                    buffer.write(parseInt(hex, 16));
                     yield;
                 }
                 return buffer;
@@ -136,120 +144,98 @@ export var PROTO;
     };
     PROTO.Int8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(1);
-            return value;
+            return stream.data_view.getInt8(stream.consume(1));
         }
     };
     PROTO.Int16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(2);
-            return value;
+            return stream.data_view.getInt16(stream.consume(2));
         }
     };
     PROTO.Int32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(4);
-            return value;
+            return stream.data_view.getInt32(stream.consume(4));
         }
     };
     PROTO.UInt8 = {
         *serialize(value, stream) {
-            const length = 1;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(1);
-            return value;
+            return stream.data_view.getUint8(stream.consume(1));
         }
     };
     PROTO.UInt16 = {
         *serialize(value, stream) {
-            const length = 2;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(2);
-            return value;
+            return stream.data_view.getUint16(stream.consume(2));
         }
     };
     PROTO.UInt32 = {
         *serialize(value, stream) {
-            const length = 4;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(4);
-            return value;
+            return stream.data_view.getUint32(stream.consume(4));
         }
     };
     PROTO.UVarInt32 = {
         *serialize(value, stream) {
+            value >>>= 0;
             while (value >= 0x80) {
-                stream.write_byte((value & 0x7f) | 0x80);
-                value >>= 7;
+                stream.write((value & 0x7f) | 0x80);
+                value >>>= 7;
                 yield;
             }
-            stream.write_byte(value);
+            stream.write(value);
         },
         *deserialize(stream) {
             let value = 0;
-            let size = 0;
-            let byte;
-            do {
-                byte = stream.read_byte();
+            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_bytes(new Uint8Array(length));
-            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_bytes(4);
-            return value;
+            return stream.data_view.getFloat32(stream.consume(4));
         }
     };
     PROTO.Float64 = {
         *serialize(value, stream) {
-            const length = 8;
-            stream.write_bytes(new Uint8Array(length));
-            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_bytes(8);
-            return value;
+            return stream.data_view.getFloat64(stream.consume(8));
         }
     };
     PROTO.String = {
@@ -272,21 +258,20 @@ export var PROTO;
     };
     PROTO.Boolean = {
         *serialize(value, stream) {
-            stream.write_byte(value ? 1 : 0);
+            stream.write(value ? 1 : 0);
         },
         *deserialize(stream) {
-            const value = stream.read_byte();
-            return value === 1;
+            return stream.read() !== 0;
         }
     };
     PROTO.UInt8Array = {
         *serialize(value, stream) {
             yield* PROTO.UVarInt32.serialize(value.length, stream);
-            stream.write_bytes(value);
+            stream.write(value);
         },
         *deserialize(stream) {
             const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return stream.read_bytes(length);
+            return stream.read(length);
         }
     };
     PROTO.Date = {
@@ -297,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;
@@ -390,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;
@@ -460,12 +444,12 @@ export var NET;
                 if (char_code <= 0xff) {
                     const hex = str[j] + str[++j];
                     const hex_code = parseInt(hex, 16);
-                    buffer.write_byte(hex_code & 0xff);
-                    buffer.write_byte(hex_code >> 8);
+                    buffer.write(hex_code & 0xff);
+                    buffer.write(hex_code >> 8);
                 }
                 else {
-                    buffer.write_byte(char_code & 0xff);
-                    buffer.write_byte(char_code >> 8);
+                    buffer.write(char_code & 0xff);
+                    buffer.write(char_code >> 8);
                 }
                 yield;
             }
@@ -476,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.4",
+  "version": "3.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OmniacDev/MCBE-IPC.git"