@bikky/replication 1.0.1

package/IDPool.js

@@ -0,0 +1,139 @@
+import { CustomReplicableType, Versions } from "./Main.js";
+import { Messenger } from "./Networking.js";
+import { ReplicableRegistry } from "./Constants/ReplicableRegistry.js";
+import { ValidExpressionTypes } from "./Expressions/TypeRegistry/Registry.js";
+//Safe to load early.
+export var IDPool;
+(function (IDPool) {
+    var remote;
+    var size = 1000;
+    var pool = [];
+    //Only present on the server.
+    var makeUUID;
+    let prototype = { __proto__: String.prototype };
+    var clientIDs = new Map();
+    //This assumes messenger has been initialised first.
+    async function initialise(makeUUIDFunction) {
+        makeUUID = makeUUIDFunction;
+        //Delay this until the world has finished initialising.
+        if (!Messenger.isServer) {
+            await Messenger.connect;
+        }
+        //Request a number of IDs based on the pool size.
+        await Private.requestUUIDs(size);
+    }
+    IDPool.initialise = initialise;
+    let UUID;
+    (function (UUID) {
+        UUID.name = "UUID";
+        function isUUID(input, complex = false) {
+            if (!complex) {
+                return typeof input === "string";
+            }
+            else {
+                return (typeof input === "string" &&
+                    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(input)
+                //Improved?: /^[A-F0-9]{8}-[A-F0-9]{4}-4[A-F0-9]{3}-[89AB][A-F0-9]{3}-[A-F0-9]{12}$/
+                );
+            }
+        }
+        UUID.isUUID = isUUID;
+    })(UUID = IDPool.UUID || (IDPool.UUID = {}));
+    function useUUID() {
+        if (typeof TestingMode !== "undefined" && TestingMode === true) {
+            return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+                var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+                return v.toString(16);
+            });
+        }
+        Private.requestUUIDs(1);
+        let id = pool.shift();
+        id.__proto__ = prototype;
+        return id;
+    }
+    IDPool.useUUID = useUUID;
+    /**
+     * Verifies the client UUID and removes it from the pool of client UUIDs.
+     * @param id
+     * @param remoteID
+     */
+    function verifyClientUUID(id, remoteID) {
+        if (typeof TestingMode !== "undefined" && TestingMode === true) {
+            return true;
+        }
+        var array = clientIDs.get(remoteID);
+        if (!array) {
+            return false;
+        }
+        var index = array.indexOf(id);
+        if (index < 0) {
+            return false;
+        }
+        array.splice(index, 0);
+        return true;
+    }
+    IDPool.verifyClientUUID = verifyClientUUID;
+    let Private;
+    (function (Private) {
+        async function requestUUIDs(amount) {
+            //Client is out of ids, ask for more.
+            var ids = [];
+            if (Messenger.isServer) {
+                for (var i = 0; i < amount; i++) {
+                    ids.push(makeUUID());
+                }
+            }
+            else {
+                ids = await remote.retrieveUUIDS(amount);
+            }
+            pool.push(...ids);
+        }
+        Private.requestUUIDs = requestUUIDs;
+        async function retrieveUUIDS(amount, client) {
+            if (!Messenger.isServer) {
+                return [];
+            }
+            else {
+                var result = [];
+                for (var i = 0; i < amount; i++) {
+                    result.push(makeUUID());
+                }
+                if (client) {
+                    var remoteID = Messenger.getIDForInstance(remote, client);
+                    var array = clientIDs.get(remoteID);
+                    if (!array) {
+                        clientIDs.set(remoteID, (array = []));
+                    }
+                    array.push(...result);
+                }
+                return result;
+            }
+        }
+        Private.retrieveUUIDS = retrieveUUIDS;
+    })(Private || (Private = {}));
+    remote = Messenger.newRemoteInterface("IDPool", Private);
+    CustomReplicableType(Versions.v1_0_0, {
+        name: "UUID",
+        Create(config) {
+            config.data.__proto__ = prototype;
+            return config.data;
+        },
+        DefinitionType: "IDPool.UUID",
+        DefinitionIncludes: [[["IDPool"], "./IDPool.js"]],
+        DataIsType(val) {
+            return UUID.isUUID(val);
+        },
+        Reference(value) {
+            return [value];
+        },
+        Dereference(value) {
+            return value[0];
+        },
+        prototype: prototype
+    }, {
+        dataTypeName: "UUID",
+        typescriptTypeName: "UUID"
+    });
+    ReplicableRegistry.RegisterTypeAlias(UUID, "UUID");
+    ValidExpressionTypes.AddAliasForType(UUID, "UUID");
+})(IDPool || (IDPool = {}));

