playsocketjs 2.1.0 → 2.1.1

package/README.md

@@ -77,7 +77,7 @@ socket.updateStorage('latestPlayer', 'set', 'Player4'); // Regular synced storag
 ### Constructor
 
 Creates a new PlaySocket instance with a specified ID and configuration options.
-The id can be set to `null` to let the server pick a unique one.
+The ID can be set to `null` to let the server pick a unique one.
 
 ```javascript
 new PlaySocket(id?: string, options: PlaySocketOptions)
@@ -90,8 +90,8 @@ new PlaySocket(id?: string, options: PlaySocketOptions)
 
 ### Methods
 
-- `init()`: Initialize the WebSocket connection – Returns Promise (async) which resolves with the client's id
-- `createRoom(initialStorage?: object, maxSize?: number)`: Create a new room and become host – Returns Promise (async) which resolves with the room id (matches the creator's id)
+- `init()`: Initialize the WebSocket connection – Returns Promise (async) which resolves with the client's ID
+- `createRoom(initialStorage?: object, maxSize?: number)`: Create a new room and become host – Returns Promise (async) which resolves with the room ID (matches the creator's ID)
 - `joinRoom(hostId: string)`: Join an existing room – Returns Promise (async)
 - `destroy()`: Use this to leave a room and close the connection
 - `updateStorage(key: string, type: 'set' | 'array-add' | 'array-add-unique' | 'array-remove-matching' | 'array-update-matching', value: any, updateValue?: any)`: Update the shared storage. Safely update arrays in storage by adding, removing, or updating items. UpdateValue is only required for the 'array-update-matching' operation type
@@ -103,9 +103,9 @@ new PlaySocket(id?: string, options: PlaySocketOptions)
 - `error`: Error events (returns error `string`)
 - `instanceDestroyed`: Destruction event - triggered by manual .destroy() method invocation or by fatal errors and disconnects
 - `storageUpdated`: Storage state changes (returns storage `object`)
-- `hostMigrated`: Host changes (returns the new host's id `string`)
-- `clientConnected`: New client connected to the room (returns client-id `string`)
-- `clientDisconnected`: Client disconnected from the room (returns client-id `string`, room id (if available) `string`)
+- `hostMigrated`: Host changes (returns the new host's ID `string`)
+- `clientConnected`: New client connected to the room (returns client's ID `string`)
+- `clientDisconnected`: Client disconnected from the room (returns client's ID `string`, room ID (if available) `string`)
 
 ### Properties (Read-only)
 
@@ -209,13 +209,13 @@ Creates a new PlaySocket Server instance with configuration options.
 
 #### Event types
 
-- `clientRegistered`: Client registered with the server (returns the client's id `string`, customData `object`)
-- `clientDisconnected`: Client disconnected from the server (returns the client's id `string`)
-- `clientJoinedRoom`: Client joined a room – note that clients can only leave by disconnecting (returns the client's id `string`, room id `string`)
-- `roomCreated`: Client created a room (returns room id `string`)
-- `roomDestroyed`: Room was destroyed, this happens when all participants leave (returns room id `string`)
-- `roomCreationRequested`: Room creation requested by client (returns `object` containing the client's id `string`, room id `string` and the initialStorage `object`) – if you return an `object` in the callback, it will take that as the initial storage instead
-- `storageUpdateRequested`: Room storage property update requested by client (returns `object` containing the client's id `string`, room id `string` and the update `object`) – if you return `false` in the callback, the update will be blocked
+- `clientRegistered`: Client registered with the server (returns the client's ID `string`, customData `object`)
+- `clientDisconnected`: Client disconnected from the server (returns the client's ID `string`)
+- `clientJoinedRoom`: Client joined a room – note that clients can only leave by disconnecting (returns the client's ID `string`, room ID `string`)
+- `roomCreated`: Client created a room (returns room ID `string`)
+- `roomDestroyed`: Room was destroyed, this happens when all participants leave (returns room ID `string`)
+- `roomCreationRequested`: Room creation requested by client (returns `object` containing the client's ID `string`, room ID `string` and the initialStorage `object`) – if you return an `object` in the callback, it will take that as the initial storage instead
+- `storageUpdateRequested`: Room storage property update requested by client (returns `object` containing the client's ID `string`, room ID `string` and the update `object`) – if you return `false` in the callback, the update will be blocked
 
 ### Properties (Read-only)
 

package/dist/playsocket-client.js

@@ -1687,7 +1687,7 @@ function requireCrdtManager () {
 	hasRequiredCrdtManager = 1;
 	// Custom conflict-free replicated data type system with vector clocks
 
-	const CONSOLE_PREFIX = "CRDT Manager: ";
+	const CONSOLE_PREFIX = "PlaySocket CRDT manager: ";
 
 	class CRDTManager {
 	    // Storage
@@ -1835,50 +1835,53 @@ function requireCrdtManager () {
 	        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
 	        const MIN_AGE_FOR_GC = 5000; // Garbage collect ops that are older than 5s
 
-	        if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
-	        this.#lastGCCheck = Date.now();
-
-	        for (const [key, operations] of this.#keyOperations.entries()) {
-	            if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
-
-	            let retainCount = operations.length;
-	            operations.forEach((op, index) => {
-	                // Count how many ops, from last to latest, are older than the min-age in a row
-	                if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
-	                    const removeCount = index + 1;
-	                    retainCount = operations.length - removeCount;
-	                    this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
-	                }
-	            });
+	        try {
+	            if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
+	            this.#lastGCCheck = Date.now();
+
+	            for (const [key, operations] of this.#keyOperations.entries()) {
+	                if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
+
+	                let retainCount = operations.length;
+	                operations.forEach((op, index) => {
+	                    // Count how many ops, from last to latest, are older than the min-age in a row
+	                    if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
+	                        const removeCount = index + 1;
+	                        retainCount = operations.length - removeCount;
+	                        this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
+	                    }
+	                });
 
-	            if (retainCount < operations.length) {
-	                if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
-	                const retainOps = operations.slice(-retainCount); // Newest ops
-	                const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
-	                const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
-
-	                // Calculate the value at the point where retained operations start
-	                let baselineValue = null;
-	                for (const op of removeOps) {
-	                    if (!op.data) continue;
-	                    if (op.data.type.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
-	                    baselineValue = this.#handleOperation(
-	                        baselineValue,
-	                        op.data.type,
-	                        op.data.value,
-	                        op.data.updateValue
-	                    );
+	                if (retainCount < operations.length) {
+	                    if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
+	                    const retainOps = operations.slice(-retainCount); // Newest ops
+	                    const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
+	                    const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
+
+	                    // Calculate the value at the point where retained operations start
+	                    let baselineValue = null;
+	                    for (const op of removeOps) {
+	                        if (!op.data) continue;
+	                        baselineValue = this.#handleOperation(
+	                            baselineValue,
+	                            op.data.type,
+	                            op.data.value,
+	                            op.data.updateValue
+	                        );
+	                    }
+
+	                    // Create a compact operation with baseline value and appropriate vector clock
+	                    const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
+
+	                    // Debug log
+	                    if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
+
+	                    // Combine compact op with retained operations
+	                    this.#keyOperations.set(key, [compactOp, ...retainOps]);
 	                }
-
-	                // Create a compact operation with baseline value and appropriate vector clock
-	                const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
-
-	                // Debug log
-	                if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
-
-	                // Combine compact op with retained operations
-	                this.#keyOperations.set(key, [compactOp, ...retainOps]);
 	            }
+	        } catch (error) {
+	            console.error(CONSOLE_PREFIX + "Error running garbage collection:", error);
 	        }
 	    }
 
@@ -1913,7 +1916,6 @@ function requireCrdtManager () {
 
 	            for (const op of ops) {
 	                if (!op.data) continue;
-	                if (op.data.type.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
 	                value = this.#handleOperation(
 	                    value,
 	                    op.data.type,

package/dist/playsocket-server.js

@@ -1813,7 +1813,7 @@ function requireCrdtManager () {
 	hasRequiredCrdtManager = 1;
 	// Custom conflict-free replicated data type system with vector clocks
 
-	const CONSOLE_PREFIX = "CRDT Manager: ";
+	const CONSOLE_PREFIX = "PlaySocket CRDT manager: ";
 
 	class CRDTManager {
 	    // Storage
@@ -1961,50 +1961,53 @@ function requireCrdtManager () {
 	        const MIN_GC_DELAY = 1000; // Minimum 1s delay between garbage collection runs
 	        const MIN_AGE_FOR_GC = 5000; // Garbage collect ops that are older than 5s
 
-	        if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
-	        this.#lastGCCheck = Date.now();
-
-	        for (const [key, operations] of this.#keyOperations.entries()) {
-	            if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
-
-	            let retainCount = operations.length;
-	            operations.forEach((op, index) => {
-	                // Count how many ops, from last to latest, are older than the min-age in a row
-	                if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
-	                    const removeCount = index + 1;
-	                    retainCount = operations.length - removeCount;
-	                    this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
-	                }
-	            });
+	        try {
+	            if (Date.now() - this.#lastGCCheck < MIN_GC_DELAY) return;
+	            this.#lastGCCheck = Date.now();
+
+	            for (const [key, operations] of this.#keyOperations.entries()) {
+	                if (operations?.length < 5) continue; // Min op amount per key for garbage collection to run (otherwise not worth it)
+
+	                let retainCount = operations.length;
+	                operations.forEach((op, index) => {
+	                    // Count how many ops, from last to latest, are older than the min-age in a row
+	                    if (op.uuid && this.#opUuidTimestamp.has(op.uuid) && (Date.now() - this.#opUuidTimestamp.get(op.uuid)) > MIN_AGE_FOR_GC) {
+	                        const removeCount = index + 1;
+	                        retainCount = operations.length - removeCount;
+	                        this.#opUuidTimestamp.delete(op.uuid); // Remove from timestamps if set to be deleted
+	                    }
+	                });
 
-	            if (retainCount < operations.length) {
-	                if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
-	                const retainOps = operations.slice(-retainCount); // Newest ops
-	                const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
-	                const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
-
-	                // Calculate the value at the point where retained operations start
-	                let baselineValue = null;
-	                for (const op of removeOps) {
-	                    if (!op.data) continue;
-	                    if (op.data.type.startsWith('array') && !Array.isArray(baselineValue)) baselineValue = []; // Initialize array if required
-	                    baselineValue = this.#handleOperation(
-	                        baselineValue,
-	                        op.data.type,
-	                        op.data.value,
-	                        op.data.updateValue
-	                    );
-	                }
+	                if (retainCount < operations.length) {
+	                    if (this.#debug) console.log(CONSOLE_PREFIX + `Running garbage collection for key ${key} with current operations:`, operations);
+	                    const retainOps = operations.slice(-retainCount); // Newest ops
+	                    const removeOps = operations.slice(0, -retainCount); // Oldest ops (start =  idx 0, end = retainCount counted from right side)
+	                    const baselineVectorClock = removeOps[removeOps.length - 1]?.vectorClock || []; // Use the vector clock from the last operation that we remove/overwrite 
+
+	                    // Calculate the value at the point where retained operations start
+	                    let baselineValue = null;
+	                    for (const op of removeOps) {
+	                        if (!op.data) continue;
+	                        baselineValue = this.#handleOperation(
+	                            baselineValue,
+	                            op.data.type,
+	                            op.data.value,
+	                            op.data.updateValue
+	                        );
+	                    }
 
-	                // Create a compact operation with baseline value and appropriate vector clock
-	                const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
+	                    // Create a compact operation with baseline value and appropriate vector clock
+	                    const compactOp = this.#createOperation({ type: "set", value: baselineValue }, baselineVectorClock);
 
-	                // Debug log
-	                if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
+	                    // Debug log
+	                    if (this.#debug) console.log(CONSOLE_PREFIX + "Operations after garbage collection for this key:", [compactOp, ...retainOps]);
 
-	                // Combine compact op with retained operations
-	                this.#keyOperations.set(key, [compactOp, ...retainOps]);
+	                    // Combine compact op with retained operations
+	                    this.#keyOperations.set(key, [compactOp, ...retainOps]);
+	                }
 	            }
+	        } catch (error) {
+	            console.error(CONSOLE_PREFIX + "Error running garbage collection:", error);
 	        }
 	    }
 
@@ -2039,7 +2042,6 @@ function requireCrdtManager () {
 
 	            for (const op of ops) {
 	                if (!op.data) continue;
-	                if (op.data.type.startsWith('array') && !Array.isArray(value)) value = []; // Initialize array if required
 	                value = this.#handleOperation(
 	                    value,
 	                    op.data.type,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playsocketjs",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "WebSocket wrapper for creating simple multiplayer systems with ease.",
   "module": "dist/playsocket-client.js",
   "exports": {