mcbe-ipc 2.0.1 → 3.0.0

package/README.md

@@ -17,74 +17,4 @@ An IPC[^1] system for MCBE Script API projects
 
 **TypeScript**
 1. Download `ipc.ts` from the latest [release](https://github.com/OmniacDev/MCBE-IPC/releases/latest)
-2. Copy file into your project
-
-##  Usage
-
-### Sending & Receiving
-
-`IPC.send()` and `IPC.on()` can be used to send messages or data between packs. 
-
-_Pack 1_
-```js
-import IPC from 'ipc.js'
-
-IPC.on('message_channel', (args) => {
-  console.log(`Message: ${args}`)
-})
-
-IPC.on('data_channel', (args) => {
-  console.log(`Data: ${args.example_bool}, ${args.example_number}`)
-})
-```
-_Pack 2_
-```js
-import IPC from 'ipc.js'
-
-IPC.send('message_channel', 'Example Message')
-
-IPC.send('data_channel', { example_number: 100, example_bool: true })
-```
-_Console Output_
-```
-Message: Example Message
-Data: true, 100
-```
-
-### Requesting & Serving
-
-`IPC.invoke()` and `IPC.handle()` can be used to request and serve data between packs.
-
-_Pack 1_
-```js
-import IPC from 'ipc.js'
-
-IPC.handle('request_channel', (args) => {
-  switch (args) {
-    case 'status': 
-      return 'inactive'
-    case 'size': 
-      return 100
-  }
-})
-```
-_Pack 2_
-```js
-import IPC from 'ipc.js'
-
-IPC.invoke('request_channel', 'status').then(result => {
-  console.log(`Status: ${result}`)
-})
-
-IPC.invoke('request_channel', 'size').then(result => {
-  console.log(`Size: ${result}`)
-})
-```
-_Console Output_
-```
-Status: inactive
-Size: 100
-```
-
-
-
+2. Copy file into your project

package/dist/ipc.d.ts

@@ -22,11 +22,75 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-declare namespace IPC {
-    type SendTypes = {};
-    type InvokeTypes = {};
-    type HandleTypes = {};
-    export class Connection {
+export declare namespace SERDE {
+    class ByteArray {
+        private _buffer;
+        private _data_view;
+        private _length;
+        private _offset;
+        private get _end();
+        constructor(size?: number);
+        write(...values: number[]): void;
+        read(amount?: number): number[];
+        write_uint8(value: number): void;
+        read_uint8(): number | undefined;
+        write_uint16(value: number): void;
+        read_uint16(): number | undefined;
+        write_uint32(value: number): void;
+        read_uint32(): number | undefined;
+        write_int8(value: number): void;
+        read_int8(): number | undefined;
+        write_int16(value: number): void;
+        read_int16(): number | undefined;
+        write_int32(value: number): void;
+        read_int32(): number | undefined;
+        write_f32(value: number): void;
+        read_f32(): number | undefined;
+        write_f64(value: number): void;
+        read_f64(): number | undefined;
+        private _ensure_capacity;
+        static from_uint8array(array: Uint8Array): ByteArray;
+        to_uint8array(): Uint8Array;
+    }
+    function serialize(byte_array: ByteArray, max_size?: number): Generator<void, string[], void>;
+    function deserialize(strings: string[]): Generator<void, ByteArray, void>;
+}
+export declare class Proto {
+    static Int8: NET.Serializable<number>;
+    static Int16: NET.Serializable<number>;
+    static Int32: NET.Serializable<number>;
+    static UInt8: NET.Serializable<number>;
+    static UInt16: NET.Serializable<number>;
+    static UInt32: NET.Serializable<number>;
+    static Float32: NET.Serializable<number>;
+    static Float64: NET.Serializable<number>;
+    static VarInt: NET.Serializable<number>;
+    static String: NET.Serializable<string>;
+    static Boolean: NET.Serializable<boolean>;
+    static UInt8Array: NET.Serializable<Uint8Array>;
+    static Date: NET.Serializable<Date>;
+    static Object<T extends object>(obj: {
+        [K in keyof T]: NET.Serializable<T[K]>;
+    }): NET.Serializable<T>;
+    static Array<T>(items: NET.Serializable<T>): NET.Serializable<T[]>;
+    static Tuple<T extends any[]>(...items: {
+        [K in keyof T]: NET.Serializable<T[K]>;
+    }): NET.Serializable<T>;
+    static Optional<T>(item: NET.Serializable<T>): NET.Serializable<T | undefined>;
+    static Map<K, V>(key: NET.Serializable<K>, value: NET.Serializable<V>): NET.Serializable<Map<K, V>>;
+    static Set<V>(value: NET.Serializable<V>): NET.Serializable<Set<V>>;
+}
+export declare namespace NET {
+    interface Serializable<T = any> {
+        serialize(value: T, stream: ByteArray): Generator<void, void, void>;
+        deserialize(stream: ByteArray): Generator<void, T, void>;
+    }
+    import ByteArray = SERDE.ByteArray;
+    function emit<T>(endpoint: string, serializer: Serializable<T>, value: T): Generator<void, void, void>;
+    function listen<T>(endpoint: string, serializer: Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => void;
+}
+export declare namespace IPC {
+    class Connection {
         private readonly _from;
         private readonly _to;
         private readonly _enc;
@@ -37,13 +101,13 @@ declare namespace IPC {
         get to(): string;
         constructor(from: string, to: string, encryption: string | false);
         terminate(notify?: boolean): void;
-        send<T extends any[]>(channel: string, ...args: T): void;
-        invoke<T extends any[], R extends any>(channel: string, ...args: T): Promise<R>;
-        on<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
-        once<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
-        handle<T extends any[], R extends any>(channel: string, listener: (...args: T) => R): () => void;
+        send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
+        invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>;
+        on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+        once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+        handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
     }
-    export class ConnectionManager {
+    class ConnectionManager {
         private readonly _id;
         private readonly _enc_map;
         private readonly _con_map;
@@ -53,36 +117,21 @@ declare namespace IPC {
         get id(): string;
         constructor(id: string, force_encryption?: boolean);
         connect(to: string, encrypted?: boolean, timeout?: number): Promise<Connection>;
-        send<T extends any[]>(channel: string, ...args: T): void;
-        invoke<T extends any[], R extends any>(channel: string, ...args: T): Promise<R>[];
-        on<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
-        once<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
-        handle<T extends any[], R extends any>(channel: string, listener: (...args: T) => R): () => void;
+        send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
+        invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>[];
+        on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+        once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
+        handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
     }
     /** Sends a message with `args` to `channel` */
-    export function send<C extends keyof SendTypes>(channel: C, ...args: SendTypes[C]): void;
-    /** Sends a message with `args` to `channel` */
-    export function send<T extends any[]>(channel: string, ...args: T): void;
+    function send<T>(channel: string, serializer: NET.Serializable<T>, value: T): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    export function invoke<C extends keyof (HandleTypes & InvokeTypes)>(channel: C, ...args: InvokeTypes[C]): Promise<HandleTypes[C]>;
-    /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    export function invoke<T extends any[], R extends any>(channel: string, ...args: T): Promise<R>;
-    /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    export function on<C extends keyof SendTypes>(channel: C, listener: (...args: SendTypes[C]) => void): () => void;
+    function invoke<T, R>(channel: string, serializer: NET.Serializable<T>, value: T, deserializer: NET.Serializable<R>): Promise<R>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    export function on<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
-    /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    export function once<C extends keyof SendTypes>(channel: C, listener: (...args: SendTypes[C]) => void): () => void;
+    function on<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
     /** Listens to `channel` once. When a new message arrives, `listener` will be called with `listener(args)`, and then removed. */
-    export function once<T extends any[]>(channel: string, listener: (...args: T) => void): () => void;
+    function once<T>(channel: string, deserializer: NET.Serializable<T>, listener: (value: T) => void): () => void;
     /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    export function handle<C extends keyof (HandleTypes & InvokeTypes)>(channel: C, listener: (...args: InvokeTypes[C]) => HandleTypes[C]): () => void;
-    /** Adds a handler for an `invoke` IPC. This handler will be called whenever `invoke(channel, ...args)` is called */
-    export function handle<T extends any[], R extends any>(channel: string, listener: (...args: T) => R): () => void;
-    export {};
+    function handle<T, R>(channel: string, deserializer: NET.Serializable<T>, serializer: NET.Serializable<R>, listener: (value: T) => R): () => void;
 }
 export default IPC;
-export declare namespace NET {
-    function emit<T = any>(namespace: string, channel: string, args: T): Generator<void, void, void>;
-    function listen<T = any>(namespace: string, channel: string, callback: (args: T) => Generator<void, void, void>): () => void;
-}