package/License.txt

@@ -0,0 +1 @@
+Not for use, reading, distribution, distributive works, altering or anything else (except by the creator).

package/Main.d.ts

@@ -0,0 +1,13 @@
+import { Versions as Versions_Ext } from "./Constants/Versions.js";
+export * from "./Constants/SerialisationTypes.js";
+export import Versions = Versions_Ext;
+export { Property } from "./Tracking/Property.js";
+export { Accessor } from "./Tracking/Functions.js";
+export { Struct, Type } from "./Tracking/Class.js";
+export { CustomReplicableType } from "./Tracking/Class.js";
+export { Replicable } from "./Replicatable.js";
+export { Expression } from "./Expressions/Expression.js";
+export { GlobalGroup } from "./Tracking/GlobalGroup.js";
+export { Referencer } from "./Transformers/Reference.js";
+export { SourceMap } from "./Constants/SourceMaps.js";
+export { SchemaGenerator } from "./Transformers/SchemaGenerator.js";

package/Main.js

@@ -0,0 +1,13 @@
+import { Versions as Versions_Ext } from "./Constants/Versions.js";
+export * from "./Constants/SerialisationTypes.js";
+export var Versions = Versions_Ext;
+export { Property } from "./Tracking/Property.js";
+export { Accessor } from "./Tracking/Functions.js";
+export { Struct, Type } from "./Tracking/Class.js";
+export { CustomReplicableType } from "./Tracking/Class.js";
+export { Replicable } from "./Replicatable.js";
+export { Expression } from "./Expressions/Expression.js";
+export { GlobalGroup } from "./Tracking/GlobalGroup.js";
+export { Referencer } from "./Transformers/Reference.js";
+export { SourceMap } from "./Constants/SourceMaps.js";
+export { SchemaGenerator } from "./Transformers/SchemaGenerator.js";

package/Networking.d.ts

@@ -0,0 +1,60 @@
+import { IDPool } from "./IDPool.js";
+export declare namespace Messenger {
+    type UUID = IDPool.UUID;
+    export type ReplicatedFunction<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<T[]> : never;
+    export type ReplicatedClass<T> = {
+        [P in keyof T]: ReplicatedFunction<T[P]>;
+    };
+    export type RemoteFunction<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<T> : never;
+    export type RemoteClass<T> = {
+        [P in keyof T]: RemoteFunction<T[P]>;
+    };
+    /**
+     * Websocket type that works for express-ws and inbuilt browser websockets.
+     */
+    export type WebSocket = {
+        on(event: "message", handler: (data: any) => void): void;
+        on(event: "close", handler: (code: number, reason: string) => void): void;
+        send(data: any): void;
+    } | {
+        onmessage?: ((event: {
+            data: any;
+        }) => void) | null;
+        onclose?: ((event: {
+            code: number;
+            reason: string;
+        }) => void) | null;
+        send(data: any): void;
+    };
+    export interface ConnectionDetails<Remote = any> {
+        connection: Remote;
+        id: UUID;
+        tick: number;
+    }
+    export const isServer: boolean;
+    export var isConnected: boolean;
+    export var connect: Promise<void>;
+    export function initialise(localID: UUID, isTheServer: boolean, time?: number): void;
+    export function tick(): void;
+    export function sendMessages(): void;
+    export function getLocalTime(): number;
+    export function onDisconnect(id: UUID, handler: Function): void;
+    export function addRemoteConnection(id: UUID, connection: WebSocket): void;
+    export function newRemoteInterface<Type extends Object>(name: string, object: any): Type;
+    export function getInstanceForID<Type>(remoteInterface: Type, id: UUID): Type | null;
+    export function getAllInstancesExceptID<Type>(remoteInterface: Type, id: UUID): Type[] | null;
+    export function getAllInstancesExcept<Type>(remoteInterface: Type, remoteInstance: Type): Type[] | null;
+    export function getRemoteTime(id: UUID): number | null;
+    export function getRemotePing(id: UUID): number | null;
+    export function getRemoteAvgPing(id: UUID): number | null;
+    export function getIDForInstance<Type>(remoteInterface: Type, remoteInstance: Type): UUID | null;
+    export function isRemoteProxy(remote: any): boolean;
+    export function getLocalID(): IDPool.UUID;
+    /**
+     * Will return the local id if on the server. Assumes that only the server connects to clients.
+     */
+    export function getServerID(): IDPool.UUID;
+    export function divertMessages<Type extends object>(remote: Type, newTarget: Type): void;
+    export function restoreMessages<Type extends object>(remote: Type): void;
+    export {};
+}