multyx-client 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Add } from './utils';
+import { Add, Done } from './utils';
 import { RawObject } from "./types";
 import { Controller } from "./controller";
 import { MultyxClientObject } from "./items";
@@ -10,12 +10,16 @@ export default class Multyx {
     ping: number;
     events: Map<string | Symbol, ((data?: any) => void)[]>;
     self: RawObject;
+    tps: number;
     all: RawObject;
-    clients: RawObject;
-    teams: RawObject;
+    space: string;
+    clients: {
+        [key: string]: MultyxClientObject;
+    };
+    teams: MultyxClientObject;
     controller: Controller;
     options: Options;
-    private listenerQueue;
+    [Done]: ((...args: any[]) => void)[];
     static Start: symbol;
     static Connection: symbol;
     static Disconnect: symbol;
@@ -24,8 +28,25 @@ export default class Multyx {
     static Custom: symbol;
     static Any: symbol;
     constructor(options?: Options, callback?: () => void);
-    on(name: string | Symbol, callback: (data: RawObject) => void): void;
-    send(name: string, data: any, expectResponse?: boolean): Promise<unknown>;
+    /**
+     * Listen for a message from the server
+     * @param name Name of the message
+     * @param callback Function to call when the message is received
+     */
+    on(name: string | Symbol, callback: (data: RawObject) => any): void;
+    /**
+     * Send a message to the server
+     * @param name Name of the message
+     * @param data Data to send
+     */
+    send(name: string, data: any): void;
+    /**
+     * Send a message to the server and wait for a response
+     * @param name Name of the message
+     * @param data Data to send
+     * @returns Promise that resolves when the message is received
+     */
+    await(name: string, data?: any): Promise<unknown>;
     /**
      * Loop over a function
      * @param callback Function to call on a loop
@@ -33,17 +54,16 @@ export default class Multyx {
      */
     loop(callback: () => void, timesPerSecond?: number): void;
     /**
-     * Create a callback function that gets called for any current or future client
-     * @param callbackfn Function to call for every client
+     * Add a function to be called after each frame
+     * @param callback Function to call after each frame
+     */
+    [Add](callback: () => void): void;
+    /**
+     * Parse a native event from the server
+     * @param msg Message to parse
      */
-    forAll(callback: (client: MultyxClientObject) => void): void;
     private parseNativeEvent;
     private initialize;
-    private parseEdit;
     private parseSelf;
-    /**
-     * Add function to listener queue
-     * @param fn Function to call once frame is complete
-     */
-    [Add](fn: ((...args: any[]) => void)): void;
+    private updateSpace;
 }

package/dist/index.js

@@ -1,4 +1,5 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const message_1 = require("./message");
 const utils_1 = require("./utils");
@@ -7,45 +8,75 @@ const items_1 = require("./items");
 const options_1 = require("./options");
 class Multyx {
     constructor(options = {}, callback) {
+        var _b;
+        // Queue of functions to be called after each frame
+        this[_a] = [];
         this.options = Object.assign(Object.assign({}, options_1.DefaultOptions), options);
-        const url = `ws${this.options.secure ? 's' : ''}://${this.options.uri}:${this.options.port}/`;
+        const url = `ws${this.options.secure ? 's' : ''}://${this.options.uri.split('/')[0]}:${this.options.port}/${(_b = this.options.uri.split('/')[1]) !== null && _b !== void 0 ? _b : ''}`;
         this.ws = new WebSocket(url);
         this.ping = 0;
+        this.space = 'default';
         this.events = new Map();
         this.self = {};
+        this.tps = 0;
         this.all = {};
-        this.teams = {};
+        this.teams = new items_1.MultyxClientObject(this, {}, [], true);
         this.clients = {};
         this.controller = new controller_1.Controller(this.ws);
-        this.listenerQueue = [];
         callback === null || callback === void 0 ? void 0 : callback();
         this.ws.onmessage = event => {
-            var _a, _b, _c;
+            var _b, _c, _d, _e;
             const msg = message_1.Message.Parse(event.data);
             this.ping = 2 * (Date.now() - msg.time);
             if (msg.native) {
                 this.parseNativeEvent(msg);
-                (_a = this.events.get(Multyx.Native)) === null || _a === void 0 ? void 0 : _a.forEach(cb => cb(msg));
+                (_b = this.events.get(Multyx.Native)) === null || _b === void 0 ? void 0 : _b.forEach(cb => cb(msg));
             }
-            else if (msg.name in this.events) {
-                this.events[msg.name](msg.data);
-                (_b = this.events.get(Multyx.Custom)) === null || _b === void 0 ? void 0 : _b.forEach(cb => cb(msg));
+            else {
+                (_c = this.events.get(msg.name)) === null || _c === void 0 ? void 0 : _c.forEach(cb => {
+                    const response = cb(msg.data);
+                    if (response !== undefined)
+                        this.send(msg.name, response);
+                });
+                (_d = this.events.get(Multyx.Custom)) === null || _d === void 0 ? void 0 : _d.forEach(cb => cb(msg));
             }
-            (_c = this.events.get(Multyx.Any)) === null || _c === void 0 ? void 0 : _c.forEach(cb => cb(msg));
+            (_e = this.events.get(Multyx.Any)) === null || _e === void 0 ? void 0 : _e.forEach(cb => cb(msg));
         };
     }
+    /**
+     * Listen for a message from the server
+     * @param name Name of the message
+     * @param callback Function to call when the message is received
+     */
     on(name, callback) {
-        var _a;
-        const events = (_a = this.events.get(name)) !== null && _a !== void 0 ? _a : [];
+        var _b;
+        const events = (_b = this.events.get(name)) !== null && _b !== void 0 ? _b : [];
         events.push(callback);
         this.events.set(name, events);
     }
-    send(name, data, expectResponse = false) {
+    /**
+     * Send a message to the server
+     * @param name Name of the message
+     * @param data Data to send
+     */
+    send(name, data) {
         if (name[0] === '_')
             name = '_' + name;
-        this.ws.send(message_1.Message.Create(name, data));
-        if (!expectResponse)
-            return;
+        const update = {
+            instruction: 'resp',
+            name,
+            response: data
+        };
+        this.ws.send(message_1.Message.Native(update));
+    }
+    /**
+     * Send a message to the server and wait for a response
+     * @param name Name of the message
+     * @param data Data to send
+     * @returns Promise that resolves when the message is received
+     */
+    await(name, data) {
+        this.send(name, data);
         return new Promise(res => this.events.set(Symbol.for("_" + name), [res]));
     }
     /**
@@ -66,26 +97,28 @@ class Multyx {
         }
     }
     /**
-     * Create a callback function that gets called for any current or future client
-     * @param callbackfn Function to call for every client
+     * Add a function to be called after each frame
+     * @param callback Function to call after each frame
      */
-    forAll(callback) {
-        this.on(Multyx.Start, () => {
-            this.teams.all.clients.forAll((uuid) => callback(this.clients[uuid]));
-        });
-        this.on(Multyx.Connection, callback);
+    [(_a = utils_1.Done, utils_1.Add)](callback) {
+        this[utils_1.Done].push(callback);
     }
+    /**
+     * Parse a native event from the server
+     * @param msg Message to parse
+     */
     parseNativeEvent(msg) {
-        var _a, _b, _c, _d;
+        var _b, _c, _d, _e;
+        msg.data = msg.data.map(message_1.UncompressUpdate);
         if (this.options.logUpdateFrame)
-            console.log(msg);
+            console.log(msg.data);
         for (const update of msg.data) {
             switch (update.instruction) {
                 // Initialization
                 case 'init': {
                     this.initialize(update);
-                    for (const listener of (_a = this.events.get(Multyx.Start)) !== null && _a !== void 0 ? _a : []) {
-                        this.listenerQueue.push(() => listener(update));
+                    for (const listener of (_b = this.events.get(Multyx.Start)) !== null && _b !== void 0 ? _b : []) {
+                        this[utils_1.Done].push(() => listener(update));
                     }
                     // Clear start event as it will never be called again
                     if (this.events.has(Multyx.Start))
@@ -94,9 +127,24 @@ class Multyx {
                 }
                 // Client or team data edit
                 case 'edit': {
-                    this.parseEdit(update);
-                    for (const listener of (_b = this.events.get(Multyx.Edit)) !== null && _b !== void 0 ? _b : []) {
-                        this.listenerQueue.push(() => listener(update));
+                    if (update.path.length == 1) {
+                        if (update.team) {
+                            this.teams.set(update.path[0], new utils_1.EditWrapper(update.value));
+                        }
+                        else {
+                            this.clients[update.path[0]] = new items_1.MultyxClientObject(this, new utils_1.EditWrapper(update.value), [update.path[0]], false);
+                        }
+                    }
+                    else {
+                        const agent = update.team
+                            ? this.teams.get(update.path[0])
+                            : this.clients[update.path[0]];
+                        if (!agent)
+                            return;
+                        agent.set(update.path.slice(1), new utils_1.EditWrapper(update.value));
+                    }
+                    for (const listener of (_c = this.events.get(Multyx.Edit)) !== null && _c !== void 0 ? _c : []) {
+                        this[utils_1.Done].push(() => listener(update));
                     }
                     break;
                 }
@@ -108,16 +156,16 @@ class Multyx {
                 // Connection
                 case 'conn': {
                     this.clients[update.uuid] = new items_1.MultyxClientObject(this, update.data, [update.uuid], false);
-                    for (const listener of (_c = this.events.get(Multyx.Connection)) !== null && _c !== void 0 ? _c : []) {
-                        this.listenerQueue.push(() => listener(this.clients[update.uuid]));
+                    for (const listener of (_d = this.events.get(Multyx.Connection)) !== null && _d !== void 0 ? _d : []) {
+                        this[utils_1.Done].push(() => listener(this.clients[update.uuid]));
                     }
                     break;
                 }
                 // Disconnection
                 case 'dcon': {
-                    for (const listener of (_d = this.events.get(Multyx.Disconnect)) !== null && _d !== void 0 ? _d : []) {
+                    for (const listener of (_e = this.events.get(Multyx.Disconnect)) !== null && _e !== void 0 ? _e : []) {
                         const clientValue = this.clients[update.client].value;
-                        this.listenerQueue.push(() => listener(clientValue));
+                        this[utils_1.Done].push(() => listener(clientValue));
                     }
                     delete this.clients[update.client];
                     break;
@@ -125,7 +173,8 @@ class Multyx {
                 // Response to client
                 case 'resp': {
                     const promiseResolve = this.events.get(Symbol.for("_" + update.name))[0];
-                    promiseResolve(update.response);
+                    this.events.delete(Symbol.for("_" + update.name));
+                    this[utils_1.Done].push(() => promiseResolve(update.response));
                     break;
                 }
                 default: {
@@ -135,15 +184,15 @@ class Multyx {
                 }
             }
         }
-        this.listenerQueue.forEach(x => x());
-        this.listenerQueue.length = 0;
+        this[utils_1.Done].forEach(x => x());
+        this[utils_1.Done].length = 0;
     }
     initialize(update) {
+        this.tps = update.tps;
         this.uuid = update.client.uuid;
         this.joinTime = update.client.joinTime;
         this.controller.listening = new Set(update.client.controller);
         // Create MultyxClientObject for all teams
-        this.teams = new items_1.MultyxClientObject(this, {}, [], true);
         for (const team of Object.keys(update.teams)) {
             this.teams[team] = new utils_1.EditWrapper(update.teams[team]);
         }
@@ -165,28 +214,14 @@ class Multyx {
             obj[utils_1.Unpack](table);
         }
     }
-    parseEdit(update) {
-        let route = update.team ? this.teams : this.clients;
-        if (!route)
-            return;
-        // Loop through path to get to object being edited
-        for (const p of update.path.slice(0, -1)) {
-            // Create new object at path if non-existent
-            if (!(p in route))
-                route[p] = new utils_1.EditWrapper({});
-            route = route[p];
-        }
-        const prop = update.path.slice(-1)[0];
-        route[prop] = new utils_1.EditWrapper(update.value);
-    }
     parseSelf(update) {
-        if (update.prop == 'controller') {
+        if (update.property == 'controller') {
             this.controller.listening = new Set(update.data);
         }
-        else if (update.prop == 'uuid') {
+        else if (update.property == 'uuid') {
             this.uuid = update.data;
         }
-        else if (update.prop == 'constraint') {
+        else if (update.property == 'constraint') {
             let route = this.uuid == update.data.path[0] ? this.self : this.teams[update.data.path[0]];
             for (const prop of update.data.path.slice(1))
                 route = route === null || route === void 0 ? void 0 : route[prop];
@@ -194,13 +229,24 @@ class Multyx {
                 return;
             route[utils_1.Unpack]({ [update.data.name]: update.data.args });
         }
+        else if (update.property == 'space') {
+            this.space = update.data;
+            this.updateSpace();
+        }
     }
-    /**
-     * Add function to listener queue
-     * @param fn Function to call once frame is complete
-     */
-    [utils_1.Add](fn) {
-        this.listenerQueue.push(fn);
+    // Hide all spaces except the current one
+    updateSpace() {
+        if (this.space == 'default') {
+            document.querySelectorAll('[data-multyx-space]').forEach(space => {
+                space.style.display = 'block';
+                space.style.pointerEvents = 'auto';
+            });
+            return;
+        }
+        document.querySelectorAll('[data-multyx-space]').forEach(space => {
+            space.style.display = space.dataset.multyxSpace == this.space ? 'block' : 'none';
+            space.style.pointerEvents = space.dataset.multyxSpace == this.space ? 'auto' : 'none';
+        });
     }
 }
 Multyx.Start = Symbol('start');

package/dist/items/index.d.ts

@@ -2,4 +2,5 @@ import MultyxClientList from "./list";
 import MultyxClientObject from "./object";
 import MultyxClientValue from "./value";
 type MultyxClientItem<T = any> = T extends any[] ? MultyxClientList : T extends object ? MultyxClientObject : MultyxClientValue;
-export { MultyxClientList, MultyxClientObject, MultyxClientValue, MultyxClientItem, };
+declare function IsMultyxClientItem(value: any): value is MultyxClientItem;
+export { MultyxClientList, MultyxClientObject, MultyxClientValue, MultyxClientItem, IsMultyxClientItem, };

package/dist/items/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultyxClientValue = exports.MultyxClientObject = exports.MultyxClientList = void 0;
+exports.IsMultyxClientItem = IsMultyxClientItem;
 const list_1 = require("./list");
 exports.MultyxClientList = list_1.default;
 const object_1 = require("./object");
 exports.MultyxClientObject = object_1.default;
 const value_1 = require("./value");
 exports.MultyxClientValue = value_1.default;
+function IsMultyxClientItem(value) {
+    return value instanceof list_1.default || value instanceof object_1.default || value instanceof value_1.default;
+}

package/dist/items/list.d.ts

@@ -1,22 +1,42 @@
 import Multyx from '../';
-import { MultyxClientItem } from '.';
-import { EditWrapper } from '../utils';
-import MultyxClientObject from "./object";
-export default class MultyxClientList extends MultyxClientObject {
-    length: number;
+import { type MultyxClientItem, type MultyxClientObject, MultyxClientValue } from '.';
+import { EditWrapper, Unpack } from '../utils';
+export default class MultyxClientList {
+    protected list: MultyxClientItem[];
+    private multyx;
+    propertyPath: string[];
+    editable: boolean;
+    private editCallbacks;
+    addEditCallback(callback: (index: number, value: any, oldValue: any) => void): void;
     get value(): any[];
+    get length(): number;
+    set length(length: number);
+    /**
+     * Shifting operations are needed to ensure that operations on elements in
+     * the list do not need to worry about the index of the element.
+     *
+     * Instead of changing each element's value when shifting, these shift
+     * operations are used to ensure that each MultyxClientItem stays the same
+     * @param index Index to shift from, -1 if special operation
+     * @param shift Shift amount, positive for right, negative for left
+     */
+    private handleShiftOperation;
     constructor(multyx: Multyx, list: any[] | EditWrapper<any[]>, propertyPath: string[], editable: boolean);
-    set(index: string | number, value: any): boolean;
-    delete(index: string | number, native?: boolean): boolean;
+    has(index: number): boolean;
+    get(index: number | string[]): MultyxClientItem;
+    private recursiveSet;
+    set(index: number | string[], value: any): boolean;
+    delete(index: number, native?: boolean): boolean;
     /**
-     * Create a callback function that gets called for any current or future element in list
-     * @param callbackfn Function to call for every element
+     * Wait for a specific index to be set
+     * @param index Index to wait for
+     * @returns Promise that resolves when the value is set
      */
-    forAll(callbackfn: (value: any, index: number) => void): void;
+    await(index: number): Promise<unknown>;
     push(...items: any): number;
     pop(): MultyxClientItem | null;
     unshift(...items: any[]): number;
-    shift(): import("./value").default | MultyxClientObject;
+    shift(): MultyxClientList | MultyxClientObject | MultyxClientValue;
     splice(start: number, deleteCount?: number, ...items: any[]): void;
     filter(predicate: (value: any, index: number, array: MultyxClientList) => boolean): void;
     map(callbackfn: (value: any, index: number, array: MultyxClientList) => any): void;
@@ -27,12 +47,11 @@ export default class MultyxClientList extends MultyxClientObject {
     forEach(callbackfn: (value: any, index: number, array: MultyxClientList) => void): void;
     every(predicate: (value: any, index: number, array: MultyxClientList) => boolean): boolean;
     some(predicate: (value: any, index: number, array: MultyxClientList) => boolean): boolean;
-    find(predicate: (value: any, index: number, array: MultyxClientList) => boolean): import("./value").default | MultyxClientObject;
+    find(predicate: (value: any, index: number, array: MultyxClientList) => boolean): MultyxClientList | MultyxClientObject | MultyxClientValue;
     findIndex(predicate: (value: any, index: number, array: MultyxClientList) => boolean): number;
-    deorder(): MultyxClientItem[];
-    deorderEntries(): [number, MultyxClientItem][];
     entries(): [any, number][];
     keys(): number[];
+    [Unpack](constraints: any[]): void;
     [Symbol.iterator](): Iterator<MultyxClientItem>;
     toString: () => string;
     valueOf: () => any[];