mcbe-ipc 3.0.1 → 3.0.3

package/dist/direct.ipc.d.ts

@@ -35,11 +35,11 @@ export declare namespace DirectIPC {
         get to(): string;
         constructor(from: string, to: string, encryption: string | false);
         terminate(notify?: boolean): void;
-        send<T>(channel: string, serializer: PROTO.Serializable<T>, value: T): void;
-        invoke<T, R>(channel: string, serializer: PROTO.Serializable<T>, value: T, deserializer: PROTO.Serializable<R>): Promise<R>;
-        on<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
-        once<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
-        handle<T, R>(channel: string, deserializer: PROTO.Serializable<T>, serializer: PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+        send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+        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>;
+        on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        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;
     }
     class ConnectionManager {
         private readonly _id;
@@ -50,12 +50,12 @@ export declare namespace DirectIPC {
         private MAYBE_DECRYPT;
         get id(): string;
         constructor(id: string, force_encryption?: boolean);
-        connect(to: string, encrypted?: boolean, timeout?: number): Promise<Connection>;
-        send<T>(channel: string, serializer: PROTO.Serializable<T>, value: T): void;
-        invoke<T, R>(channel: string, serializer: PROTO.Serializable<T>, value: T, deserializer: PROTO.Serializable<R>): Promise<R>[];
-        on<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
-        once<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
-        handle<T, R>(channel: string, deserializer: PROTO.Serializable<T>, serializer: PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+        connect(to: string, encrypted?: boolean, timeout?: number, mod?: number, prime?: number): Promise<Connection>;
+        send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
+        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>[];
+        on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+        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;
     }
 }
 export default DirectIPC;

package/dist/direct.ipc.js

@@ -42,15 +42,15 @@ var CRYPTO;
         }
         return result;
     }
-    function make_secret(mod = CRYPTO.MOD) {
+    function make_secret(mod) {
         return Math.floor(Math.random() * (mod - 1)) + 1;
     }
     CRYPTO.make_secret = make_secret;
-    function* make_public(secret, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
+    function* make_public(secret, mod, prime) {
         return to_HEX(yield* mod_exp(mod, secret, prime));
     }
     CRYPTO.make_public = make_public;
-    function* make_shared(secret, other, prime = CRYPTO.PRIME) {
+    function* make_shared(secret, other, prime) {
         return to_HEX(yield* mod_exp(to_NUM(other), secret, prime));
     }
     CRYPTO.make_shared = make_shared;
@@ -235,7 +235,7 @@ export var DirectIPC;
                 $._enc_map.delete(value);
             });
         }
