isaacscript-common 6.10.0 → 6.11.0

package/src/functions/deepCopyTests.ts

@@ -32,6 +32,12 @@ export function runDeepCopyTests(): void {
   copiedDefaultMapHasChildDefaultMap();
   copiedDefaultMapHasBrand();
 
+  copiedSerializedMapHasStringKey();
+  copiedSerializedMapHasNumberKey();
+
+  copiedSerializedDefaultMapHasStringKey();
+  copiedSerializedDefaultMapHasNumberKey();
+
   log("All deep copy tests passed!");
 }
 
@@ -268,11 +274,8 @@ function copiedMapIsMap() {
   const newObject = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
   const newMap = newObject as Map<string, string>;
 
-  if (!isTable(newMap)) {
-    error(`The copied Map had a type of: ${typeof newMap}`);
-  }
   if (!isTSTLMap(newMap)) {
-    error("The copied Map was not a Map.");
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
   }
 }
 
@@ -287,8 +290,13 @@ function copiedMapHasValue() {
     SerializationType.NONE,
     "copiedMapHasValue",
   );
+
   const newMap = newTable as typeof oldMap;
 
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
+  }
+
   const value = newMap.get(keyToLookFor);
   if (value === undefined) {
     error(`The copied Map did not have a key of: ${keyToLookFor}`);
@@ -306,11 +314,8 @@ function copiedSetIsSet() {
   const newTable = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
   const newSet = newTable as Set<string>;
 
-  if (!isTable(newSet)) {
-    error(`The copied Set had a type of: ${typeof newSet}`);
-  }
   if (!isTSTLSet(newSet)) {
-    error("The copied Set was not a Map.");
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
   }
 }
 
@@ -326,6 +331,10 @@ function copiedSetHasValue() {
   );
   const newSet = newTable as Set<string>;
 
+  if (!isTSTLSet(newSet)) {
+    error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
+  }
+
   const hasValue = newSet.has(valueToLookFor);
   if (!hasValue) {
     error(`The copied Set did not have a value of: ${valueToLookFor}`);
@@ -338,7 +347,7 @@ function copiedMapHasChildMap() {
   const oldChildMap = new Map<number, number>();
   oldChildMap.set(childMapKey, childMapValue);
 
-  const keyToLookFor = "abc";
+  const keyToLookFor = "childMap";
   const oldMap = new Map<string, Map<number, number>>();
   oldMap.set(keyToLookFor, oldChildMap);
 
@@ -349,16 +358,19 @@ function copiedMapHasChildMap() {
   );
   const newMap = newTable as typeof oldMap;
 
+  if (!isTSTLMap(newMap)) {
+    error(`The copied Map was not a Map and had a type of: ${typeof newMap}`);
+  }
+
   const newChildMap = newMap.get(keyToLookFor);
   if (newChildMap === undefined) {
     error(`The copied Map did not have a child map at key: ${keyToLookFor}`);
   }
 
-  if (!isTable(newChildMap)) {
-    error(`The copied child Map had a type of: ${typeof newChildMap}`);
-  }
   if (!isTSTLMap(newChildMap)) {
-    error("The copied child Map was not a Map.");
+    error(
+      `The copied child Map was not a Map and had a type of: ${typeof newChildMap}`,
+    );
   }
 
   const value = newChildMap.get(childMapKey);
@@ -390,6 +402,12 @@ function copiedDefaultMapHasChildDefaultMap() {
   );
   const newParentMap = newTable as typeof oldParentMap;
 
+  if (!isDefaultMap(newParentMap)) {
+    error(
+      `The copied parent DefaultMap was not a DefaultMap and had a type of: ${typeof newParentMap}`,
+    );
+  }
+
   const newChildMap = newParentMap.get(parentMapKey);
   if (newChildMap === undefined) {
     error(
@@ -397,11 +415,10 @@ function copiedDefaultMapHasChildDefaultMap() {
     );
   }
 
-  if (!isTable(newChildMap)) {
-    error(`The copied child DefaultMap had a type of: ${typeof newChildMap}`);
-  }
   if (!isDefaultMap(newChildMap)) {
-    error("The copied child DefaultMap was not a DefaultMap.");
+    error(
+      `The copied child DefaultMap was not a DefaultMap and had a type of: ${typeof newChildMap}`,
+    );
   }
 
   const newChildMapValue1 = newChildMap.get(childMapKey1);
@@ -434,9 +451,121 @@ function copiedDefaultMapHasBrand() {
     "copiedDefaultMapHasBrand",
   ) as LuaMap<AnyNotNil, unknown>;
 
+  if (!isTable(newTable)) {
+    error(
+      `The copied DefaultMap was not a table and had a type of: ${typeof newTable}`,
+    );
+  }
+
   if (!newTable.has(SerializationBrand.DEFAULT_MAP)) {
     error(
       `The copied DefaultMap does not have the brand: ${SerializationBrand.DEFAULT_MAP}`,
     );
   }
 }
+
+function copiedSerializedMapHasStringKey() {
+  const mapKey = "123";
+  const mapValue = 456;
+  const oldMap = new Map<string, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const serializedOldMap = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasStringKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasStringKey-deserialize",
+  );
+
+  const newMap = newTable as Map<string, number>;
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedMapHasNumberKey() {
+  const mapKey = 123;
+  const mapValue = 456;
+  const oldMap = new Map<number, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const serializedOldMap = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasNumberKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasNumberKey-deserialize",
+  );
+
+  const newMap = newTable as Map<number, number>;
+  if (!newMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasStringKey() {
+  const mapKey = "123";
+  const oldDefaultMap = new DefaultMap<string, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
+
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasStringKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldDefaultMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasStringKey-deserialize",
+  );
+
+  const newDefaultMap = newTable as DefaultMap<string, number>;
+  if (!newDefaultMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied DefaultMap did not have a key of "${mapKey}" with type: ${keyType}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasNumberKey() {
+  const mapKey = 123;
+  const oldDefaultMap = new DefaultMap<number, number>(456);
+  oldDefaultMap.getAndSetDefault(mapKey);
+
+  const serializedOldDefaultMap = deepCopy(
+    oldDefaultMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKey-serialize",
+  );
+
+  const newTable = deepCopy(
+    serializedOldDefaultMap,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKey-deserialize",
+  );
+
+  const newDefaultMap = newTable as DefaultMap<number, number>;
+  if (!newDefaultMap.has(mapKey)) {
+    const keyType = type(mapKey);
+    error(
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${keyType}`,
+    );
+  }
+}

package/src/functions/jsonHelpers.ts

@@ -1,12 +1,12 @@
-import * as json from "json";
+import * as jsonLua from "../lib/jsonLua";
 import { logError } from "./log";
 
 function tryDecode(this: void, jsonString: string) {
-  return json.decode(jsonString) as LuaMap;
+  return jsonLua.decode(jsonString) as LuaMap;
 }
 
 function tryEncode(this: void, luaTable: unknown) {
-  return json.encode(luaTable);
+  return jsonLua.encode(luaTable);
 }
 
 /**
@@ -16,6 +16,9 @@ function tryEncode(this: void, luaTable: unknown) {
  * fails, it will return a blank Lua table instead of throwing an error. (This allows execution to
  * continue in cases where users have no current save data or have manually removed their existing
  * save data.)
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
  */
 export function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknown> {
   const [ok, luaTableOrErrMsg] = pcall(tryDecode, jsonString);
@@ -34,6 +37,9 @@ export function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknown> {
  * In most cases, this function will be used for writing data to a "save#.dat" file. If encoding
  * fails, it will throw an error to prevent writing a blank string or corrupted data to a user's
  * "save#.dat" file.
+ *
+ * Under the hood, this uses a custom JSON parser that was measured to be 11.8 times faster than the
+ * vanilla JSON parser.
  */
 export function jsonEncode(luaTable: unknown): string {
   const [ok, jsonStringOrErrMsg] = pcall(tryEncode, luaTable);

package/src/functions/log.ts

@@ -640,6 +640,7 @@ export function logTable(
     return;
   }
 
+  let numElements = 0;
   iterateTableInOrder(luaTable, (key, value) => {
     // eslint-disable-next-line @typescript-eslint/no-base-to-string
     log(`${indentation}${key} --> ${value}`);
@@ -653,13 +654,14 @@ export function logTable(
         logTable(value, parentTables + 1);
       }
     }
+
+    numElements++;
   });
 
   // Put it in an IIFE so that the it will show as "func" instead of "logTable" and align with the
   // other text.
   (() => {
-    const { length } = Object.keys(luaTable);
-    log(`${indentation}The size of the table was: ${length}`);
+    log(`${indentation}The size of the table was: ${numElements}`);
   })();
 }
 

package/src/functions/mergeTests.ts

@@ -266,8 +266,6 @@ function oldTableHasFilledDefaultMap() {
 }
 
 function oldTableHasVector() {
-  log("Starting test: oldTableHasVector");
-
   interface Foo {
     bar: Vector;
   }
@@ -307,8 +305,6 @@ function oldTableHasVector() {
 }
 
 function oldTableHasVectorSerialized() {
-  log("Starting test: oldTableHasVectorSerialized");
-
   interface Foo {
     bar: Vector;
   }
@@ -355,8 +351,6 @@ function oldTableHasVectorSerialized() {
 }
 
 function oldTableHasRNG() {
-  log("Starting test: oldTableHasRNG");
-
   interface Foo {
     bar: RNG;
   }
@@ -392,8 +386,6 @@ function oldTableHasRNG() {
 }
 
 function oldTableHasRNGSerialized() {
-  log("Starting test: oldTableHasRNGSerialized");
-
   interface Foo {
     bar: RNG;
   }

package/src/lib/jsonLua.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is the custom JSON parser library called "json.lua". It is located at:
+ * https://github.com/rxi/json.lua
+ *
+ * This parser was measured to be 11.8 times faster than the vanilla parser at decoding a sample
+ * "save1.dat" file.
+ */
+
+export function encode(this: void, data: unknown): string;
+export function decode(this: void, data: string): unknown;