isaacscript-common 6.9.0 → 6.10.2

package/src/functions/deepCopyTests.ts

@@ -32,6 +32,12 @@ export function runDeepCopyTests(): void {
   copiedDefaultMapHasChildDefaultMap();
   copiedDefaultMapHasBrand();
 
+  copiedSerializedMapHasStringKeyType();
+  copiedSerializedMapHasNumberKeyType();
+
+  copiedSerializedDefaultMapHasStringKeyType();
+  copiedSerializedDefaultMapHasNumberKeyType();
+
   log("All deep copy tests passed!");
 }
 
@@ -40,7 +46,7 @@ function copiedObjectIsTable() {
     abc: "def",
   };
   const newObject = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectIsTable",
   );
@@ -56,7 +62,7 @@ function copiedObjectHasKeyAndValueString() {
     abc: valueToLookFor,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasKeyAndValueString",
   );
@@ -79,7 +85,7 @@ function copiedObjectHasKeyAndValueString() {
 function copiedTableHasKeyAndValueNumber() {
   const keyToLookFor = 123;
   const valueToLookFor = 456;
-  const oldTable = new LuaTable<AnyNotNil, unknown>();
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
   const newObject = deepCopy(
@@ -87,7 +93,7 @@ function copiedTableHasKeyAndValueNumber() {
     SerializationType.NONE,
     "copiedTableHasKeyAndValueNumber",
   );
-  const newTable = newObject as LuaTable<AnyNotNil, unknown>;
+  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const value = newTable.get(keyToLookFor) as number | undefined;
   if (value === undefined) {
@@ -105,7 +111,7 @@ function copiedTableHasKeyAndValueNumber() {
 function copiedTableDoesNotCoerceTypes() {
   const keyToLookFor = 123;
   const valueToLookFor = 456;
-  const oldTable = new LuaTable<AnyNotNil, unknown>();
+  const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
   const newObject = deepCopy(
@@ -113,7 +119,7 @@ function copiedTableDoesNotCoerceTypes() {
     SerializationType.NONE,
     "copiedTableDoesNotCoerceTypes",
   );
-  const newTable = newObject as LuaTable<AnyNotNil, unknown>;
+  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const keyString = tostring(keyToLookFor);
   const valueString = tostring(valueToLookFor);
@@ -140,7 +146,7 @@ function copiedObjectHasNoReferencesForPrimitivesForward() {
     def: originalNumberValue,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesForward",
   );
@@ -165,7 +171,7 @@ function copiedObjectHasNoReferencesForPrimitivesBackward() {
     def: originalNumberValue,
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesBackward",
   );
@@ -188,7 +194,7 @@ function copiedObjectHasNoReferencesForArray() {
     abc: [1, 2, 3],
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForArray",
   );
@@ -229,7 +235,7 @@ function copiedObjectHasChildObject() {
     },
   };
   const newTable = deepCopy(
-    oldObject as unknown as LuaTable,
+    oldObject as unknown as LuaMap,
     SerializationType.NONE,
     "copiedObjectHasChildObject",
   );
@@ -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);
@@ -432,7 +449,13 @@ function copiedDefaultMapHasBrand() {
     oldDefaultMap,
     SerializationType.SERIALIZE,
     "copiedDefaultMapHasBrand",
-  ) as LuaTable<AnyNotNil, unknown>;
+  ) 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(
@@ -440,3 +463,113 @@ function copiedDefaultMapHasBrand() {
     );
   }
 }
+
+function copiedSerializedMapHasStringKeyType() {
+  const mapKey = "123";
+  const mapValue = 456;
+  const oldMap = new Map<string, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const tempTable = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasStringKeyTypeSerialize",
+  );
+
+  const newTable = deepCopy(
+    tempTable,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasStringKeyTypeDeserialize",
+  );
+
+  const newMap = newTable as Map<string, number>;
+  if (![...newMap.keys()].includes(mapKey)) {
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${type(
+        mapKey,
+      )}`,
+    );
+  }
+}
+
+function copiedSerializedMapHasNumberKeyType() {
+  const mapKey = 123;
+  const mapValue = 456;
+  const oldMap = new Map<number, number>();
+  oldMap.set(mapKey, mapValue);
+
+  const tempTable = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedMapHasNumberKeyTypeSerialize",
+  );
+
+  const newTable = deepCopy(
+    tempTable,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedMapHasNumberKeyTypeDeserialize",
+  );
+
+  const newMap = newTable as Map<number, number>;
+  if (![...newMap.keys()].includes(mapKey)) {
+    error(
+      `The copied Map did not have a key of: ${mapKey} with type ${type(
+        mapKey,
+      )}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasStringKeyType() {
+  const mapKey = "123";
+  const oldMap = new DefaultMap<string, number>(456);
+  oldMap.getAndSetDefault(mapKey);
+
+  const tempTable = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasStringKeyTypeSerialize",
+  );
+
+  const newTable = deepCopy(
+    tempTable,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasStringKeyTypeDeserialize",
+  );
+
+  const newMap = newTable as DefaultMap<string, number>;
+  if (![...newMap.keys()].includes(mapKey)) {
+    error(
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${type(
+        mapKey,
+      )}`,
+    );
+  }
+}
+
+function copiedSerializedDefaultMapHasNumberKeyType() {
+  const mapKey = 123;
+  const oldMap = new DefaultMap<number, number>(456);
+  oldMap.getAndSetDefault(mapKey);
+
+  const tempTable = deepCopy(
+    oldMap,
+    SerializationType.SERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKeyTypeSerialize",
+  );
+
+  const newTable = deepCopy(
+    tempTable,
+    SerializationType.DESERIALIZE,
+    "copiedSerializedDefaultMapHasNumberKeyTypeDeserialize",
+  );
+
+  const newMap = newTable as DefaultMap<number, number>;
+  if (![...newMap.keys()].includes(mapKey)) {
+    error(
+      `The copied DefaultMap did not have a key of: ${mapKey} with type ${type(
+        mapKey,
+      )}`,
+    );
+  }
+}

package/src/functions/entities.ts

@@ -137,11 +137,11 @@ export function getEntities(
  */
 export function getEntityFields(
   entity: Entity,
-): LuaTable<string, boolean | number | string> {
-  const entityFields = new LuaTable<string, boolean | number | string>();
+): LuaMap<string, boolean | number | string> {
+  const entityFields = new LuaMap<string, boolean | number | string>();
 
   const metatable = getmetatable(entity) as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (metatable === undefined) {
     error("Failed to get the metatable for an entity.");
@@ -158,7 +158,7 @@ export function getEntityFields(
   }
 
   const parentTable = metatable.get("__parent") as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (parentTable === undefined) {
     error('Failed to get the "__parent" table for an entity.');
@@ -171,11 +171,11 @@ export function getEntityFields(
 
 function setPrimitiveEntityFields(
   entity: Entity,
-  metatable: LuaTable<AnyNotNil, unknown>,
-  entityFields: LuaTable<string, boolean | number | string>,
+  metatable: LuaMap<AnyNotNil, unknown>,
+  entityFields: LuaMap<string, boolean | number | string>,
 ) {
   const propGetTable = metatable.get("__propget") as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (propGetTable === undefined) {
     error('Failed to get the "__propget" table for an entity.');

package/src/functions/input.ts

@@ -4,10 +4,9 @@ import {
   ControllerIndex,
   Keyboard,
 } from "isaac-typescript-definitions";
-import { MAX_NUM_INPUTS } from "../constants";
+import { getEnumValues } from "./enums";
 import { copySet } from "./set";
 import { trimPrefix } from "./string";
-import { erange } from "./utils";
 
 const MODIFIER_KEYS: readonly Keyboard[] = [
   Keyboard.LEFT_SHIFT, // 340
@@ -62,9 +61,9 @@ export function getShootActions(): Set<ButtonAction> {
 
 /** Iterates over all inputs to determine if a particular button is pressed (i.e. held down). */
 export function isActionPressedOnAnyInput(buttonAction: ButtonAction): boolean {
-  const validInputs = erange(MAX_NUM_INPUTS);
-  return validInputs.some((input) =>
-    Input.IsActionPressed(buttonAction, input),
+  const controllerIndexes = getEnumValues(ControllerIndex);
+  return controllerIndexes.some((controllerIndex) =>
+    Input.IsActionPressed(buttonAction, controllerIndex),
   );
 }
 
@@ -75,9 +74,9 @@ export function isActionPressedOnAnyInput(buttonAction: ButtonAction): boolean {
 export function isActionTriggeredOnAnyInput(
   buttonAction: ButtonAction,
 ): boolean {
-  const validInputs = erange(MAX_NUM_INPUTS);
-  return validInputs.some((input) =>
-    Input.IsActionTriggered(buttonAction, input),
+  const controllerIndexes = getEnumValues(ControllerIndex);
+  return controllerIndexes.some((controllerIndex) =>
+    Input.IsActionTriggered(buttonAction, controllerIndex),
   );
 }
 

package/src/functions/isaacAPIClass.ts

@@ -16,7 +16,7 @@ export function getIsaacAPIClassName(object: unknown): string | undefined {
   }
 
   const metatable = getmetatable(object) as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (metatable === undefined) {
     return undefined;
@@ -60,8 +60,8 @@ export function isaacAPIClassEquals(
   object2: unknown,
   keys: string[],
 ): boolean {
-  const table1 = object1 as LuaTable<AnyNotNil, unknown>;
-  const table2 = object2 as LuaTable<AnyNotNil, unknown>;
+  const table1 = object1 as LuaMap<AnyNotNil, unknown>;
+  const table2 = object2 as LuaMap<AnyNotNil, unknown>;
 
   return keys.every((key) => table1.get(key) === table2.get(key));
 }

package/src/functions/jsonHelpers.ts

@@ -2,7 +2,7 @@ import * as json from "json";
 import { logError } from "./log";
 
 function tryDecode(this: void, jsonString: string) {
-  return json.decode(jsonString) as LuaTable;
+  return json.decode(jsonString) as LuaMap;
 }
 
 function tryEncode(this: void, luaTable: unknown) {
@@ -17,12 +17,12 @@ function tryEncode(this: void, luaTable: unknown) {
  * continue in cases where users have no current save data or have manually removed their existing
  * save data.)
  */
-export function jsonDecode(jsonString: string): LuaTable<AnyNotNil, unknown> {
+export function jsonDecode(jsonString: string): LuaMap<AnyNotNil, unknown> {
   const [ok, luaTableOrErrMsg] = pcall(tryDecode, jsonString);
   if (!ok) {
     // Instead of throwing an error, continue execution of the callback.
     logError(`Failed to convert the JSON string to a Lua table: ${jsonString}`);
-    return new LuaTable();
+    return new LuaMap();
   }
 
   return luaTableOrErrMsg;

package/src/functions/kColor.ts

@@ -4,7 +4,7 @@ import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
 import { isTable } from "./types";
 
-type SerializedKColor = LuaTable<string, unknown> & {
+type SerializedKColor = LuaMap<string, unknown> & {
   readonly __serializedKColorBrand: symbol;
 };
 
@@ -53,7 +53,7 @@ export function copyKColor(
         );
       }
 
-      const kColorTable = new LuaTable<string, unknown>();
+      const kColorTable = new LuaMap<string, unknown>();
       copyValuesToTable(kColor, KEYS, kColorTable);
       kColorTable.set(SerializationBrand.K_COLOR, "");
       return kColorTable as SerializedKColor;
@@ -67,7 +67,7 @@ export function copyKColor(
       }
 
       const [r, g, b, a] = getNumbersFromTable(
-        kColor as LuaTable<string, unknown>,
+        kColor as LuaMap<string, unknown>,
         OBJECT_NAME,
         ...KEYS,
       );

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,12 +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.
   (() => {
-    log(`${indentation}The size of the table was: ${luaTable.length()}`);
+    log(`${indentation}The size of the table was: ${numElements}`);
   })();
 }
 
@@ -668,8 +671,8 @@ export function logTable(
  */
 export function logTableDifferences<K, V>(
   this: void,
-  table1: LuaTable<K, V>,
-  table2: LuaTable<K, V>,
+  table1: LuaMap<K, V>,
+  table2: LuaMap<K, V>,
 ): void {
   log("Comparing two Lua tables:");
 
@@ -725,7 +728,7 @@ export function logUserdata(this: void, userdata: unknown): void {
   }
 
   const metatable = getmetatable(userdata) as
-    | LuaTable<AnyNotNil, unknown>
+    | LuaMap<AnyNotNil, unknown>
     | undefined;
   if (metatable === undefined) {
     log("Userdata: [no metatable]");