update jaylydb and assert (JaylyDev#244)

* 1.0.6

* 1.0.7

Author: JaylyDev

scripts/assert/README.md

@@ -0,0 +1,7 @@
+# assert
+
+## Description
+A function to test if a value is equal to true, an error is thrown otherwise. Used for unit tests.
+
+## Credits
+These scripts were written by [Jayly](https://github.com/JaylyDev)

scripts/assert/index.js

@@ -1,3 +1,6 @@
+// Script example for ScriptAPI
+// Author: Jayly <https://github.com/JaylyDev>
+// Project: https://github.com/JaylyDev/ScriptAPI
 /**
  * Indicates the failure of an assertion. All errors thrown by the `assert` function
  * will be instances of the `AssertionError` class.

scripts/assert/index.ts

@@ -1,3 +1,6 @@
+// Script example for ScriptAPI
+// Author: Jayly <https://github.com/JaylyDev>
+// Project: https://github.com/JaylyDev/ScriptAPI
 
 /**
  * Indicates the failure of an assertion. All errors thrown by the `assert` function

scripts/jaylydb/index.d.ts

@@ -22,14 +22,13 @@ declare class JaylyDB implements Map<string, string | number | boolean> {
     /**
      * Executes a provided function once per each key/value pair in the database, in insertion order.
      */
-    forEach(callbackfn: (value: string | number | boolean, key: string, map: this) => void): void;
+    forEach(callbackfn: (value: string | number | boolean, key: string, jaylydb: this) => void): void;
     /**
      * Returns a specified element from the database.
      * @param key The key of the element to return.
-     * @param reloadCache If set to true, the database object reloads cache before returning the element. This is made for when the database is modified from a external source.
      * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
      */
-    get(key: string, reloadCache?: boolean): string | number | boolean | undefined;
+    get(key: string): string | number | boolean | undefined;
     has(key: string): boolean;
     /**
      * Adds a new element with a specified key and value to the database. If an element with the same key already exists, the element will be updated.

scripts/jaylydb/index.js

@@ -1,9 +1,30 @@
-var _a;
 // Script example for ScriptAPI
 // Author: Jayly <https://github.com/JaylyDev>
 // Project: https://github.com/JaylyDev/ScriptAPI
-import { ScoreboardIdentityType, world } from "@minecraft/server";
-const version = "1.0.5";
+var _a;
+/*!
+ * Copyright (c) Jayly. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+import { ScoreboardIdentityType, system, world } from "@minecraft/server";
+const version = "1.0.7";
 const str = () => ('00000000000000000' + (Math.random() * 0xffffffffffffffff).toString(16)).slice(-16);
 /**
  * A rough mechanism for create a random uuid. Not as secure as uuid without as much of a guarantee of uniqueness,
@@ -33,7 +54,7 @@ const decrypt = (encrypted, salt) => {
     return String.fromCharCode(...decryptedChars);
 };
 const CreateCrashReport = (action, data, error, salt) => {
-    console.log("[JaylyDB] Failed to " + action + " JSON data.", "\nVersion: " + version, "\nData: " + data, "\nSalt: " + salt, "\nError: " + error.message, "\n" + error.stack);
+    console.warn("[JaylyDB] Failed to " + action + " JSON data.", "\nVersion: " + version, "\nData: " + data, "\nSalt: " + salt, "\nError: " + error.message, "\n" + error.stack);
     throw new Error(`Failed to ${action} data. Please check content log file for more info.\n`);
 };
 /**
@@ -65,19 +86,37 @@ const overworld = world.getDimension("overworld");
  * A simple database for storing data in a Minecraft world, using scoreboard.
  */
 class JaylyDB {
-    /** @internal */
-    get salt() {
-        return this.encrypted ? this.objective.displayName : undefined;
-    }
-    ;
     /** @internal */
     updateParticipants() {
+        const id = this.objective.id.substring(this.objective.id.indexOf(":") + 1);
+        if (this.tempCache.size <= 0 && this.warningSent === true) {
+            console.warn(`[JaylyDB] Database '${id}' has written data to world. It is now safe to exit the world.`);
+            this.warningSent = false;
+        }
+        else if (this.tempCache.size > 0 && this.warningSent === false) {
+            console.warn(`[JaylyDB] Database '${id}' is writing data to world. Please wait until the process is completed before exiting the world.`);
+            this.warningSent = true;
+        }
+        ;
+        try {
+            for (const [key, value] of this.tempCache.entries()) {
+                overworld.runCommandAsync(`scoreboard players set "${value}" ${this.objective.id} 0`);
+                this.tempCache.delete(key);
+            }
+            ;
+        }
+        catch (error) {
+            if (error.message !== "Runtime failure, command queue is full.")
+                throw error;
+        }
+        ;
         this.participants.clear();
         for (const participant of this.objective.getParticipants()) {
             if (participant.type !== ScoreboardIdentityType.fakePlayer)
                 continue;
             this.participants.set(Object.keys(DisplayName.parse(participant.displayName, this.salt))[0], participant);
         }
+        ;
     }
     /**
      * @param id An identifier for the database
@@ -87,11 +126,23 @@ class JaylyDB {
         /** @internal */
         this.participants = new Map();
         /** @internal */
-        this.displayDataCache = new Map();
+        this.localCache = new Map();
+        /** @internal */
+        this.warningSent = false;
+        /**
+         * Internal cache object to allow data to write from memory to scoreboard every tick interval.
+         * This is done to prevent multiple values written to a same key to scoreboard each operation.
+         * @internal
+         */
+        this.tempCache = new Map();
         this[_a] = JaylyDB.name;
         this.objective = world.scoreboard.getObjective("jaylydb:" + id) ?? world.scoreboard.addObjective("jaylydb:" + id, uuid());
         this.encrypted = encrypted;
+        this.salt = this.encrypted ? this.objective.displayName : undefined;
+        // Fetch all data when database initialize
         this.updateParticipants();
+        // This function queues the data to be written to the scoreboard every second interval.
+        system.runInterval(() => this.updateParticipants());
     }
     /**
      * @returns the number of elements in the database.
@@ -115,6 +166,7 @@ class JaylyDB {
             return false;
         const success = this.objective.removeParticipant(participant);
         this.participants.delete(key);
+        this.localCache.delete(key);
         return success;
     }
     /**
@@ -127,50 +179,43 @@ class JaylyDB {
     /**
      * Returns a specified element from the database.
      * @param key The key of the element to return.
-     * @param reloadCache If set to true, the database object reloads cache before returning the element. This is made for when the database is modified from a external source.
      * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
      */
-    get(key, reloadCache = false) {
-        if (!reloadCache && this.displayDataCache.has(key))
-            return this.displayDataCache.get(key);
+    get(key) {
+        if (this.localCache.has(key))
+            return this.localCache.get(key);
+        // local cache does not have element, fetch global participant
         const participant = this.participants.get(key);
         if (!participant)
             return undefined;
         const displayName = participant.displayName;
-        const displayData = DisplayName.parse(displayName, this.salt);
-        this.displayDataCache.set(key, displayData[key]);
-        return displayData[key];
+        const data = DisplayName.parse(displayName, this.salt);
+        this.localCache.set(key, data[key]);
+        return data[key];
     }
     has(key) {
-        return this.participants.has(key);
+        return this.localCache.has(key);
     }
     /**
      * Adds a new element with a specified key and value to the database. If an element with the same key already exists, the element will be updated.
      */
     set(key, value) {
         if (!allowedTypes.includes(typeof value))
             throw new TypeError("JaylyDB::set only accepts a value of string, number, or boolean.");
-        const str = DisplayName.stringify({ [key]: value }, this.salt);
-        if (str.length > 32767)
+        const encoded = DisplayName.stringify({ [key]: value }, this.salt);
+        if (encoded.length > 32767)
             throw new RangeError("JaylyDB::set only accepts a string value less than 32767 characters.");
-        if (this.displayDataCache.has(key)) {
-            const displayData = this.displayDataCache.get(key);
-            if (displayData[key] === value)
-                return this;
-        }
-        ;
-        this.delete(key);
-        overworld.runCommand(`scoreboard players set "${str}" ${this.objective.id} 0`);
-        this.displayDataCache.set(key, value);
-        this.updateParticipants();
+        if (this.localCache.get(key) === value)
+            return this;
+        // push change to temp cache
+        this.participants.delete(key);
+        this.tempCache.set(key, encoded);
+        this.localCache.set(key, value);
         return this;
     }
     *entries() {
-        for (const [, { displayName }] of this.participants) {
-            const valueObject = DisplayName.parse(displayName, this.salt);
-            const [entryKey, entryValue] = Object.entries(valueObject)[0];
-            yield [entryKey, entryValue];
-        }
+        for (const iterator of this.localCache.entries())
+            yield iterator;
     }
     /**
      * Returns an iterable of keys in the database