isaacscript-common 84.1.1 → 84.2.0

package/src/classes/features/callbackLogic/PlayerCollectibleDetection.ts

@@ -16,6 +16,7 @@ import {
   mapSetPlayer,
 } from "../../../functions/playerDataStructures";
 import { getPlayerFromPtr } from "../../../functions/players";
+import { sortNormal } from "../../../functions/sort";
 import { repeat } from "../../../functions/utils";
 import type { PickingUpItem } from "../../../types/PickingUpItem";
 import type { PlayerIndex } from "../../../types/PlayerIndex";
@@ -262,8 +263,8 @@ export class PlayerCollectibleDetection extends Feature {
     // For example, it is possible for the player to switch Schoolbag items, which will cause the
     // collectibles in the array to be the same, but in a different order. Thus, we sort both arrays
     // before comparing them.
-    oldCollectibleTypes.sort();
-    newCollectibleTypes.sort();
+    oldCollectibleTypes.sort(sortNormal);
+    newCollectibleTypes.sort(sortNormal);
 
     if (!arrayEquals(oldCollectibleTypes, newCollectibleTypes)) {
       // One or more active items have changed (with the player's total collectible count remaining

package/src/functions/array.ts

@@ -2,6 +2,7 @@ import { ReadonlySet } from "../types/ReadonlySet";
 import type { WidenLiteral } from "../types/WidenLiteral";
 import { getRandomInt } from "./random";
 import { isRNG, newRNG } from "./rng";
+import { sortNormal } from "./sort";
 import { isNumber, isTable } from "./types";
 import { assertDefined, eRange } from "./utils";
 
@@ -359,7 +360,7 @@ function addCombinations<T>(
  * Helper function to get the duplicate elements in an array. Only one element for each value will
  * be returned. The elements will be sorted before they are returned.
  */
-export function getArrayDuplicateElements<T>(
+export function getArrayDuplicateElements<T extends number | string>(
   array: readonly T[],
 ): readonly T[] {
   const duplicateElements = new Set<T>();
@@ -373,7 +374,7 @@ export function getArrayDuplicateElements<T>(
   }
 
   const values = [...duplicateElements];
-  return values.sort();
+  return values.sort(sortNormal);
 }
 
 /**

package/src/functions/enums.ts

@@ -1,5 +1,6 @@
 import { ReadonlySet } from "../types/ReadonlySet";
 import { getRandomArrayElement } from "./array";
+import { sortNormal } from "./sort";
 import { isNumber, isString } from "./types";
 import { assertDefined, iRange } from "./utils";
 
@@ -151,11 +152,11 @@ export function getHighestEnumValue<T extends TranspiledEnum>(
   transpiledEnum: T,
 ): T[keyof T] {
   const enumValues = getEnumValues(transpiledEnum);
-
-  const lastElement = enumValues.at(-1);
+  const sortedValues = enumValues.toSorted(sortNormal);
+  const lastElement = sortedValues.at(-1);
   assertDefined(
     lastElement,
-    "Failed to get the last value from an enum since the enum was empty.",
+    "Failed to get the highest value from an enum since the enum was empty.",
   );
 
   return lastElement;
@@ -173,11 +174,11 @@ export function getLowestEnumValue<T extends TranspiledEnum>(
   transpiledEnum: T,
 ): T[keyof T] {
   const enumValues = getEnumValues(transpiledEnum);
-
-  const firstElement = enumValues[0];
+  const sortedValues = enumValues.toSorted(sortNormal);
+  const firstElement = sortedValues[0];
   assertDefined(
     firstElement,
-    "Failed to get the first value from an enum since the enum was empty.",
+    "Failed to get the lowest value from an enum since the enum was empty.",
   );
 
   return firstElement;

package/src/functions/logMisc.ts

@@ -38,6 +38,7 @@ import { getPlayerHealth } from "./playerHealth";
 import { getPlayerName } from "./players";
 import { getRoomData, getRoomGridIndex, getRoomListIndex } from "./roomData";
 import { combineSets, getSortedSetValues } from "./set";
+import { sortNormal } from "./sort";
 import { iterateTableInOrder } from "./table";
 import { getTrinketName } from "./trinkets";
 import { isDefaultMap, isTSTLMap, isTSTLSet } from "./tstlClass";
@@ -257,7 +258,7 @@ export function logLevelStateFlags(this: void): void {
  */
 export function logMap(
   this: void,
-  map: ReadonlyMap<AnyNotNil, unknown>,
+  map: ReadonlyMap<number | string, unknown>,
   name?: string,
 ): void {
   if (!isTSTLMap(map) && !isDefaultMap(map)) {
@@ -269,11 +270,10 @@ export function logMap(
   log(`Logging a TSTL map${suffix}:`);
 
   const mapKeys = [...map.keys()];
-  mapKeys.sort();
+  mapKeys.sort(sortNormal);
 
   for (const key of mapKeys) {
     const value = map.get(key);
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
     log(`  ${key} --> ${value}`);
   }
 
@@ -405,7 +405,7 @@ export function logSeedEffects(this: void): void {
  */
 export function logSet(
   this: void,
-  set: ReadonlySet<AnyNotNil>,
+  set: ReadonlySet<number | string>,
   name?: string,
 ): void {
   if (!isTSTLSet(set)) {
@@ -418,7 +418,6 @@ export function logSet(
 
   const setValues = getSortedSetValues(set);
   for (const value of setValues) {
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
     log(`  Value: ${value}`);
   }
 
@@ -510,7 +509,7 @@ export function logTableDifferences<K extends AnyNotNil, V>(
 
   const keysSet = combineSets(table1KeysSet, table2KeysSet);
   const keys = [...keysSet.values()];
-  keys.sort();
+  keys.sort(); // eslint-disable-line @typescript-eslint/require-array-sort-compare
 
   for (const key of keys) {
     const value1 = table1.get(key);

package/src/functions/set.ts

@@ -1,5 +1,6 @@
 import { ReadonlySet } from "../types/ReadonlySet";
 import { getArrayCombinations, getRandomArrayElement, sumArray } from "./array";
+import { sortNormal } from "./sort";
 import { isPrimitive } from "./types";
 
 /**
@@ -78,7 +79,7 @@ export function deleteSetsFromSet<T>(
  *                  a random seed.
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
-export function getRandomSetElement<T>(
+export function getRandomSetElement<T extends number | string>(
   set: ReadonlySet<T>,
   seedOrRNG: Seed | RNG | undefined,
   exceptions: readonly T[] = [],
@@ -106,7 +107,7 @@ export function getRandomSetElement<T>(
  * @param set The set to get the combinations of.
  * @param includeEmptyArray Whether to include an empty array in the combinations.
  */
-export function getSetCombinations<T>(
+export function getSetCombinations<T extends number | string>(
   set: ReadonlySet<T>,
   includeEmptyArray: boolean,
 ): ReadonlyArray<ReadonlySet<T>> {
@@ -123,7 +124,9 @@ export function getSetCombinations<T>(
  * the contents is important.
  */
 // eslint-disable-next-line isaacscript/no-mutable-return
-export function getSortedSetValues<T>(set: ReadonlySet<T>): T[] {
+export function getSortedSetValues<T extends number | string>(
+  set: ReadonlySet<T>,
+): T[] {
   const values = [...set];
 
   // Check for problematic types in order to throw a helpful error message.
@@ -137,7 +140,7 @@ export function getSortedSetValues<T>(set: ReadonlySet<T>): T[] {
     }
   }
 
-  values.sort();
+  values.sort(sortNormal);
 
   return values;
 }

package/src/functions/sort.ts

@@ -1,6 +1,6 @@
 import { isNumber, isString, isTable } from "./types";
 
-function sortNormal(a: unknown, b: unknown): -1 | 0 | 1 {
+export function sortNormal(a: unknown, b: unknown): -1 | 0 | 1 {
   if (!isNumber(a) && !isString(a)) {
     error(
       `Failed to normal sort since the first value was not a number or string and was instead: ${type(
@@ -79,7 +79,7 @@ export function sortObjectArrayByKey(key: string) {
  *
  * ```ts
  * const myArray = [[1, 2], [2, 3], [3, 4]];
- * myArray.sort(twoDimensionalSort);
+ * myArray.sort(sortTwoDimensionalArray);
  * ```
  *
  * This function also properly handles when the array elements are strings or numbers (instead of

package/src/functions/table.ts

@@ -186,7 +186,7 @@ export function iterateTableInOrder<K extends AnyNotNil, V>(
     return;
   }
 
-  keys.sort();
+  keys.sort(); // eslint-disable-line @typescript-eslint/require-array-sort-compare
   for (const key of keys) {
     const keyIndex = key as unknown as K;
     const value = luaMap.get(keyIndex);

package/src/functions/types.ts

@@ -171,12 +171,12 @@ export function asTrinketType(num: int): TrinketType {
 }
 
 export function isBoolean(variable: unknown): variable is boolean {
-  return type(variable) === "boolean";
+  return typeof variable === "boolean";
 }
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export function isFunction(variable: unknown): variable is Function {
-  return type(variable) === "function";
+  return typeof variable === "function";
 }
 
 export function isInteger(variable: unknown): variable is int {
@@ -188,14 +188,14 @@ export function isInteger(variable: unknown): variable is int {
 }
 
 export function isNumber(variable: unknown): variable is number {
-  return type(variable) === "number";
+  return typeof variable === "number";
 }
 
 /** Helper function to detect if a variable is a boolean, number, or string. */
 export function isPrimitive(
   variable: unknown,
 ): variable is boolean | number | string {
-  const variableType = type(variable);
+  const variableType = typeof variable;
   return (
     variableType === "boolean" ||
     variableType === "number" ||
@@ -204,16 +204,18 @@ export function isPrimitive(
 }
 
 export function isString(variable: unknown): variable is string {
-  return type(variable) === "string";
+  return typeof variable === "string";
 }
 
 export function isTable(
   variable: unknown,
 ): variable is LuaMap<AnyNotNil, unknown> {
+  // We cannot use `typeof` here since "table" is not a JavaScript type.
   return type(variable) === "table";
 }
 
 export function isUserdata(variable: unknown): variable is LuaUserdata {
+  // We cannot use `typeof` here since "userdata" is not a JavaScript type.
   return type(variable) === "userdata";
 }