isaacscript-common 87.9.6 → 87.9.7

package/dist/functions/merge.js

@@ -85,45 +85,13 @@ function mergeSerializedArray(oldArray, newArray, traversalDescription, classCon
         oldArray.set(key, deserializedValue);
     }, constants_1.SAVE_DATA_MANAGER_DEBUG);
 }
-function mergeSerializedTSTLObject(
-// eslint-disable-next-line complete/prefer-readonly-parameter-types
-oldObject, newTable, traversalDescription, classConstructors) {
-    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-        (0, log_1.log)(`merge encountered a TSTL object: ${traversalDescription}`);
-    }
-    // We blow away the old object and recursively copy over all of the incoming values.
-    oldObject.clear();
-    // During serialization, we brand some Lua tables with a special identifier to signify that it has
-    // keys that should be deserialized to numbers.
-    const convertStringKeysToNumbers = newTable.has(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
-    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
-        if ((0, serialization_1.isSerializationBrand)(key)) {
-            return;
-        }
-        let keyToUse = key;
-        if (convertStringKeysToNumbers) {
-            const numberKey = tonumber(key);
-            if (numberKey === undefined) {
-                return;
-            }
-            keyToUse = numberKey;
-        }
-        if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
-            const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
-            oldObject.set(keyToUse, deserializedValue);
-        }
-        else if ((0, tstlClass_1.isTSTLSet)(oldObject)) {
-            oldObject.add(keyToUse);
-        }
-    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
-}
 function mergeSerializedTable(oldTable, newTable, traversalDescription, classConstructors) {
     if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
         (0, log_1.log)(`merge encountered a Lua table: ${traversalDescription}`);
     }
     (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
         if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
-            const valueToPrint = value === "" ? "(empty string)" : `${value}`;
+            const valueToPrint = value === "" ? "(empty string)" : String(value);
             (0, log_1.log)(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
         }
         if ((0, serialization_1.isSerializationBrand)(key)) {
@@ -156,3 +124,35 @@ function mergeSerializedTable(oldTable, newTable, traversalDescription, classCon
         }
     }, constants_1.SAVE_DATA_MANAGER_DEBUG);
 }
+function mergeSerializedTSTLObject(
+// eslint-disable-next-line complete/prefer-readonly-parameter-types
+oldObject, newTable, traversalDescription, classConstructors) {
+    if (constants_1.SAVE_DATA_MANAGER_DEBUG) {
+        (0, log_1.log)(`merge encountered a TSTL object: ${traversalDescription}`);
+    }
+    // We blow away the old object and recursively copy over all of the incoming values.
+    oldObject.clear();
+    // During serialization, we brand some Lua tables with a special identifier to signify that it has
+    // keys that should be deserialized to numbers.
+    const convertStringKeysToNumbers = newTable.has(SerializationBrand_1.SerializationBrand.OBJECT_WITH_NUMBER_KEYS);
+    (0, table_1.iterateTableInOrder)(newTable, (key, value) => {
+        if ((0, serialization_1.isSerializationBrand)(key)) {
+            return;
+        }
+        let keyToUse = key;
+        if (convertStringKeysToNumbers) {
+            const numberKey = tonumber(key);
+            if (numberKey === undefined) {
+                return;
+            }
+            keyToUse = numberKey;
+        }
+        if ((0, tstlClass_1.isTSTLMap)(oldObject) || (0, tstlClass_1.isDefaultMap)(oldObject)) {
+            const deserializedValue = (0, deepCopy_1.deepCopy)(value, SerializationType_1.SerializationType.DESERIALIZE, traversalDescription, classConstructors);
+            oldObject.set(keyToUse, deserializedValue);
+        }
+        else if ((0, tstlClass_1.isTSTLSet)(oldObject)) {
+            oldObject.add(keyToUse);
+        }
+    }, constants_1.SAVE_DATA_MANAGER_DEBUG);
+}

package/dist/functions/merge.lua

@@ -2,7 +2,7 @@ local ____lualib = require("lualib_bundle")
 local Set = ____lualib.Set
 local Map = ____lualib.Map
 local ____exports = {}
-local mergeSerializedArray, mergeSerializedTSTLObject, mergeSerializedTable
+local mergeSerializedArray, mergeSerializedTable, mergeSerializedTSTLObject
 local ____constants = require("classes.features.other.saveDataManager.constants")
 local SAVE_DATA_MANAGER_DEBUG = ____constants.SAVE_DATA_MANAGER_DEBUG
 local ____SerializationBrand = require("enums.private.SerializationBrand")
