mcbe-ipc 3.1.3 → 3.1.4

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,10 @@ export declare namespace PROTO {
         get front(): number;
         get data_view(): DataView;
         constructor(size?: number);
-        write(...values: number[]): void;
-        read(amount?: number): number[];
+        write_byte(byte: number): void;
+        write_bytes(bytes: Uint8Array): void;
+        read_byte(): number;
+        read_bytes(amount: number): Uint8Array;
         ensure_capacity(size: number): void;
         static from_uint8array(array: Uint8Array): Buffer;
         to_uint8array(): Uint8Array;
@@ -86,19 +89,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: S): 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,31 @@ 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;
+        write_byte(byte) {
+            this.ensure_capacity(1);
+            this._buffer[this.end] = byte;
+            this._length++;
         }
-        read(amount = 1) {
+        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.subarray(this._offset, this._offset + max_amount);
+                const values = this._buffer.slice(this._offset, this._offset + max_amount);
                 this._length -= max_amount;
                 this._offset += max_amount;
-                return globalThis.Array.from(values);
+                return values;
             }
-            return [];
+            return new Uint8Array();
         }
         ensure_capacity(size) {
             if (this.end + size > this._buffer.length) {
@@ -98,7 +109,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(parseInt(hex, 16));
+                    buffer.write_byte(parseInt(hex, 16));
                     yield;
                 }
                 return buffer;
@@ -126,90 +137,90 @@ export var PROTO;
     PROTO.Int8 = {
         *serialize(value, stream) {
             const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt8(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt8(stream.front);
-            stream.read(1);
+            stream.read_bytes(1);
             return value;
         }
     };
     PROTO.Int16 = {
         *serialize(value, stream) {
             const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt16(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt16(stream.front);
-            stream.read(2);
+            stream.read_bytes(2);
             return value;
         }
     };
     PROTO.Int32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setInt32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getInt32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.UInt8 = {
         *serialize(value, stream) {
             const length = 1;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint8(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint8(stream.front);
-            stream.read(1);
+            stream.read_bytes(1);
             return value;
         }
     };
     PROTO.UInt16 = {
         *serialize(value, stream) {
             const length = 2;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint16(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint16(stream.front);
-            stream.read(2);
+            stream.read_bytes(2);
             return value;
         }
     };
     PROTO.UInt32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setUint32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getUint32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.UVarInt32 = {
         *serialize(value, stream) {
             while (value >= 0x80) {
-                stream.write((value & 0x7f) | 0x80);
+                stream.write_byte((value & 0x7f) | 0x80);
                 value >>= 7;
                 yield;
             }
-            stream.write(value);
+            stream.write_byte(value);
         },
         *deserialize(stream) {
             let value = 0;
             let size = 0;
             let byte;
             do {
-                byte = stream.read()[0];
+                byte = stream.read_byte();
                 value |= (byte & 0x7f) << (size * 7);
                 size += 1;
                 yield;
@@ -220,24 +231,24 @@ export var PROTO;
     PROTO.Float32 = {
         *serialize(value, stream) {
             const length = 4;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setFloat32(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getFloat32(stream.front);
-            stream.read(4);
+            stream.read_bytes(4);
             return value;
         }
     };
     PROTO.Float64 = {
         *serialize(value, stream) {
             const length = 8;
-            stream.write(...globalThis.Array(length).fill(0));
+            stream.write_bytes(new Uint8Array(length));
             stream.data_view.setFloat64(stream.end - length, value);
         },
         *deserialize(stream) {
             const value = stream.data_view.getFloat64(stream.front);
-            stream.read(8);
+            stream.read_bytes(8);
             return value;
         }
     };
@@ -261,21 +272,21 @@ export var PROTO;
     };
     PROTO.Boolean = {
         *serialize(value, stream) {
-            stream.write(value ? 1 : 0);
+            stream.write_byte(value ? 1 : 0);
         },
         *deserialize(stream) {
-            const value = stream.read()[0];
+            const value = stream.read_byte();
             return value === 1;
         }
     };
     PROTO.UInt8Array = {
         *serialize(value, stream) {
             yield* PROTO.UVarInt32.serialize(value.length, stream);
-            stream.write(...value);
+            stream.write_bytes(value);
         },
         *deserialize(stream) {
             const length = yield* PROTO.UVarInt32.deserialize(stream);
-            return new Uint8Array(stream.read(length));
+            return stream.read_bytes(length);
         }
     };
     PROTO.Date = {
@@ -449,12 +460,12 @@ export var NET;
                 if (char_code <= 0xff) {
                     const hex = str[j] + str[++j];
                     const hex_code = parseInt(hex, 16);
-                    buffer.write(hex_code & 0xff);
-                    buffer.write(hex_code >> 8);
+                    buffer.write_byte(hex_code & 0xff);
+                    buffer.write_byte(hex_code >> 8);
                 }
                 else {
-                    buffer.write(char_code & 0xff);
-                    buffer.write(char_code >> 8);
+                    buffer.write_byte(char_code & 0xff);
+                    buffer.write_byte(char_code >> 8);
                 }
                 yield;
             }

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.1.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OmniacDev/MCBE-IPC.git"