-        connect(to, encrypted = false, timeout = 20) {
+        connect(to, encrypted = false, timeout = 20, mod = CRYPTO.MOD, prime = CRYPTO.PRIME) {
             const $ = this;
             return new Promise((resolve, reject) => {
                 const con = this._con_map.get(to);
@@ -244,15 +244,15 @@ export var DirectIPC;
                     resolve(con);
                 }
                 else {
-                    const secret = CRYPTO.make_secret();
+                    const secret = CRYPTO.make_secret(mod);
                     system.runJob((function* () {
-                        const public_key = yield* CRYPTO.make_public(secret);
+                        const public_key = yield* CRYPTO.make_public(secret, mod, prime);
                         yield* NET.emit(`ipc:${to}:handshake:synchronize`, HandshakeSynchronizeSerializer, {
                             from: $._id,
                             encryption_enabled: encrypted,
                             encryption_public_key: public_key,
-                            encryption_prime: CRYPTO.PRIME,
-                            encryption_modulus: CRYPTO.MOD
+                            encryption_prime: prime,
+                            encryption_modulus: mod
                         });
                     })());
                     function clear() {
@@ -266,7 +266,7 @@ export var DirectIPC;
                     const terminate = NET.listen(`ipc:${this._id}:handshake:acknowledge`, HandshakeAcknowledgeSerializer, function* (data) {
                         if (data.from === to) {
                             const enc = data.encryption_enabled || encrypted
-                                ? yield* CRYPTO.make_shared(secret, data.encryption_public_key)
+                                ? yield* CRYPTO.make_shared(secret, data.encryption_public_key, prime)
                                 : false;
                             const new_con = new Connection($._id, to, enc);
                             $._con_map.set(to, new_con);

package/dist/ipc.d.ts

@@ -47,6 +47,8 @@ export declare namespace PROTO {
         function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
     }
     const Void: PROTO.Serializable<void>;
+    const Null: PROTO.Serializable<null>;
+    const Undefined: PROTO.Serializable<undefined>;
     const Int8: PROTO.Serializable<number>;
     const Int16: PROTO.Serializable<number>;
     const Int32: PROTO.Serializable<number>;
@@ -83,19 +85,19 @@ export declare namespace PROTO {
 export declare namespace NET {
     function serialize(byte_queue: PROTO.ByteQueue, max_size?: number): Generator<void, string[], void>;
     function deserialize(strings: string[]): Generator<void, PROTO.ByteQueue, void>;
-    function emit<T>(endpoint: string, serializer: PROTO.Serializable<T>, value: T): Generator<void, void, void>;
-    function listen<T>(endpoint: string, serializer: PROTO.Serializable<T>, callback: (value: T) => Generator<void, void, void>): () => 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;
 }
 export declare namespace IPC {
     /** Sends a message with `args` to `channel` */
-    function send<T>(channel: string, serializer: PROTO.Serializable<T>, value: T): void;
+    function send<S extends PROTO.Serializable<T>, T>(channel: string, serializer: S & PROTO.Serializable<T>, value: T): void;
     /** Sends an `invoke` message through IPC, and expects a result asynchronously. */
-    function invoke<T, R>(channel: string, serializer: PROTO.Serializable<T>, value: T, deserializer: PROTO.Serializable<R>): Promise<R>;
+    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>;
     /** Listens to `channel`. When a new message arrives, `listener` will be called with `listener(args)`. */
-    function on<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function on<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.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. */
-    function once<T>(channel: string, deserializer: PROTO.Serializable<T>, listener: (value: T) => void): () => void;
+    function once<S extends PROTO.Serializable<T>, T>(channel: string, deserializer: S & PROTO.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 */
-    function handle<T, R>(channel: string, deserializer: PROTO.Serializable<T>, serializer: PROTO.Serializable<R>, listener: (value: T) => R): () => void;
+    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;
 }
 export default IPC;

package/dist/ipc.js

@@ -111,6 +111,18 @@ export var PROTO;
         *serialize() { },
         *deserialize() { }
     };
+    PROTO.Null = {
+        *serialize() { },
+        *deserialize() {
+            return null;
+        }
+    };
+    PROTO.Undefined = {
+        *serialize() { },
+        *deserialize() {
+            return undefined;
+        }
+    };
     PROTO.Int8 = {
         *serialize(value, stream) {
             const length = 1;

package/dist/proto.d.ts

@@ -47,6 +47,8 @@ export declare namespace PROTO {
         function deserialize(str: string): Generator<void, PROTO.ByteQueue, void>;
     }
     const Void: PROTO.Serializable<void>;
+    const Null: PROTO.Serializable<null>;
+    const Undefined: PROTO.Serializable<undefined>;
     const Int8: PROTO.Serializable<number>;
     const Int16: PROTO.Serializable<number>;
     const Int32: PROTO.Serializable<number>;

package/dist/proto.js

@@ -110,6 +110,18 @@ export var PROTO;
         *serialize() { },
         *deserialize() { }
     };
+    PROTO.Null = {
+        *serialize() { },
+        *deserialize() {
+            return null;
+        }
+    };
+    PROTO.Undefined = {
+        *serialize() { },
+        *deserialize() {
+            return undefined;
+        }
+    };
     PROTO.Int8 = {
         *serialize(value, stream) {
             const length = 1;

package/package.json

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