@@ -127,43 +127,6 @@ function mergeSerializedArray(self, oldArray, newArray, traversalDescription, cl
         SAVE_DATA_MANAGER_DEBUG
     )
 end
-function mergeSerializedTSTLObject(self, oldObject, newTable, traversalDescription, classConstructors)
-    if SAVE_DATA_MANAGER_DEBUG then
-        log("merge encountered a TSTL object: " .. traversalDescription)
-    end
-    oldObject:clear()
-    local convertStringKeysToNumbers = newTable[SerializationBrand.OBJECT_WITH_NUMBER_KEYS] ~= nil
-    iterateTableInOrder(
-        nil,
-        newTable,
-        function(____, key, value)
-            if isSerializationBrand(nil, key) then
-                return
-            end
-            local keyToUse = key
-            if convertStringKeysToNumbers then
-                local numberKey = tonumber(key)
-                if numberKey == nil then
-                    return
-                end
-                keyToUse = numberKey
-            end
-            if isTSTLMap(nil, oldObject) or isDefaultMap(nil, oldObject) then
-                local deserializedValue = deepCopy(
-                    nil,
-                    value,
-                    SerializationType.DESERIALIZE,
-                    traversalDescription,
-                    classConstructors
-                )
-                oldObject:set(keyToUse, deserializedValue)
-            elseif isTSTLSet(nil, oldObject) then
-                oldObject:add(keyToUse)
-            end
-        end,
-        SAVE_DATA_MANAGER_DEBUG
-    )
-end
 function mergeSerializedTable(self, oldTable, newTable, traversalDescription, classConstructors)
     if SAVE_DATA_MANAGER_DEBUG then
         log("merge encountered a Lua table: " .. traversalDescription)
@@ -208,4 +171,41 @@ function mergeSerializedTable(self, oldTable, newTable, traversalDescription, cl
         SAVE_DATA_MANAGER_DEBUG
     )
 end
+function mergeSerializedTSTLObject(self, oldObject, newTable, traversalDescription, classConstructors)
+    if SAVE_DATA_MANAGER_DEBUG then
+        log("merge encountered a TSTL object: " .. traversalDescription)
+    end
+    oldObject:clear()
+    local convertStringKeysToNumbers = newTable[SerializationBrand.OBJECT_WITH_NUMBER_KEYS] ~= nil
+    iterateTableInOrder(
+        nil,
+        newTable,
+        function(____, key, value)
+            if isSerializationBrand(nil, key) then
+                return
+            end
+            local keyToUse = key
+            if convertStringKeysToNumbers then
+                local numberKey = tonumber(key)
+                if numberKey == nil then
+                    return
+                end
+                keyToUse = numberKey
+            end
+            if isTSTLMap(nil, oldObject) or isDefaultMap(nil, oldObject) then
+                local deserializedValue = deepCopy(
+                    nil,
+                    value,
+                    SerializationType.DESERIALIZE,
+                    traversalDescription,
+                    classConstructors
+                )
+                oldObject:set(keyToUse, deserializedValue)
+            elseif isTSTLSet(nil, oldObject) then
+                oldObject:add(keyToUse)
+            end
+        end,
+        SAVE_DATA_MANAGER_DEBUG
+    )
+end
 return ____exports

package/dist/functions/mergeTests.js

@@ -29,74 +29,24 @@ function runMergeTests() {
     const successText = "All merge tests passed!";
     (0, log_1.logAndPrint)(successText);
 }
-function oldTableHasUpdatedValue() {
-    const key = "foo";
-    const oldValue = "bar";
-    const newValue = "baz";
-    const oldTable = {
-        foo: oldValue,
-    };
-    const newTable = {
-        foo: newValue,
-    };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValue");
-    const oldTableValue = oldTable.get(key);
-    if (oldTableValue !== newValue) {
-        error(`The old table does not have a value of: ${newValue}`);
-    }
-}
 function newTableHasSameValue() {
     const key = "foo";
     const oldValue = "bar";
     const newValue = "baz";
-    const oldTable = {
-        foo: oldValue,
-    };
-    const newTable = {
-        foo: newValue,
-    };
+    const oldTable = { foo: oldValue };
+    const newTable = { foo: newValue };
     (0, merge_1.merge)(oldTable, newTable, "newTableHasSameValue");
     const newTableValue = newTable.get(key);
     if (newTableValue !== newValue) {
         error(`The new table does not have a value of: ${newValue}`);
     }
 }
