@bikky/replication 1.0.1

package/Networking.js

@@ -0,0 +1,626 @@
+import { SmartArray } from "@bikky/smart-collections";
+import { Replicable } from "./Replicatable.js";
+var InstanceByProxy = new Map();
+var LocalTime;
+let lastUpdate = Date.now();
+var Connections;
+(function (Connections) {
+    Connections.RemotesByID = new Map();
+    Connections.Remotes = new SmartArray();
+    Connections.Interfaces = new Map();
+    Connections.disconnectHandlers = new Map();
+    /**
+     * There's one RemoteConnection per remote PC. All instances reference the RemoteConnection.
+     * The RemoteConnection handles batching as well as keeping track of the ping of clients and
+     * how far behind they are.
+     */
+    class RemoteConnection {
+        constructor(id, connection) {
+            this.ping = -1;
+            this.pingHistory = [];
+            this.time = -1;
+            this.messages = [];
+            this.id = id;
+            this.socket = connection;
+            if ("on" in this.socket) {
+                this.socket.on("message", (body) => {
+                    var data = JSON.parse(body);
+                    this.recieveMessages(data, id);
+                });
+                this.socket.on("close", (code, reason) => {
+                    this.handleDisconnect();
+                });
+            }
+            else {
+                this.socket.onmessage = (event) => {
+                    var body = event.data;
+                    var data = JSON.parse(body);
+                    this.recieveMessages(data, id);
+                };
+                this.socket.onclose = (event) => {
+                    this.handleDisconnect();
+                };
+            }
+            Connections.disconnectHandlers.set(id, []);
+            Connections.RemotesByID.set(id, this);
+            Connections.Remotes.push(this);
+        }
+        handleDisconnect() {
+            for (var handler of Connections.disconnectHandlers.get(this.id)) {
+                handler();
+            }
+            Connections.RemotesByID.delete(this.id);
+            Connections.Remotes.remove(this);
+            for (var remoteInterface of Connections.Interfaces.values()) {
+                remoteInterface.removeConnection(this.id, this);
+            }
+            Connections.disconnectHandlers.delete(this.id);
+        }
+        recieveMessages(data, remoteID) {
+            this.ping = data.time - this.time;
+            this.pingHistory.unshift(this.ping);
+            if (this.pingHistory.length > 5) {
+                this.pingHistory.pop();
+            }
+            this.time = data.time;
+            if (!Messenger.isServer) {
+                //TODO: Add ping to this calculation, but ping should be calculated based on the messages' clientTime not serverTime.
+                LocalTime = data.time; // + this.ping / 2;
+                lastUpdate = Date.now();
+            }
+            for (var message of data.messages) {
+                var target = Connections.Interfaces.get(message.id);
+                if (target) {
+                    target.recieveMessage(message, remoteID);
+                }
+                else {
+                    console.error("Remote tried to send a message to", message.id, "but no interface by that id exists");
+                }
+            }
+        }
+        queueMessage(obj) {
+            this.messages.push(obj);
+        }
+        sendMessages() {
+            try {
+                this.socket.send(JSON.stringify({
+                    time: LocalTime,
+                    messages: this.messages
+                }));
+                this.messages = [];
+            }
+            catch (e) {
+                console.log("------------------------------------------------");
+                console.log(e);
+                console.log("Failed to send message batch");
+                console.log("------------------------------------------------");
+            }
+        }
+    }
+    Connections.RemoteConnection = RemoteConnection;
+    //This has the traps for the proxy to send messages over the network.
+    class RemoteInstance {
+        constructor(remoteID, connection, remoteInterface) {
+            this.propertyMap = new Map();
+            this.remoteID = remoteID;
+            this.connection = connection;
+            this.interface = remoteInterface;
+        }
+        send(message) {
+            try {
+                this.connection.queueMessage(message);
+            }
+            catch (e) {
+                console.log("------------------------------------------------");
+                console.log(e);
+                console.log(message);
+                console.log("------------------------------------------------");
+            }
+        }
+        get(target, property) {
+            if (typeof property === "symbol") {
+                //this can be triggered by console logging a proxy so we should handle it nicely.
+                console.error("Can't invoke symbol on remote!");
+                return "This is a proxy";
+            }
+            var send = (property, ...args) => {
+                var key;
+                var promise = new Promise((resolve, reject) => {
+                    key = this.interface.addCompletion(resolve);
+                });
+                var data = {
+                    id: this.interface.objectID,
+                    property: property,
+                    args: args.map((e) => {
+                        if (Replicable.CanReference(e)) {
+                            return Replicable.Reference(e);
+                        }
+                        return ["Plain", e];
+                    }),
+                    key: key,
+                    from: Connections.LocalID,
+                    tick: LocalTime
+                };
+                this.send(data);
+                return promise;
+            };
+            if (typeof property === "string") {
+                var result = this.propertyMap.get(property);
+                if (result) {
+                    return result;
+                }
+                //Proxy has to wrap a function to be callable.
+                var proxy = new Proxy(() => { }, new PropertyProxy([property], send));
+                this.propertyMap.set(property, proxy);
+                return proxy;
+            }
+            else {
+                return (...args) => send(property, ...args);
+            }
+        }
+        //A trap for setting property values.
+        set(target, property, value, receiver) {
+            throw new Error("Don't set properties on remote objects directly, use the set function!");
+            //return false;
+        }
+        //A trap for a direct function call (not a method).
+        apply(...args) {
+            var key;
+            var promise = new Promise((resolve, reject) => {
+                key = this.interface.addCompletion(resolve);
+            });
+            var data = {
+                id: this.interface.objectID,
+                function: true,
+                args: args.map((e) => {
+                    if (Replicable.CanReference(e)) {
+                        return Replicable.Reference(e);
+                    }
+                    return ["Plain", e];
+                }),
+                key: key,
+                from: Connections.LocalID,
+                tick: LocalTime
+            };
+            this.send(data);
+            return promise;
+        }
+        //A trap for the new operator.
+        construct(target, args, newTarget) {
+            throw new Error("Construct Trap Not Implemented");
+            //return {};
+        }
+    }
+    Connections.RemoteInstance = RemoteInstance;
+    //This class allows you to send messages to property's functions. E.g. remote.property.foo.
+    //It was coded at midnight and in a rush, so it's poorly typed and named.
+    class PropertyProxy {
+        constructor(propertyPath, send) {
+            this.propertyMap = new Map();
+            this.propertyPath = propertyPath;
+            this.parentSend = send;
+        }
+        //A trap for getting property values.
+        get(target, property) {
+            if (typeof property === "symbol") {
+                //this can be triggered by console logging a proxy so we should handle it nicely.
+                console.error("Can't invoke symbol on remote!");
+                return "This is a proxy";
+            }
+            else {
+                if (typeof property === "string") {
+                    var result = this.propertyMap.get(property);
+                    if (result) {
+                        return result;
+                    }
+                    //Proxy has to wrap a function to be callable.
+                    var proxy = new Proxy(() => { }, new PropertyProxy([...this.propertyPath, property], this.parentSend));
+                    this.propertyMap.set(property, proxy);
+                    return proxy;
+                }
+                else {
+                    //property can be a number here, but I didn't want to update the typings everywhere.
+                    return (...args) => {
+                        return this.parentSend([...this.propertyPath, property], ...args);
+                    };
+                }
+            }
+        }
+        //A trap for setting property values.
+        set(target, property, value, receiver) {
+            throw new Error("Don't set properties on remote objects directly, use the set function!");
+            //return false;
+        }
+        //A trap for a direct function call (not a method).
+        apply(target, thisArg, args) {
+            return this.parentSend(this.propertyPath, ...args);
+        }
+    }
+    //This can hold one remote for client stuff (the server) or many remotes for server stuff (one for each client)
+    // and the user won't know the difference.
+    class RemoteInterface {
+        constructor(objectID, local) {
+            this.remotes = new Map();
+            this.nextKey = 0;
+            this.completions = new Map();
+            //Allows users to access sub-properties via getters.
+            this.propertyMap = new Map();
+            this.objectID = objectID;
+            this.local = local;
+            Connections.Interfaces.set(this.objectID, this);
+        }
+        divertMessages(newLocal) {
+            if (!this.oldLocal) {
+                this.oldLocal = this.local;
+            }
+            this.local = newLocal;
+        }
+        restoreMessageRecipient() {
+            if (this.oldLocal) {
+                this.local = this.oldLocal;
+                delete this.oldLocal;
+            }
+        }
+        getNewKey() {
+            var key = this.nextKey;
+            this.nextKey++;
+            return key;
+        }
+        addCompletion(resolver) {
+            var key = this.getNewKey();
+            this.completions.set(key, resolver);
+            return key;
+        }
+        addConnection(remoteID, connection) {
+            var remoteInstance = new RemoteInstance(remoteID, connection, this);
+            remoteInstance.proxy = new Proxy({}, remoteInstance);
+            InstanceByProxy.set(remoteInstance.proxy, remoteInstance);
+            this.remotes.set(remoteID, remoteInstance);
+        }
+        removeConnection(remoteID, connection) {
+            var instance = this.remotes.get(remoteID);
+            this.remotes.delete(remoteID);
+            return instance;
+        }
+        recieveMessage(data, remoteID) {
+            var remote = this.remotes.get(remoteID);
+            if (!remote) {
+                return;
+            }
+            if ("completion" in data) {
+                var completion = this.completions.get(data.key);
+                if (completion) {
+                    this.completions.delete(data.key);
+                    completion(data.result);
+                    return;
+                }
+                else {
+                    //throw new Error("Got a message for a completion that's already been completed");
+                    console.error("Got a message for a completion that's already been completed", data);
+                    return;
+                }
+            }
+            if (data.property) {
+                var objectID = this.objectID;
+                function sendResponse(result) {
+                    var response = {
+                        id: objectID,
+                        property: data.property,
+                        completion: true, //the function has finished being called.
+                        key: data.key,
+                        result: result,
+                        from: Connections.LocalID,
+                        tick: LocalTime
+                    };
+                    remote.send(response);
+                }
+                let args = data.args.map((e) => {
+                    if (Array.isArray(e) && e[0] === "Plain") {
+                        return e[1];
+                    }
+                    if (Replicable.IsReference(e)) {
+                        return Replicable.Dereference(e);
+                    }
+                    return e;
+                });
+                args.push({ connection: remote.proxy, id: data.from, tick: data.tick });
+                var target = this.local;
+                var prop = data.property;
+                if (Array.isArray(prop)) {
+                    for (var i = 0; i < prop.length - 1; i++) {
+                        target = target[prop[i]];
+                    }
+                    //Store the last one.
+                    prop = prop[i];
+                }
+                var returned = target[prop].apply(target, args);
+                if (returned instanceof Promise) {
+                    returned.then(sendResponse.bind(this));
+                }
+                else {
+                    sendResponse.call(this, returned);
+                }
+            }
+            if (data.function) {
+                let args = data.args.map((e) => {
+                    if (Array.isArray(e) && e[0] === "Plain") {
+                        return e[1];
+                    }
+                    if (Replicable.IsReference(e)) {
+                        return Replicable.Dereference(e);
+                    }
+                    return e;
+                });
+                args.push({ connection: remote.proxy, id: data.from, tick: data.tick });
+                this.local
+                    .apply(this.local, args)
+                    .then((result) => {
+                    var response = {
+                        id: this.objectID,
+                        property: data.property,
+                        completion: true, //the function has finished being called.
+                        key: data.key,
+                        result: result,
+                        from: Connections.LocalID,
+                        tick: LocalTime
+                    };
+                    remote.send(response);
+                });
+            }
+        }
+        //A trap for getting property values.
+        get(target, property) {
+            if (typeof property === "symbol") {
+                //this can be triggered by console logging a proxy so we should handle it nicely.
+                console.error("Can't invoke symbol on remote!");
+                return "This is a proxy";
+            }
+            else {
+                var send = (property, ...args) => {
+                    if (Messenger.isServer) {
+                        var promises = [];
+                        for (var remote of this.remotes.values()) {
+                            let remoteFunction = remote.get(target, property);
+                            promises.push(remoteFunction.apply(remote, args));
+                        }
+                        //Don't return results from every client - as this is probably unintentional.
+                        return new Promise((res, rej) => {
+                            Promise.all(promises)
+                                .then(() => res())
+                                .catch(rej);
+                        });
+                    }
+                    else {
+                        for (var remote of this.remotes.values()) {
+                            let remoteFunction = remote.get(target, property);
+                            return remoteFunction.apply(remote, args);
+                        }
+                    }
+                };
+                if (typeof property === "string") {
+                    var result = this.propertyMap.get(property);
+                    if (result) {
+                        return result;
+                    }
+                    //Proxy has to wrap a function to be callable.
+                    var proxy = new Proxy(() => { }, new PropertyProxy([property], send));
+                    this.propertyMap.set(property, proxy);
+                    return proxy;
+                }
+                else {
+                    return (...args) => send(property, ...args);
+                }
+            }
+        }
+        //A trap for setting property values.
+        set(target, property, value, receiver) {
+            throw new Error("Don't set properties on remote objects directly, use the set function!");
+            //return false;
+        }
+        //A trap for a direct function call (not a method).
+        apply(...args) {
+            return (...args) => {
+                if (Messenger.isServer) {
+                    var promises = [];
+                    for (var remote of this.remotes.values()) {
+                        promises.push(remote.apply(remote, args));
+                    }
+                    //Don't return results from every client - as this is probably unintentional.
+                    return new Promise((res, rej) => {
+                        Promise.all(promises)
+                            .then(() => res())
+                            .catch(rej);
+                    });
+                }
+                else {
+                    for (var remote of this.remotes.values()) {
+                        return remote.apply(remote, args);
+                    }
+                }
+            };
+        }
+        //A trap for the new operator.
+        construct(target, args, newTarget) {
+            throw new Error("Construct Trap Not Implemented");
+            //return {};
+        }
+    }
+    Connections.RemoteInterface = RemoteInterface;
+})(Connections || (Connections = {}));
+export var Messenger;
+(function (Messenger) {
+    var InterfaceByProxy = new Map();
+    Messenger.isConnected = false;
+    var resolveConnectPromise;
+    Messenger.connect = new Promise((resolve) => (resolveConnectPromise = resolve));
+    let serverID = null;
+    function initialise(localID, isTheServer, time) {
+        Connections.LocalID = localID;
+        Messenger.isServer = isTheServer;
+        Messenger.isConnected = Messenger.isServer;
+        if (Messenger.isServer) {
+            LocalTime = 0;
+            lastUpdate = Date.now();
+            serverID = localID;
+            resolveConnectPromise();
+        }
+        else {
+            if (typeof time === "undefined") {
+                throw new Error("Can't initialise client without server time");
+            }
+            LocalTime = time;
+            lastUpdate = Date.now();
+        }
+    }
+    Messenger.initialise = initialise;
+    //var lastMessage = 0;
+    function tick() {
+        let nextUpdate = Date.now();
+        LocalTime += nextUpdate - lastUpdate;
+        lastUpdate = nextUpdate;
+    }
+    Messenger.tick = tick;
+    function sendMessages() {
+        for (var conn of Connections.Remotes) {
+            conn.sendMessages();
+        }
+    }
+    Messenger.sendMessages = sendMessages;
+    function getLocalTime() {
+        return LocalTime;
+    }
+    Messenger.getLocalTime = getLocalTime;
+    function onDisconnect(id, handler) {
+        if (Connections.disconnectHandlers.has(id)) {
+            Connections.disconnectHandlers.get(id).push(handler);
+            return;
+        }
+        throw new Error("Can't add handler for connection that doesn't exist");
+    }
+    Messenger.onDisconnect = onDisconnect;
+    //Connection is any because it throws an error during compile on the server - WebSocket the type isn't defined on the server.
+    function addRemoteConnection(id, connection) {
+        var websocket = connection;
+        var remote = new Connections.RemoteConnection(id, websocket);
+        for (var remoteInterface of Connections.Interfaces.values()) {
+            remoteInterface.addConnection(id, remote);
+        }
+        if (!Messenger.isServer) {
+            serverID = id;
+            resolveConnectPromise();
+        }
+    }
+    Messenger.addRemoteConnection = addRemoteConnection;
+    //Local will usually be different to type even though they represent the same object/entity,
+    // because usually the server will have different functions to the client.
+    function newRemoteInterface(name, object) {
+        var remoteInterface = new Connections.RemoteInterface(name, object);
+        Connections.Interfaces.set(name, remoteInterface);
+        var proxy = new Proxy({}, remoteInterface);
+        InterfaceByProxy.set(proxy, remoteInterface);
+        for (var [id, connection] of Connections.RemotesByID.entries()) {
+            remoteInterface.addConnection(id, connection);
+        }
+        console.info("Made new interface", name, "for", object.__proto__.constructor.name, object.name || "");
+        return proxy;
+    }
+    Messenger.newRemoteInterface = newRemoteInterface;
+    function getInstanceForID(remoteInterface, id) {
+        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
+        if (trueRemoteInterface) {
+            var remote = trueRemoteInterface.remotes.get(id);
+            if (remote) {
+                return remote.proxy;
+            }
+        }
+        return null;
+    }
+    Messenger.getInstanceForID = getInstanceForID;
+    function getAllInstancesExceptID(remoteInterface, id) {
+        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
+        if (trueRemoteInterface) {
+            var instances = [];
+            for (var remote of trueRemoteInterface.remotes.values()) {
+                if (remote.remoteID !== id) {
+                    instances.push(remote.proxy);
+                }
+            }
+            return instances;
+        }
+        return null;
+    }
+    Messenger.getAllInstancesExceptID = getAllInstancesExceptID;
+    function getAllInstancesExcept(remoteInterface, remoteInstance) {
+        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
+        if (trueRemoteInterface) {
+            var instances = [];
+            for (var remote of trueRemoteInterface.remotes.values()) {
+                if (remote.proxy != remoteInstance) {
+                    instances.push(remote.proxy);
+                }
+            }
+            return instances;
+        }
+        return null;
+    }
+    Messenger.getAllInstancesExcept = getAllInstancesExcept;
+    function getRemoteTime(id) {
+        var _a, _b;
+        return (_b = (_a = Connections.RemotesByID.get(id)) === null || _a === void 0 ? void 0 : _a.time) !== null && _b !== void 0 ? _b : null;
+    }
+    Messenger.getRemoteTime = getRemoteTime;
+    function getRemotePing(id) {
+        var _a, _b;
+        return (_b = (_a = Connections.RemotesByID.get(id)) === null || _a === void 0 ? void 0 : _a.ping) !== null && _b !== void 0 ? _b : null;
+    }
+    Messenger.getRemotePing = getRemotePing;
+    function getRemoteAvgPing(id) {
+        var remote = Connections.RemotesByID.get(id);
+        if (!remote)
+            return null;
+        return remote.pingHistory.reduce((a, b) => a + b) / remote.pingHistory.length;
+    }
+    Messenger.getRemoteAvgPing = getRemoteAvgPing;
+    function getIDForInstance(remoteInterface, remoteInstance) {
+        var trueRemoteInterface = InterfaceByProxy.get(remoteInterface);
+        if (trueRemoteInterface) {
+            for (var remote of trueRemoteInterface.remotes.values()) {
+                if (remote.proxy == remoteInstance) {
+                    return remote.remoteID;
+                }
+            }
+        }
+        return null;
+    }
+    Messenger.getIDForInstance = getIDForInstance;
+    function isRemoteProxy(remote) {
+        return InterfaceByProxy.has(remote) || InstanceByProxy.has(remote);
+    }
+    Messenger.isRemoteProxy = isRemoteProxy;
+    function getLocalID() {
+        return Connections.LocalID;
+    }
+    Messenger.getLocalID = getLocalID;
+    /**
+     * Will return the local id if on the server. Assumes that only the server connects to clients.
+     */
+    function getServerID() {
+        if (serverID === null) {
+            throw new Error(`Cannot get remote ID before server has connected/initialised.`);
+        }
+        return serverID;
+    }
+    Messenger.getServerID = getServerID;
+    //Diverts messages from their original target to a new target. Good for proxies.
+    function divertMessages(remote, newTarget) {
+        var rInterface = InterfaceByProxy.get(remote);
+        rInterface.divertMessages(newTarget);
+    }
+    Messenger.divertMessages = divertMessages;
+    //Restores diverted messages to their original target.
+    function restoreMessages(remote) {
+        var rInterface = InterfaceByProxy.get(remote);
+        rInterface.restoreMessageRecipient();
+    }
+    Messenger.restoreMessages = restoreMessages;
+})(Messenger || (Messenger = {}));

