isaacscript-common 87.9.6 → 87.9.7

package/src/functions/deepCopy.ts

@@ -145,98 +145,55 @@ export function deepCopy(
   }
 }
 
-function deepCopyTable(
+/**
+ * Lua tables can have metatables, which make writing a generic deep cloner impossible. The deep
+ * copy function will refuse to copy a table type that has a metatable, outside of specifically
+ * supported TSTL objects.
+ */
+function checkMetatable(
   luaMap: LuaMap<AnyNotNil, unknown>,
-  serializationType: SerializationType,
   traversalDescription: string,
-  classConstructors: LuaMap<string, AnyClass>,
-  insideMap: boolean,
-): unknown {
-  // First, handle the cases of TSTL classes or serialized TSTL classes.
-  if (isDefaultMap(luaMap) || luaMap.has(SerializationBrand.DEFAULT_MAP)) {
-    return deepCopyDefaultMap(
-      luaMap,
-      serializationType,
-      traversalDescription,
-      classConstructors,
-      insideMap,
-    );
-  }
-
-  if (isTSTLMap(luaMap) || luaMap.has(SerializationBrand.MAP)) {
-    return deepCopyMap(
-      luaMap,
-      serializationType,
-      traversalDescription,
-      classConstructors,
-      insideMap,
-    );
-  }
-
-  if (isTSTLSet(luaMap) || luaMap.has(SerializationBrand.SET)) {
-    return deepCopySet(
-      luaMap,
-      serializationType,
-      traversalDescription,
-      classConstructors,
-      insideMap,
-    );
+) {
+  const metatable = getmetatable(luaMap);
+  if (metatable === undefined) {
+    return;
   }
 
-  const className = getTSTLClassName(luaMap);
-
-  if (className === "WeakMap") {
-    error(
-      `The deep copy function does not support copying the "WeakMap" class for: ${traversalDescription}`,
-    );
-  }
+  const tableDescription =
+    traversalDescription === ""
+      ? "the table to copy"
+      : `"${traversalDescription}"`;
 
-  if (className === "WeakSet") {
-    error(
-      `The deep copy function does not support copying the "WeakSet" class for: ${traversalDescription}`,
-    );
-  }
+  error(
+    `The deepCopy function detected that ${tableDescription} has a metatable. Copying tables with metatables is not supported, unless they are explicitly handled by the save data manager. (e.g. TypeScriptToLua Maps, TypeScriptToLua Sets, etc.)`,
+  );
+}
 
-  if (className !== undefined || luaMap.has(SerializationBrand.TSTL_CLASS)) {
-    return deepCopyTSTLClass(
-      luaMap as TSTLClass,
-      serializationType,
-      traversalDescription,
-      classConstructors,
-      insideMap,
-    );
+function deepCopyArray(
+  array: readonly unknown[],
+  serializationType: SerializationType,
+  traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
+  insideMap: boolean,
+): readonly unknown[] {
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying an array.");
   }
 
-  // This is not a TSTL Map/Set/class. If it has a metatable, abort.
-  checkMetatable(luaMap, traversalDescription);
-
-  // Handle the special case of serialized Isaac API classes.
-  if (
-    isSerializedIsaacAPIClass(luaMap)
-    && serializationType === SerializationType.DESERIALIZE
-  ) {
-    return deserializeIsaacAPIClass(luaMap);
-  }
+  const newArray: unknown[] = [];
 
-  // Handle the special case of an array.
-  if (isArray(luaMap)) {
-    return deepCopyArray(
-      luaMap,
+  for (const value of array) {
+    const newValue = deepCopy(
+      value,
       serializationType,
       traversalDescription,
       classConstructors,
       insideMap,
     );
+    newArray.push(newValue);
   }
 
-  // Base case: copy a normal Lua table
-  return deepCopyNormalLuaTable(
-    luaMap,
-    serializationType,
-    traversalDescription,
-    classConstructors,
-    insideMap,
-  );
+  return newArray;
 }
 
 function deepCopyDefaultMap(
@@ -305,6 +262,7 @@ function deepCopyDefaultMap(
     // the proper set method call.
     if (isDefaultMap(newDefaultMap)) {
       newDefaultMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+      // eslint-disable-next-line unicorn/no-duplicate-if-branches
     } else {
       newDefaultMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
     }
@@ -315,6 +273,7 @@ function deepCopyDefaultMap(
     // the proper set method call.
     if (isDefaultMap(newDefaultMap)) {
       newDefaultMap.set(key, value);
+      // eslint-disable-next-line unicorn/no-duplicate-if-branches
     } else {
       newDefaultMap.set(key, value);
     }
@@ -323,53 +282,6 @@ function deepCopyDefaultMap(
   return newDefaultMap;
 }
 
-/**
- * The new copied default map with either be a TSTL `DefaultMap` class or a Lua table, depending on
- * whether we are serializing.
- */
-function getNewDefaultMap(
-  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
-  serializationType: SerializationType,
-  traversalDescription: string,
-  constructorArg: unknown,
-): DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown> {
-  switch (serializationType) {
-    case SerializationType.NONE: {
-      // eslint-disable-next-line isaacscript/no-invalid-default-map
-      return new DefaultMap(constructorArg);
-    }
-
-    case SerializationType.SERIALIZE: {
-      // Since we are serializing, the new object will be a Lua table. (At this point, we already
-      // handled the special case of a DefaultMap instantiated with a factory function.)
-      const newDefaultMap = new LuaMap<AnyNotNil, unknown>();
-      newDefaultMap.set(SerializationBrand.DEFAULT_MAP, "");
-      newDefaultMap.set(SerializationBrand.DEFAULT_MAP_VALUE, constructorArg);
-
-      return newDefaultMap;
-    }
-
-    case SerializationType.DESERIALIZE: {
-      if (isDefaultMap(defaultMap)) {
-        error(
-          `Failed to deserialize a default map of "${traversalDescription}", since it was not a Lua table.`,
-        );
-      }
-
-      const defaultMapValue = defaultMap.get(
-        SerializationBrand.DEFAULT_MAP_VALUE,
-      );
-      assertDefined(
-        defaultMapValue,
-        `Failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand.DEFAULT_MAP_VALUE}`,
-      );
-
-      // eslint-disable-next-line isaacscript/no-invalid-default-map
-      return new DefaultMap(defaultMapValue);
-    }
-  }
-}
-
 function deepCopyMap(
   map: ReadonlyMap<AnyNotNil, unknown> | Readonly<LuaMap<AnyNotNil, unknown>>,
   serializationType: SerializationType,
@@ -404,6 +316,7 @@ function deepCopyMap(
     // the proper set method call.
     if (isTSTLMap(newMap)) {
       newMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+      // eslint-disable-next-line unicorn/no-duplicate-if-branches
     } else {
       newMap.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
     }
@@ -414,6 +327,7 @@ function deepCopyMap(
     // the proper set method call.
     if (isTSTLMap(newMap)) {
       newMap.set(key, value);
+      // eslint-disable-next-line unicorn/no-duplicate-if-branches
     } else {
       newMap.set(key, value);
     }
@@ -422,6 +336,37 @@ function deepCopyMap(
   return newMap;
 }
 
+function deepCopyNormalLuaTable(
+  luaMap: LuaMap<AnyNotNil, unknown>,
+  serializationType: SerializationType,
+  traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
+  insideMap: boolean,
+) {
+  if (SAVE_DATA_MANAGER_DEBUG) {
+    log("deepCopy is copying a normal Lua table.");
+  }
+
+  const newTable = new LuaMap<AnyNotNil, unknown>();
+  const { entries, convertedNumberKeysToStrings } = getCopiedEntries(
+    luaMap,
+    serializationType,
+    traversalDescription,
+    classConstructors,
+    insideMap,
+  );
+
+  if (convertedNumberKeysToStrings) {
+    newTable.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
+  }
+
+  for (const [key, value] of entries) {
+    newTable.set(key, value);
+  }
+
+  return newTable;
+}
+
 function deepCopySet(
   set: ReadonlySet<AnyNotNil> | Readonly<LuaMap<AnyNotNil, unknown>>,
   serializationType: SerializationType,
@@ -477,6 +422,94 @@ function deepCopySet(
   return newSet;
 }
 
+function deepCopyTable(
+  luaMap: LuaMap<AnyNotNil, unknown>,
+  serializationType: SerializationType,
+  traversalDescription: string,
+  classConstructors: LuaMap<string, AnyClass>,
+  insideMap: boolean,
+): unknown {
+  // First, handle the cases of TSTL classes or serialized TSTL classes.
+  if (isDefaultMap(luaMap) || luaMap.has(SerializationBrand.DEFAULT_MAP)) {
+    return deepCopyDefaultMap(
+      luaMap,
+      serializationType,
+      traversalDescription,
+      classConstructors,
+      insideMap,
+    );
+  }
+
+  if (isTSTLMap(luaMap) || luaMap.has(SerializationBrand.MAP)) {
+    return deepCopyMap(
+      luaMap,
+      serializationType,
+      traversalDescription,
+      classConstructors,
+      insideMap,
+    );
+  }
+
+  if (isTSTLSet(luaMap) || luaMap.has(SerializationBrand.SET)) {
+    return deepCopySet(
+      luaMap,
+      serializationType,
+      traversalDescription,
+      classConstructors,
+      insideMap,
+    );
+  }
+
+  const className = getTSTLClassName(luaMap);
+
+  if (className === "WeakMap" || className === "WeakSet") {
+    error(
+      `The deep copy function does not support copying the "${className}" class for: ${traversalDescription}`,
+    );
+  }
+
+  if (className !== undefined || luaMap.has(SerializationBrand.TSTL_CLASS)) {
+    return deepCopyTSTLClass(
+      luaMap as TSTLClass,
+      serializationType,
+      traversalDescription,
+      classConstructors,
+      insideMap,
+    );
+  }
+
+  // This is not a TSTL Map/Set/class. If it has a metatable, abort.
+  checkMetatable(luaMap, traversalDescription);
+
+  // Handle the special case of serialized Isaac API classes.
+  if (
+    isSerializedIsaacAPIClass(luaMap)
+    && serializationType === SerializationType.DESERIALIZE
+  ) {
+    return deserializeIsaacAPIClass(luaMap);
+  }
+
+  // Handle the special case of an array.
+  if (isArray(luaMap)) {
+    return deepCopyArray(
+      luaMap,
+      serializationType,
+      traversalDescription,
+      classConstructors,
+      insideMap,
+    );
+  }
+
+  // Base case: copy a normal Lua table
+  return deepCopyNormalLuaTable(
+    luaMap,
+    serializationType,
+    traversalDescription,
+    classConstructors,
+    insideMap,
+  );
+}
+
 function deepCopyTSTLClass(
   tstlClass: TSTLClass,
   serializationType: SerializationType,
@@ -511,8 +544,7 @@ function deepCopyTSTLClass(
 
     case SerializationType.DESERIALIZE: {
       const tstlClassName = tstlClass.get(SerializationBrand.TSTL_CLASS) as
-        | string
-        | undefined;
+        string | undefined;
       assertDefined(
         tstlClassName,
         "Failed to deserialize a TSTL class since the brand did not contain the class name.",
@@ -550,62 +582,34 @@ function deepCopyTSTLClass(
   return newClass;
 }
 
-function deepCopyArray(
-  array: readonly unknown[],
-  serializationType: SerializationType,
-  traversalDescription: string,
-  classConstructors: LuaMap<string, AnyClass>,
-  insideMap: boolean,
-): readonly unknown[] {
-  if (SAVE_DATA_MANAGER_DEBUG) {
-    log("deepCopy is copying an array.");
-  }
-
-  const newArray: unknown[] = [];
-
-  for (const value of array) {
-    const newValue = deepCopy(
-      value,
-      serializationType,
-      traversalDescription,
-      classConstructors,
-      insideMap,
-    );
-    newArray.push(newValue);
-  }
-
-  return newArray;
-}
-
-function deepCopyNormalLuaTable(
-  luaMap: LuaMap<AnyNotNil, unknown>,
+/** Isaac API classes are of type "userdata". End-user code cannot create userdata. */
+function deepCopyUserdata(
+  value: unknown,
   serializationType: SerializationType,
   traversalDescription: string,
-  classConstructors: LuaMap<string, AnyClass>,
-  insideMap: boolean,
 ) {
-  if (SAVE_DATA_MANAGER_DEBUG) {
-    log("deepCopy is copying a normal Lua table.");
+  if (!isCopyableIsaacAPIClass(value)) {
+    const className = getIsaacAPIClassName(value) ?? "Unknown";
+    error(
+      `The deep copy function does not support serializing "${traversalDescription}", since it is an Isaac API class of type: ${className}`,
+    );
   }
 
-  const newTable = new LuaMap<AnyNotNil, unknown>();
-  const { entries, convertedNumberKeysToStrings } = getCopiedEntries(
-    luaMap,
-    serializationType,
-    traversalDescription,
-    classConstructors,
-    insideMap,
-  );
+  switch (serializationType) {
+    case SerializationType.NONE: {
+      return copyIsaacAPIClass(value);
+    }
 
-  if (convertedNumberKeysToStrings) {
-    newTable.set(SerializationBrand.OBJECT_WITH_NUMBER_KEYS, "");
-  }
+    case SerializationType.SERIALIZE: {
+      return serializeIsaacAPIClass(value);
+    }
 
-  for (const [key, value] of entries) {
-    newTable.set(key, value);
+    case SerializationType.DESERIALIZE: {
+      return error(
+        `The deep copy function can not deserialize "${traversalDescription}", since it is userdata.`,
+      );
+    }
   }
-
-  return newTable;
 }
 
 /**
@@ -691,55 +695,48 @@ function getCopiedEntries(
 }
 
 /**
- * Lua tables can have metatables, which make writing a generic deep cloner impossible. The deep
- * copy function will refuse to copy a table type that has a metatable, outside of specifically
- * supported TSTL objects.
+ * The new copied default map with either be a TSTL `DefaultMap` class or a Lua table, depending on
+ * whether we are serializing.
  */
-function checkMetatable(
-  luaMap: LuaMap<AnyNotNil, unknown>,
-  traversalDescription: string,
-) {
-  const metatable = getmetatable(luaMap);
-  if (metatable === undefined) {
-    return;
-  }
-
-  const tableDescription =
-    traversalDescription === ""
-      ? "the table to copy"
-      : `"${traversalDescription}"`;
-
-  error(
-    `The deepCopy function detected that ${tableDescription} has a metatable. Copying tables with metatables is not supported, unless they are explicitly handled by the save data manager. (e.g. TypeScriptToLua Maps, TypeScriptToLua Sets, etc.)`,
-  );
-}
-
-/** Isaac API classes are of type "userdata". End-user code cannot create userdata. */
-function deepCopyUserdata(
-  value: unknown,
+function getNewDefaultMap(
+  defaultMap: DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown>,
   serializationType: SerializationType,
   traversalDescription: string,
-) {
-  if (!isCopyableIsaacAPIClass(value)) {
-    const className = getIsaacAPIClassName(value) ?? "Unknown";
-    error(
-      `The deep copy function does not support serializing "${traversalDescription}", since it is an Isaac API class of type: ${className}`,
-    );
-  }
-
+  constructorArg: unknown,
+): DefaultMap<AnyNotNil, unknown> | LuaMap<AnyNotNil, unknown> {
   switch (serializationType) {
     case SerializationType.NONE: {
-      return copyIsaacAPIClass(value);
+      // eslint-disable-next-line isaacscript/no-invalid-default-map
+      return new DefaultMap(constructorArg);
     }
 
     case SerializationType.SERIALIZE: {
-      return serializeIsaacAPIClass(value);
+      // Since we are serializing, the new object will be a Lua table. (At this point, we already
+      // handled the special case of a DefaultMap instantiated with a factory function.)
+      const newDefaultMap = new LuaMap<AnyNotNil, unknown>();
+      newDefaultMap.set(SerializationBrand.DEFAULT_MAP, "");
+      newDefaultMap.set(SerializationBrand.DEFAULT_MAP_VALUE, constructorArg);
+
+      return newDefaultMap;
     }
 
     case SerializationType.DESERIALIZE: {
-      return error(
-        `The deep copy function can not deserialize "${traversalDescription}", since it is userdata.`,
+      if (isDefaultMap(defaultMap)) {
+        error(
+          `Failed to deserialize a default map of "${traversalDescription}", since it was not a Lua table.`,
+        );
+      }
+
+      const defaultMapValue = defaultMap.get(
+        SerializationBrand.DEFAULT_MAP_VALUE,
+      );
+      assertDefined(
+        defaultMapValue,
+        `Failed to deserialize a default map of "${traversalDescription}", since there was no serialization brand of: ${SerializationBrand.DEFAULT_MAP_VALUE}`,
       );
+
+      // eslint-disable-next-line isaacscript/no-invalid-default-map
+      return new DefaultMap(defaultMapValue);
     }
   }
 }