-function oldTableHasUpdatedValueFromNull() {
-    const key = "foo";
-    const newValue = "baz";
-    const oldTable = {
-        foo: null,
-    };
-    const newTable = {
-        foo: newValue,
-    };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
-    const oldTableValue = oldTable.get(key);
-    if (oldTableValue !== newValue) {
-        error(`The old table does not have a value of: ${newValue}`);
-    }
-}
-function oldTableHasSerializedIsaacAPIClass() {
-    const x = 50;
-    const y = 60;
-    const vector = Vector(x, y);
-    const vectorSerialized = (0, vector_1.serializeVector)(vector);
-    if (!(0, serialization_1.isSerializedIsaacAPIClass)(vectorSerialized)) {
-        error('The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.');
-    }
-}
 function oldTableHasFilledChildTable() {
     const key = "foo";
     const newValue = "baz";
-    const oldTable = {
-        foo: null,
-    };
-    const foo = {
-        bar: newValue,
-    };
-    const newTable = {
-        foo,
-    };
+    const oldTable = { foo: null };
+    const foo = { bar: newValue };
+    const newTable = { foo };
     (0, merge_1.merge)(oldTable, newTable, "oldTableHasFilledChildTable");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
@@ -106,15 +56,15 @@ function oldTableHasFilledChildTable() {
         error('The old table\'s key of "bar" was not filled.');
     }
 }