package/Replicatable.d.ts

@@ -0,0 +1,66 @@
+import { ReplicableRegistry } from "./Constants/ReplicableRegistry.js";
+import { getClassOfObject as GetClassOfObjectInternal } from "./Constants/SerialisationTypes.js";
+import { SourceMap } from "./Constants/SourceMaps.js";
+import { ConstructorArgs as ConstArgs } from "./Tracking/Types.js";
+import { Definitions } from "./Transformers/Definitions.js";
+import { Referencer } from "./Transformers/Reference.js";
+import { Utils } from "./Transformers/Utils.js";
+import { Serialiser } from "./Transformers/Serialiser.js";
+export declare namespace Replicable {
+    /**
+     * Can be used to create a new instance of a replicable class, even from serialised data.
+     * When restoring serialised data provide the serialised data as the "data" parameter of the options.
+     * @param Class the class to create an instance of.
+     * @param opts the options for creating the instance.
+     */
+    function Create<C extends AnyClass<any>, T extends (C extends {
+        new (...args: any[]): infer J;
+    } ? J : never), A extends (C extends {
+        new (...args: infer J): object;
+    } ? J : never)>(Class: C | string, opts?: {
+        args?: A;
+        data?: any | [string, any];
+        source?: SourceMap;
+        owner?: any;
+    }): T;
+    function Initialise<T extends object>(object: T, data: ConstructorArgs, expressionParams?: {
+        type: any;
+        scope: {
+            [key: string]: any;
+        };
+    }): T;
+    function Load<T extends object>(object: T, data: any, source: SourceMap, expressionParams?: {
+        type: any;
+        scope: {
+            [key: string]: any;
+        };
+    }): T;
+    /**
+     * Get the original value loaded into this porperty.
+     * @param object
+     * @param property
+     */
+    function GetOriginalPropertyValue<T extends object, K extends keyof T>(object: T, property: K): T[K];
+    function GetChildClassesNames(type: any | string): string[];
+    type ReferenceType<R extends any[] = any[]> = Referencer.Reference<R>;
+    const GetClassOfObject: typeof GetClassOfObjectInternal;
+    export import GetDataName = ReplicableRegistry.GetDataName;
+    export import GetTypesForName = ReplicableRegistry.GetTypesForName;
+    export import GetTypeForDataName = ReplicableRegistry.GetTypeForDataName;
+    export import IsType = ReplicableRegistry.IsType;
+    export import getDataNameOfObjectType = ReplicableRegistry.GetDataNameOfObjectType;
+    export import InitialiseData = Definitions.PrePrepareData;
+    export import CanReference = Referencer.CanReference;
+    export import IsReference = Referencer.IsReference;
+    export import Reference = Referencer.Reference;
+    export import Dereference = Referencer.Dereference;
+    export import CompareReferences = Utils.CompareUtils.CompareReferences;
+    export import Serialise = Serialiser.Serialise;
+    export import IsSerialisable = Serialiser.IsSerialisable;
+    export import Deserialise = Serialiser.Deserialise;
+    export import Compare = Utils.CompareUtils.Compare;
+    export import OnReady = ReplicableRegistry.Initialise;
+    export import RegisterTypeAlias = ReplicableRegistry.RegisterTypeAlias;
+    export import ReplaceClass = ReplicableRegistry.ReplaceClass;
+    type ConstructorArgs<DefinitionType = any, OwnerType = any> = ConstArgs<DefinitionType, OwnerType>;
+}