isaacscript-common 81.0.1 → 81.0.3

package/src/functions/jsonRoom.ts

@@ -88,7 +88,7 @@ export function getJSONRoomDoorSlotFlags(
  *                room.)
  */
 export function getJSONRoomOfVariant(
-  jsonRooms: JSONRoom[] | readonly JSONRoom[],
+  jsonRooms: readonly JSONRoom[],
   variant: int,
 ): JSONRoom | undefined {
   const jsonRoomsOfVariant = jsonRooms.filter((jsonRoom) => {
@@ -127,7 +127,7 @@ export function getJSONRoomOfVariant(
  * @param subType The sub-type to match.
  */
 export function getJSONRoomsOfSubType(
-  jsonRooms: JSONRoom[] | readonly JSONRoom[],
+  jsonRooms: readonly JSONRoom[],
   subType: int,
 ): readonly JSONRoom[] {
   return jsonRooms.filter((jsonRoom) => {
@@ -209,7 +209,7 @@ export function getRandomJSONEntity(
  *                what the function is doing. Default is false.
  */
 export function getRandomJSONRoom(
-  jsonRooms: JSONRoom[],
+  jsonRooms: readonly JSONRoom[],
   seedOrRNG: Seed | RNG | undefined,
   verbose = false,
 ): JSONRoom {
@@ -232,7 +232,9 @@ export function getRandomJSONRoom(
   return randomJSONRoom;
 }
 
-function getTotalWeightOfJSONObject(jsonOjectArray: JSONObject[]): float {
+function getTotalWeightOfJSONObject(
+  jsonOjectArray: readonly JSONObject[],
+): float {
   const weights = jsonOjectArray.map((jsonObject) => {
     const weightString = jsonObject.$.weight;
     const weight = tonumber(weightString);
@@ -248,7 +250,7 @@ function getTotalWeightOfJSONObject(jsonOjectArray: JSONObject[]): float {
 }
 
 function getJSONObjectWithChosenWeight<T extends JSONObject>(
-  jsonOjectArray: T[],
+  jsonOjectArray: readonly T[],
   chosenWeight: float,
 ): T | undefined {
   let weightAccumulator = 0;

package/src/functions/logMisc.ts

@@ -49,7 +49,7 @@ import { vectorToString } from "./vector";
  */
 export function logArray<T>(
   this: void,
-  array: T[] | readonly T[],
+  array: readonly T[],
   name?: string,
 ): void {
   // We do not assume the given array has contiguous values in order to be more permissive about the
@@ -74,7 +74,7 @@ export function logArray<T>(
  */
 export function logCollectibleTypes(
   this: void,
-  collectibleTypes: CollectibleType[] | readonly CollectibleType[],
+  collectibleTypes: readonly CollectibleType[],
   name?: string,
 ): void {
   if (name === undefined) {
@@ -192,7 +192,7 @@ export function logGameStateFlags(this: void): void {
  */
 export function logItemPoolTypes(
   this: void,
-  itemPoolTypes: ItemPoolType[] | readonly ItemPoolType[],
+  itemPoolTypes: readonly ItemPoolType[],
   name?: string,
 ): void {
   if (name === undefined) {
@@ -254,7 +254,7 @@ export function logLevelStateFlags(this: void): void {
  */
 export function logMap(
   this: void,
-  map: Map<AnyNotNil, unknown> | ReadonlyMap<AnyNotNil, unknown>,
+  map: ReadonlyMap<AnyNotNil, unknown>,
   name?: string,
 ): void {
   if (!isTSTLMap(map) && !isDefaultMap(map)) {
@@ -398,7 +398,7 @@ export function logSeedEffects(this: void): void {
  */
 export function logSet(
   this: void,
-  set: Set<AnyNotNil> | ReadonlySet<AnyNotNil>,
+  set: ReadonlySet<AnyNotNil>,
   name?: string,
 ): void {
   if (!isTSTLSet(set)) {

package/src/functions/map.ts

@@ -2,11 +2,10 @@ import type { DefaultMap } from "../classes/DefaultMap";
 import { sumArray } from "./array";
 
 /** Helper function to copy a map. (You can also use a Map constructor to accomplish this task.) */
-export function copyMap<K, V>(
-  oldMap: Map<K, V> | ReadonlyMap<K, V>,
-): Map<K, V> {
+// eslint-disable-next-line isaacscript/no-mutable-return
+export function copyMap<K, V>(oldMap: ReadonlyMap<K, V>): Map<K, V> {
   const newMap = new Map<K, V>();
-  for (const [key, value] of oldMap.entries()) {
+  for (const [key, value] of oldMap) {
     newMap.set(key, value);
   }
 
@@ -62,11 +61,9 @@ export function defaultMapSetHash<V>(
  * ]);
  * ```
  */
-export function getReversedMap<K, V>(map: Map<K, V>): Map<V, K>;
-export function getReversedMap<K, V>(map: ReadonlyMap<K, V>): ReadonlyMap<V, K>;
 export function getReversedMap<K, V>(
-  map: Map<K, V> | ReadonlyMap<K, V>,
-): Map<V, K> {
+  map: ReadonlyMap<K, V>,
+): ReadonlyMap<V, K> {
   const reverseMap = new Map<V, K>();
 
   for (const [key, value] of map) {
@@ -102,6 +99,7 @@ export function mapSetHash<V>(
  *
  * Also see the `objectToReadonlyMap` function.
  */
+// eslint-disable-next-line isaacscript/no-mutable-return
 export function objectToMap<K extends string | number | symbol, V>(
   object: Record<K, V>,
 ): Map<K, V> {
@@ -134,9 +132,7 @@ export function objectToReadonlyMap<K extends string | number | symbol, V>(
 }
 
 /** Helper function to sum every value in a map together. */
-export function sumMap(
-  map: Map<unknown, number> | ReadonlyMap<unknown, number>,
-): number {
+export function sumMap(map: ReadonlyMap<unknown, number>): number {
   const values = [...map.values()];
   return sumArray(values);
 }

package/src/functions/minimap.ts

@@ -66,7 +66,7 @@ export function clearRoomDisplayFlags(roomGridIndex: int): void {
  */
 export function getFloorDisplayFlags(
   minimapAPI = true,
-): Map<int, BitFlags<DisplayFlag>> {
+): ReadonlyMap<int, BitFlags<DisplayFlag>> {
   const displayFlagsMap = new Map<int, BitFlags<DisplayFlag>>();
 
   for (const roomDescriptor of getRoomsInsideGrid()) {

package/src/functions/newArray.ts

@@ -16,7 +16,7 @@ import { repeat } from "./utils";
  * const arrayWithArrays = newArray([0], 20); // Has 20 elements of an array with a 0 in it.
  * ```
  */
-// eslint-disable-next-line isaacscript/no-mutable-array-return
+// eslint-disable-next-line isaacscript/no-mutable-return
 export function newArray<T>(defaultValue: T, size: int): T[] {
   const array: T[] = [];
   repeat(size, () => {

package/src/functions/npcDataStructures.ts

@@ -130,9 +130,9 @@ export function mapSetNPC<V>(
  * Helper function to make using sets with an type of `PtrHash` easier. Use this instead of the
  * `Set.add` method if you have a set of this type.
  */
-export function setAddNPC(set: Set<PtrHash>, npc: EntityNPC): Set<PtrHash> {
+export function setAddNPC(set: Set<PtrHash>, npc: EntityNPC): void {
   const ptrHash = GetPtrHash(npc);
-  return set.add(ptrHash);
+  set.add(ptrHash);
 }
 
 /**

package/src/functions/playerDataStructures.ts

@@ -134,9 +134,9 @@ export function mapSetPlayer<V>(
 export function setAddPlayer(
   set: Set<PlayerIndex>,
   player: EntityPlayer,
-): Set<PlayerIndex> {
+): void {
   const playerIndex = getPlayerIndex(player);
-  return set.add(playerIndex);
+  set.add(playerIndex);
 }
 
 /**

package/src/functions/pocketItems.ts

@@ -173,8 +173,8 @@ export function isFirstSlotPocketActiveItem(player: EntityPlayer): boolean {
 
 /** Helper function to see if two sets of pocket item descriptions are identical. */
 export function pocketItemsEquals(
-  pocketItems1: PocketItemDescription[] | readonly PocketItemDescription[],
-  pocketItems2: PocketItemDescription[] | readonly PocketItemDescription[],
+  pocketItems1: readonly PocketItemDescription[],
+  pocketItems2: readonly PocketItemDescription[],
 ): boolean {
   if (pocketItems1.length !== pocketItems2.length) {
     return false;

package/src/functions/positionVelocity.ts

@@ -12,7 +12,7 @@ import { getPlayerCloserThan } from "./players";
 const MAX_FIND_FREE_POSITION_ATTEMPTS = 100;
 
 export function anyEntityCloserThan(
-  entities: Entity[] | readonly Entity[],
+  entities: readonly Entity[],
   position: Vector,
   distance: int,
 ): boolean {
@@ -110,8 +110,8 @@ export function findFreePosition(
  *                 multiple times.
  */
 export function getEntityPositions(
-  entities?: Entity[] | readonly Entity[],
-): Map<PtrHash, Vector> {
+  entities?: readonly Entity[],
+): ReadonlyMap<PtrHash, Vector> {
   if (entities === undefined) {
     entities = getEntities();
   }
@@ -135,8 +135,8 @@ export function getEntityPositions(
  *                 multiple times.
  */
 export function getEntityVelocities(
-  entities?: Entity[] | readonly Entity[],
-): Map<PtrHash, Vector> {
+  entities?: readonly Entity[],
+): ReadonlyMap<PtrHash, Vector> {
   if (entities === undefined) {
     entities = getEntities();
   }
@@ -164,8 +164,8 @@ export function getEntityVelocities(
  *                 multiple times.
  */
 export function setEntityPositions(
-  entityPositions: Map<PtrHash, Vector>,
-  entities?: Entity[] | readonly Entity[],
+  entityPositions: ReadonlyMap<PtrHash, Vector>,
+  entities?: readonly Entity[],
 ): void {
   if (entities === undefined) {
     entities = getEntities();
@@ -194,8 +194,8 @@ export function setEntityPositions(
  *                 multiple times.
  */
 export function setEntityVelocities(
-  entityVelocities: Map<PtrHash, Vector>,
-  entities?: Entity[] | readonly Entity[],
+  entityVelocities: ReadonlyMap<PtrHash, Vector>,
+  entities?: readonly Entity[],
 ): void {
   if (entities === undefined) {
     entities = getEntities();

package/src/functions/random.ts

@@ -77,7 +77,7 @@ export function getRandomInt(
   min: int,
   max: int,
   seedOrRNG: Seed | RNG | undefined,
-  exceptions: int[] | readonly int[] = [],
+  exceptions: readonly int[] = [],
 ): int {
   const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
 

package/src/functions/roomData.ts

@@ -13,7 +13,9 @@ import { hasFlag } from "./flag";
  * Helper function to get the set of allowed door slots for the room at the supplied grid index.
  * This corresponds to the doors that are enabled in the STB/XML file for the room.
  */
-export function getRoomAllowedDoors(roomGridIndex?: int): Set<DoorSlot> {
+export function getRoomAllowedDoors(
+  roomGridIndex?: int,
+): ReadonlySet<DoorSlot> {
   const allowedDoors = new Set<DoorSlot>();
 
   const roomData = getRoomData(roomGridIndex);

package/src/functions/rooms.ts

@@ -545,7 +545,7 @@ export function is2x1Room(roomData: RoomConfig): boolean {
  * @allowEmptyVariadic
  */
 export function isAllRoomsClear(
-  onlyCheckRoomTypes?: RoomType[] | readonly RoomType[],
+  onlyCheckRoomTypes?: readonly RoomType[],
   includeSecretRoom = false,
   includeSuperSecretRoom = false,
   includeUltraSecretRoom = false,

package/src/functions/set.ts

@@ -10,7 +10,7 @@ import { isPrimitive } from "./types";
  */
 export function addSetsToSet<T>(
   mainSet: Set<T>,
-  ...setsToAdd: Array<Set<T> | ReadonlySet<T>>
+  ...setsToAdd: ReadonlyArray<ReadonlySet<T>>
 ): void {
   for (const set of setsToAdd) {
     for (const value of set) {
@@ -24,9 +24,8 @@ export function addSetsToSet<T>(
  *
  * This function is variadic, meaning that you can specify N sets.
  */
-export function combineSets<T>(
-  ...sets: Array<Set<T> | ReadonlySet<T>>
-): Set<T> {
+// eslint-disable-next-line isaacscript/no-mutable-return
+export function combineSets<T>(...sets: ReadonlyArray<ReadonlySet<T>>): Set<T> {
   const newSet = new Set<T>();
   for (const set of sets) {
     for (const value of set) {
@@ -38,7 +37,8 @@ export function combineSets<T>(
 }
 
 /** Helper function to copy a set. (You can also use a Set constructor to accomplish this task.) */
-export function copySet<T>(oldSet: Set<T> | ReadonlySet<T>): Set<T> {
+// eslint-disable-next-line isaacscript/no-mutable-return
+export function copySet<T>(oldSet: ReadonlySet<T>): Set<T> {
   const newSet = new Set<T>();
   for (const value of oldSet) {
     newSet.add(value);
@@ -55,7 +55,7 @@ export function copySet<T>(oldSet: Set<T> | ReadonlySet<T>): Set<T> {
  */
 export function deleteSetsFromSet<T>(
   mainSet: Set<T>,
-  ...setsToRemove: Array<Set<T> | ReadonlySet<T>>
+  ...setsToRemove: ReadonlyArray<ReadonlySet<T>>
 ): void {
   for (const set of setsToRemove) {
     for (const value of set) {
@@ -77,9 +77,9 @@ export function deleteSetsFromSet<T>(
  * @param exceptions Optional. An array of elements to skip over if selected.
  */
 export function getRandomSetElement<T>(
-  set: Set<T> | ReadonlySet<T>,
+  set: ReadonlySet<T>,
   seedOrRNG: Seed | RNG | undefined,
-  exceptions: T[] | readonly T[] = [],
+  exceptions: readonly T[] = [],
 ): T {
   const array = getSortedSetValues(set);
   return getRandomArrayElement(array, seedOrRNG, exceptions);
@@ -105,7 +105,7 @@ export function getRandomSetElement<T>(
  * @param includeEmptyArray Whether to include an empty array in the combinations.
  */
 export function getSetCombinations<T>(
-  set: Set<T> | ReadonlySet<T>,
+  set: ReadonlySet<T>,
   includeEmptyArray: boolean,
 ): ReadonlyArray<ReadonlySet<T>> {
   const values = getSortedSetValues(set);
@@ -120,8 +120,8 @@ export function getSetCombinations<T>(
  * Normally, set values are returned in insertion order, so use this function when the ordering of
  * the contents is important.
  */
-// eslint-disable-next-line isaacscript/no-mutable-array-return
-export function getSortedSetValues<T>(set: Set<T> | ReadonlySet<T>): T[] {
+// eslint-disable-next-line isaacscript/no-mutable-return
+export function getSortedSetValues<T>(set: ReadonlySet<T>): T[] {
   const values = [...set];
 
   // Check for problematic types in order to throw a helpful error message.
@@ -162,6 +162,7 @@ export function objectKeysToReadonlySet<K extends string | number | symbol, V>(
  *
  * Also see the `objectKeysToReadonlySet` function.
  */
+// eslint-disable-next-line isaacscript/no-mutable-return
 export function objectKeysToSet<K extends string | number | symbol, V>(
   object: Record<K, V>,
 ): Set<K> {
@@ -197,6 +198,7 @@ export function objectValuesToReadonlySet<
  *
  * Also see the `objectValuesToReadonlySet` function.
  */
+// eslint-disable-next-line isaacscript/no-mutable-return
 export function objectValuesToSet<K extends string | number | symbol, V>(
   object: Record<K, V>,
 ): Set<V> {
@@ -215,7 +217,7 @@ export function objectValuesToSet<K extends string | number | symbol, V>(
  *
  * This function is variadic, meaning that you can pass as many things as you want to add.
  */
-export function setAdd<T>(set: Set<T>, ...elements: T[]): void {
+export function setAdd<T>(set: Set<T>, ...elements: readonly T[]): void {
   for (const element of elements) {
     set.add(element);
   }
@@ -229,14 +231,14 @@ export function setAdd<T>(set: Set<T>, ...elements: T[]): void {
  * will return true if one or more elements are found.
  */
 export function setHas<T>(
-  set: Set<T> | ReadonlySet<T>,
-  ...elements: T[]
+  set: ReadonlySet<T>,
+  ...elements: readonly T[]
 ): boolean {
   return elements.some((element) => set.has(element));
 }
 
 /** Helper function to sum every value in a set together. */
-export function sumSet(set: Set<number> | ReadonlySet<number>): number {
+export function sumSet(set: ReadonlySet<number>): number {
   const values = [...set];
   return sumArray(values);
 }

package/src/functions/sort.ts

@@ -146,7 +146,7 @@ export function sortTwoDimensionalArray<T>(a: T[], b: T[]): -1 | 0 | 1 {
  *
  * Under the hood, this uses the merge sort algorithm.
  */
-// eslint-disable-next-line isaacscript/no-mutable-array-return
+// eslint-disable-next-line isaacscript/no-mutable-return
 export function stableSort<T>(
   array: T[],
   sortFunc: (a: T, b: T) => -1 | 0 | 1 = sortNormal,

package/src/functions/string.ts

@@ -120,7 +120,7 @@ export function getObjectPartialMatch<T>(
  */
 export function getPartialMatch(
   searchText: string,
-  array: string[] | readonly string[],
+  array: readonly string[],
 ): string | undefined {
   const sortedArray = array.toSorted();
 

package/src/functions/table.ts

@@ -14,7 +14,7 @@ export function clearTable(luaMap: LuaMap<AnyNotNil, unknown>): void {
 /** Helper function to copy specific values from a userdata object (e.g. `Vector`) to a table. */
 export function copyUserdataValuesToTable(
   object: unknown,
-  keys: string[] | readonly string[],
+  keys: readonly string[],
   luaMap: LuaMap<string, unknown>,
 ): void {
   if (!isUserdata(object)) {

package/src/functions/transformations.ts

@@ -34,7 +34,7 @@ const TRANSFORMATIONS_THAT_GRANT_FLYING = new ReadonlySet<PlayerForm>([
 /** Returns a set of the player's current transformations. */
 export function getPlayerTransformations(
   player: EntityPlayer,
-): Set<PlayerForm> {
+): ReadonlySet<PlayerForm> {
   const transformations = new Set<PlayerForm>();
   for (const playerForm of PLAYER_FORM_VALUES) {
     if (player.HasPlayerForm(playerForm)) {
@@ -65,7 +65,7 @@ export function getTransformationName(playerForm: PlayerForm): string {
  */
 export function getTransformationsForCollectibleType(
   collectibleType: CollectibleType,
-): Set<PlayerForm> {
+): ReadonlySet<PlayerForm> {
   const itemConfigTags = getCollectibleTags(collectibleType);
 
   const transformationSet = new Set<PlayerForm>();

package/src/objects/itemPoolTypeToCollectibleTypesSet.ts

@@ -8,10 +8,10 @@ import { asCollectibleType, parseIntSafe } from "../functions/types";
 import { ITEM_POOL_TYPE_TO_ITEM_POOL_NAME } from "../maps/itemPoolTypeToItemPoolName";
 
 export const ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET: Readonly<
-  Record<ItemPoolType, Set<CollectibleType>>
+  Record<ItemPoolType, ReadonlySet<CollectibleType>>
 > = (() => {
   const itemPoolTypeToCollectibleTypes: Partial<
-    Record<ItemPoolType, Set<CollectibleType>>
+    Record<ItemPoolType, ReadonlySet<CollectibleType>>
   > = {};
 
   for (const itemPoolType of ITEM_POOL_TYPE_VALUES) {
@@ -39,7 +39,7 @@ export const ITEM_POOL_TYPE_TO_COLLECTIBLE_TYPES_SET: Readonly<
 
   return itemPoolTypeToCollectibleTypes as Record<
     ItemPoolType,
-    Set<CollectibleType>
+    ReadonlySet<CollectibleType>
   >;
 })();
 

package/src/types/TupleWithLengthBetween.ts

@@ -10,7 +10,7 @@ export type TupleWithLengthBetween<
   T,
   MinLength extends number,
   MaxLength extends number,
-> = (T[] | readonly T[]) & {
+> = readonly T[] & {
   length: IRange<MinLength, MaxLength>;
 };
 

package/src/types/TupleWithMaxLength.ts

@@ -5,10 +5,7 @@ import type { IRange } from "./IRange";
  *
  * For example, `TupleWithMaxLength<string, 3>` will allow string tuples of size 0, 1, 2, or 3.
  */
-export type TupleWithMaxLength<T, MaxLength extends number> = (
-  | T[]
-  | readonly T[]
-) & {
+export type TupleWithMaxLength<T, MaxLength extends number> = readonly T[] & {
   length: IRange<0, MaxLength>;
 };