-function oldTableHasFilledMap() {
+function oldTableHasFilledDefaultMap() {
     const fakeV = {
         run: {
-            myMap: new Map(),
+            myDefaultMap: new DefaultMap_1.DefaultMap("default"),
         },
     };
     const saveData = {
         run: {
-            myMap: new Map([
+            myDefaultMap: new DefaultMap_1.DefaultMap("default", [
                 ["foo1", "bar1"],
                 ["foo2", "bar2"],
                 ["foo3", "bar3"],
@@ -122,45 +72,45 @@ function oldTableHasFilledMap() {
         },
     };
     const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
-    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledMap");
+    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledDefaultMap");
     const expectedSize = 3;
-    if (fakeV.run.myMap.size !== expectedSize) {
-        error(`The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`);
+    if (fakeV.run.myDefaultMap.size !== expectedSize) {
+        error(`The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`);
     }
     {
         const key = "foo1";
         const expectedValue = "bar1";
-        const value = fakeV.run.myMap.get(key);
+        const value = fakeV.run.myDefaultMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
     {
         const key = "foo2";
         const expectedValue = "bar2";
-        const value = fakeV.run.myMap.get(key);
+        const value = fakeV.run.myDefaultMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
     {
         const key = "foo3";
         const expectedValue = "bar3";
-        const value = fakeV.run.myMap.get(key);
+        const value = fakeV.run.myDefaultMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
 }
-function oldTableHasFilledDefaultMap() {
+function oldTableHasFilledMap() {
     const fakeV = {
         run: {
-            myDefaultMap: new DefaultMap_1.DefaultMap("default"),
+            myMap: new Map(),
         },
     };
     const saveData = {
         run: {
-            myDefaultMap: new DefaultMap_1.DefaultMap("default", [
+            myMap: new Map([
                 ["foo1", "bar1"],
                 ["foo2", "bar2"],
                 ["foo3", "bar3"],
@@ -168,50 +118,117 @@ function oldTableHasFilledDefaultMap() {
         },
     };
     const serializedSaveData = (0, deepCopy_1.deepCopy)(saveData, SerializationType_1.SerializationType.SERIALIZE);
-    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledDefaultMap");
+    (0, merge_1.merge)(fakeV, serializedSaveData, "oldTableHasFilledMap");
     const expectedSize = 3;
-    if (fakeV.run.myDefaultMap.size !== expectedSize) {
-        error(`The size of the merged default map was equal to ${fakeV.run.myDefaultMap.size}, but it should be equal to: ${expectedSize}`);
+    if (fakeV.run.myMap.size !== expectedSize) {
+        error(`The size of the merged map was equal to ${fakeV.run.myMap.size}, but it should be equal to: ${expectedSize}`);
     }
     {
         const key = "foo1";
         const expectedValue = "bar1";
-        const value = fakeV.run.myDefaultMap.get(key);
+        const value = fakeV.run.myMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
     {
         const key = "foo2";
         const expectedValue = "bar2";
-        const value = fakeV.run.myDefaultMap.get(key);
+        const value = fakeV.run.myMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
     {
         const key = "foo3";
         const expectedValue = "bar3";
-        const value = fakeV.run.myDefaultMap.get(key);
+        const value = fakeV.run.myMap.get(key);
         if (value !== expectedValue) {
-            error(`The old table's default map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
+            error(`The old table's map key of "${key}" was not equal to "${expectedValue}" and was instead equal to: ${value}`);
         }
     }
 }
+function oldTableHasRNG() {
+    const key = "foo";
+    const seed = 50;
+    const newValue = (0, rng_1.newRNG)(seed);
+    const oldTable = { foo: null };
+    const foo = { bar: newValue };
+    const newTable = { foo };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasRNG");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object.");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}
+function oldTableHasRNGSerialized() {
+    const key = "foo";
+    const seed = 50;
+    const newValue = (0, rng_1.newRNG)(seed);
+    const oldTable = { foo: null };
+    const foo = { bar: newValue };
+    const newTable = { foo };
+    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasRNGSerialized");
+    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object (during the serialized test).");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}
+function oldTableHasSerializedIsaacAPIClass() {
+    const x = 50;
+    const y = 60;
+    const vector = Vector(x, y);
+    const vectorSerialized = (0, vector_1.serializeVector)(vector);
+    if (!(0, serialization_1.isSerializedIsaacAPIClass)(vectorSerialized)) {
+        error('The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.');
+    }
+}
+function oldTableHasUpdatedValue() {
+    const key = "foo";
+    const oldValue = "bar";
+    const newValue = "baz";
+    const oldTable = { foo: oldValue };
+    const newTable = { foo: newValue };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValue");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
+function oldTableHasUpdatedValueFromNull() {
+    const key = "foo";
+    const newValue = "baz";
+    const oldTable = { foo: null };
+    const newTable = { foo: newValue };
+    (0, merge_1.merge)(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
 function oldTableHasVector() {
     const key = "foo";
     const x = 50;
     const y = 60;
     const newValue = Vector(x, y);
-    const oldTable = {
-        foo: null,
-    };
-    const foo = {
-        bar: newValue,
-    };
-    const newTable = {
-        foo,
-    };
+    const oldTable = { foo: null };
+    const foo = { bar: newValue };
+    const newTable = { foo };
     (0, merge_1.merge)(oldTable, newTable, "oldTableHasVector");
     const oldTableValue = oldTable.get(key);
     if (oldTableValue === undefined) {
@@ -232,15 +249,9 @@ function oldTableHasVectorSerialized() {
     const x = 50;
     const y = 60;
     const newValue = Vector(x, y);
-    const oldTable = {
-        foo: null,
-    };
-    const foo = {
-        bar: newValue,
-    };
-    const newTable = {
-        foo,
-    };
+    const oldTable = { foo: null };
+    const foo = { bar: newValue };
+    const newTable = { foo };
     const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasVectorSerialized");
     (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
     const oldTableValue = oldTable.get(key);
@@ -257,56 +268,3 @@ function oldTableHasVectorSerialized() {
         error("The old table's value is not a Vector object (during the serialized test).");
     }
 }
-function oldTableHasRNG() {
-    const key = "foo";
-    const seed = 50;
-    const newValue = (0, rng_1.newRNG)(seed);
-    const oldTable = {
-        foo: null,
-    };
-    const foo = {
-        bar: newValue,
-    };
-    const newTable = {
-        foo,
-    };
-    (0, merge_1.merge)(oldTable, newTable, "oldTableHasRNG");
-    const oldTableValue = oldTable.get(key);
-    if (oldTableValue === undefined) {
-        error(`The old table's key of "${key}" was not filled.`);
-    }
-    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
-        error("The old table's value is not an RNG object.");
-    }
-    const newSeed = oldTableValue.bar.GetSeed();
-    if (newSeed !== seed) {
-        error(`The old table's seed not match: ${seed}`);
-    }
-}
-function oldTableHasRNGSerialized() {
-    const key = "foo";
-    const seed = 50;
-    const newValue = (0, rng_1.newRNG)(seed);
-    const oldTable = {
-        foo: null,
-    };
-    const foo = {
-        bar: newValue,
-    };
-    const newTable = {
-        foo,
-    };
-    const newTableSerialized = (0, deepCopy_1.deepCopy)(newTable, SerializationType_1.SerializationType.SERIALIZE, "oldTableHasRNGSerialized");
-    (0, merge_1.merge)(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
-    const oldTableValue = oldTable.get(key);
-    if (oldTableValue === undefined) {
-        error(`The old table's key of "${key}" was not filled.`);
-    }
-    if (!(0, rng_1.isRNG)(oldTableValue.bar)) {
-        error("The old table's value is not an RNG object (during the serialized test).");
-    }
-    const newSeed = oldTableValue.bar.GetSeed();
-    if (newSeed !== seed) {
-        error(`The old table's seed not match: ${seed}`);
-    }
-}