isaacscript-common 80.1.0 → 80.2.1

package/src/functions/nextStage.ts

@@ -13,7 +13,6 @@ import {
   calculateStageTypeRepentance,
   onRepentanceStage,
 } from "./stage";
-import { asNumber } from "./types";
 
 /**
  * Helper function to get the stage that a trapdoor or heaven door would take the player to, based
@@ -35,7 +34,7 @@ export function getNextStage(): LevelStage {
 
   // First, handle the special case of being on the backwards path.
   if (backwardsPath) {
-    const nextStage = asNumber(stage) - 1;
+    const nextStage = stage - 1;
     return nextStage === 0 ? LevelStage.HOME : nextStage;
   }
 
@@ -55,7 +54,7 @@ export function getNextStage(): LevelStage {
     case GridRoom.SECRET_EXIT: {
       if (repentanceStage) {
         // e.g. From Downpour 2 to Mines 1, etc.
-        return asNumber(stage) + 1;
+        return stage + 1;
       }
 
       if (
@@ -114,7 +113,7 @@ export function getNextStage(): LevelStage {
   }
 
   // By default, go to the next floor.
-  return asNumber(stage) + 1;
+  return stage + 1;
 }
 
 /**
@@ -146,7 +145,7 @@ export function getNextStageType(upwards = false): StageType {
   }
 
   // Second, handle the special case of being in a specific off-grid room.
-  if (roomGridIndex === asNumber(GridRoom.SECRET_EXIT)) {
+  if (roomGridIndex === GridRoom.SECRET_EXIT) {
     return calculateStageTypeRepentance(nextStage);
   }
 

package/src/functions/npcs.ts

@@ -19,7 +19,6 @@ import {
 import { EGGY_STATE_FRAME_OF_FINAL_SPIDER } from "../core/constants";
 import { ReadonlySet } from "../types/ReadonlySet";
 import { getNPCs } from "./entitiesSpecific";
-import { asNumber } from "./types";
 
 /**
  * Used to filter out certain NPCs when determining of an NPC is "alive" and/or should keep the
@@ -133,7 +132,7 @@ export function isDaddyLongLegsChildStompEntity(npc: EntityNPC): boolean {
 export function isDyingDump(npc: EntityNPC): boolean {
   return (
     npc.Type === EntityType.DUMP &&
-    npc.Variant === asNumber(DumpVariant.DUMP) &&
+    npc.Variant === DumpVariant.DUMP &&
     npc.State === NPCState.SPECIAL
   );
 }
@@ -146,7 +145,7 @@ export function isDyingDump(npc: EntityNPC): boolean {
 export function isDyingEggyWithNoSpidersLeft(npc: EntityNPC): boolean {
   return (
     npc.Type === EntityType.HOPPER &&
-    npc.Variant === asNumber(HopperVariant.EGGY) &&
+    npc.Variant === HopperVariant.EGGY &&
     npc.State === NPCState.SUICIDE &&
     npc.StateFrame >= EGGY_STATE_FRAME_OF_FINAL_SPIDER
   );
@@ -161,7 +160,7 @@ export function isDyingEggyWithNoSpidersLeft(npc: EntityNPC): boolean {
 export function isRaglingDeathPatch(npc: EntityNPC): boolean {
   return (
     npc.Type === EntityType.RAGLING &&
-    npc.Variant === asNumber(RaglingVariant.RAG_MANS_RAGLING) &&
+    npc.Variant === RaglingVariant.RAG_MANS_RAGLING &&
     // They go to `STATE_SPECIAL` when they are patches on the ground.
     npc.State === NPCState.SPECIAL
   );

package/src/functions/pills.ts

@@ -64,7 +64,7 @@ export function getFalsePHDPillEffect(pillEffect: PillEffect): PillEffect {
  * corresponds to the horse pill color for blue/blue.
  */
 export function getHorsePillColor(pillColor: PillColor): PillColor {
-  return asNumber(pillColor) + HORSE_PILL_ADJUSTMENT;
+  return pillColor + HORSE_PILL_ADJUSTMENT;
 }
 
 /** Helper function to get an array with every non-gold horse pill color. */
@@ -80,11 +80,9 @@ export function getHorsePillColors(): readonly PillColor[] {
  * If called with a non-horse pill color, this function will return back the same color.
  */
 export function getNormalPillColorFromHorse(pillColor: PillColor): PillColor {
-  const normalPillColor = asPillColor(
-    asNumber(pillColor) - HORSE_PILL_ADJUSTMENT,
-  );
-
-  return normalPillColor > PillColor.NULL ? normalPillColor : pillColor;
+  return isHorsePill(pillColor)
+    ? asPillColor(pillColor - HORSE_PILL_ADJUSTMENT)
+    : pillColor;
 }
 
 /** Helper function to get an array with every non-gold and non-horse pill color. */

package/src/functions/pocketItems.ts

@@ -10,7 +10,6 @@ import { POCKET_ITEM_SLOT_VALUES } from "../arrays/cachedEnumValues";
 import { PocketItemType } from "../enums/PocketItemType";
 import type { PocketItemDescription } from "../interfaces/PocketItemDescription";
 import { isCharacter } from "./players";
-import { asNumber } from "./types";
 
 /**
  * Helper function to get the `PocketItemSlot` that the player's pocket active collectible item is
@@ -129,7 +128,7 @@ export function getPocketItems(player: EntityPlayer): PocketItemDescription[] {
       });
     }
 
-    if (asNumber(slot) + 1 === maxPocketItems) {
+    if (slot + 1 === maxPocketItems) {
       break;
     }
   }

package/src/functions/rooms.ts

@@ -48,7 +48,6 @@ import {
 import { is2x1RoomShape, isBigRoomShape, isLRoomShape } from "./roomShape";
 import { reloadRoom } from "./roomTransition";
 import { getGotoCommand } from "./stage";
-import { asNumber } from "./types";
 import { assertDefined, iRange } from "./utils";
 
 const SECRET_ROOM_TYPES = new ReadonlySet([
@@ -599,7 +598,7 @@ export function isAllRoomsClear(
 export function isAngelShop(roomData: RoomConfig): boolean {
   return (
     roomData.Type === RoomType.ANGEL &&
-    roomData.Subtype === asNumber(AngelRoomSubType.SHOP)
+    roomData.Subtype === AngelRoomSubType.SHOP
   );
 }
 
@@ -614,7 +613,7 @@ export function isAngelShop(roomData: RoomConfig): boolean {
 export function isBeastRoom(roomData: RoomConfig): boolean {
   return (
     roomData.Type === RoomType.DUNGEON &&
-    roomData.Subtype === asNumber(DungeonSubType.BEAST_ROOM)
+    roomData.Subtype === DungeonSubType.BEAST_ROOM
   );
 }
 
@@ -634,7 +633,7 @@ export function isBossRoomOf(roomData: RoomConfig, bossID: BossID): boolean {
   return (
     roomData.Type === RoomType.BOSS &&
     roomData.StageID === StageID.SPECIAL_ROOMS &&
-    roomData.Subtype === asNumber(bossID)
+    roomData.Subtype === bossID
   );
 }
 
@@ -646,7 +645,7 @@ export function isBossRoomOf(roomData: RoomConfig, bossID: BossID): boolean {
 export function isCrawlSpace(roomData: RoomConfig): boolean {
   return (
     roomData.Type === RoomType.DUNGEON &&
-    roomData.Subtype === asNumber(DungeonSubType.NORMAL)
+    roomData.Subtype === DungeonSubType.NORMAL
   );
 }
 
@@ -668,9 +667,8 @@ export function isCrawlSpaceWithBlackMarketEntrance(
 export function isDeathCertificateArea(roomData: RoomConfig): boolean {
   return (
     roomData.StageID === StageID.HOME &&
-    (roomData.Subtype ===
-      asNumber(HomeRoomSubType.DEATH_CERTIFICATE_ENTRANCE) ||
-      roomData.Subtype === asNumber(HomeRoomSubType.DEATH_CERTIFICATE_ITEMS))
+    (roomData.Subtype === HomeRoomSubType.DEATH_CERTIFICATE_ENTRANCE ||
+      roomData.Subtype === HomeRoomSubType.DEATH_CERTIFICATE_ITEMS)
   );
 }
 
@@ -704,7 +702,7 @@ export function isDogmaRoom(roomData: RoomConfig): boolean {
     roomData.StageID === StageID.HOME &&
     roomData.Type === RoomType.DEFAULT &&
     roomData.Variant === 1000 &&
-    roomData.Subtype === asNumber(HomeRoomSubType.LIVING_ROOM)
+    roomData.Subtype === HomeRoomSubType.LIVING_ROOM
   );
 }
 
@@ -729,7 +727,7 @@ export function isDoubleTrouble(roomData: RoomConfig): boolean {
  * Helper function to determine if the index of the provided room is equal to `GridRoom.GENESIS`.
  */
 export function isGenesisRoom(roomGridIndex: int): boolean {
-  return roomGridIndex === asNumber(GridRoom.GENESIS);
+  return roomGridIndex === GridRoom.GENESIS;
 }
 
 /**
@@ -741,8 +739,8 @@ export function isGenesisRoom(roomGridIndex: int): boolean {
 export function isHomeCloset(roomData: RoomConfig): boolean {
   return (
     roomData.StageID === StageID.HOME &&
-    (roomData.Subtype === asNumber(HomeRoomSubType.CLOSET_LEFT) ||
-      roomData.Subtype === asNumber(HomeRoomSubType.CLOSET_RIGHT))
+    (roomData.Subtype === HomeRoomSubType.CLOSET_LEFT ||
+      roomData.Subtype === HomeRoomSubType.CLOSET_RIGHT)
   );
 }
 
@@ -755,7 +753,7 @@ export function isLRoom(roomData: RoomConfig): boolean {
  * Helper function to determine if the index of the provided room is equal to `GridRoom.MEGA_SATAN`.
  */
 export function isMegaSatanRoom(roomGridIndex: int): boolean {
-  return roomGridIndex === asNumber(GridRoom.MEGA_SATAN);
+  return roomGridIndex === GridRoom.MEGA_SATAN;
 }
 
 /**
@@ -782,7 +780,7 @@ export function isMinibossRoomOf(
   return (
     roomData.Type === RoomType.MINI_BOSS &&
     roomData.StageID === StageID.SPECIAL_ROOMS &&
-    roomData.Subtype === asNumber(minibossID)
+    roomData.Subtype === minibossID
   );
 }
 
@@ -795,7 +793,7 @@ export function isMirrorRoom(roomData: RoomConfig): boolean {
     roomData.Type === RoomType.DEFAULT &&
     (roomData.StageID === StageID.DOWNPOUR ||
       roomData.StageID === StageID.DROSS) &&
-    roomData.Subtype === asNumber(DownpourRoomSubType.MIRROR)
+    roomData.Subtype === DownpourRoomSubType.MIRROR
   );
 }
 
@@ -828,7 +826,7 @@ export function isRoomType(
  * floor.
  */
 export function isSecretExit(roomGridIndex: int): boolean {
-  return roomGridIndex === asNumber(GridRoom.SECRET_EXIT);
+  return roomGridIndex === GridRoom.SECRET_EXIT;
 }
 
 /**
@@ -848,7 +846,7 @@ export function isSecretRoomType(roomType: RoomType): boolean {
  * the only way to detect them is by using the grid index.
  */
 export function isSecretShop(roomGridIndex: int): boolean {
-  return roomGridIndex === asNumber(GridRoom.SECRET_SHOP);
+  return roomGridIndex === GridRoom.SECRET_SHOP;
 }
 
 /**

package/src/functions/set.ts

@@ -13,7 +13,7 @@ export function addSetsToSet<T>(
   ...setsToAdd: Array<Set<T> | ReadonlySet<T>>
 ): void {
   for (const set of setsToAdd) {
-    for (const value of set.values()) {
+    for (const value of set) {
       mainSet.add(value);
     }
   }
@@ -29,7 +29,7 @@ export function combineSets<T>(
 ): Set<T> {
   const newSet = new Set<T>();
   for (const set of sets) {
-    for (const value of set.values()) {
+    for (const value of set) {
       newSet.add(value);
     }
   }
@@ -40,7 +40,7 @@ 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> {
   const newSet = new Set<T>();
-  for (const value of oldSet.values()) {
+  for (const value of oldSet) {
     newSet.add(value);
   }
 
@@ -58,7 +58,7 @@ export function deleteSetsFromSet<T>(
   ...setsToRemove: Array<Set<T> | ReadonlySet<T>>
 ): void {
   for (const set of setsToRemove) {
-    for (const value of set.values()) {
+    for (const value of set) {
       mainSet.delete(value);
     }
   }
@@ -117,15 +117,14 @@ export function getSetCombinations<T>(
 /**
  * Helper function to get a sorted array based on the contents of a set.
  *
- * Normally, set values are returned in a random order, so use this function when the ordering of
+ * Normally, set values are returned in insertion order, so use this function when the ordering of
  * the contents is important.
  */
 export function getSortedSetValues<T>(set: Set<T> | ReadonlySet<T>): T[] {
-  const values = set.values();
-  const array = [...values];
+  const values = [...set];
 
   // Check for problematic types in order to throw a helpful error message.
-  const firstElement = array[0];
+  const firstElement = values[0];
   if (firstElement !== undefined) {
     const arrayType = type(firstElement);
     if (!isPrimitive(arrayType)) {
@@ -135,9 +134,78 @@ export function getSortedSetValues<T>(set: Set<T> | ReadonlySet<T>): T[] {
     }
   }
 
-  array.sort();
+  values.sort();
 
-  return array;
+  return values;
+}
+
+/**
+ * Helper function to convert the keys of an object to a read-only set.
+ *
+ * Note that the set values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectKeysToSet` function.
+ */
+export function objectKeysToReadonlySet<K extends string | number | symbol, V>(
+  object: Record<K, V>,
+): ReadonlySet<K> {
+  return objectKeysToSet(object);
+}
+
+/**
+ * Helper function to convert the keys of an object to a set.
+ *
+ * Note that the set values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectKeysToReadonlySet` function.
+ */
+export function objectKeysToSet<K extends string | number | symbol, V>(
+  object: Record<K, V>,
+): Set<K> {
+  const set = new Set<K>();
+
+  for (const key of Object.keys(object)) {
+    set.add(key as K);
+  }
+
+  return set;
+}
+
+/**
+ * Helper function to convert the values of an object to a read-only set.
+ *
+ * Note that the set values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectValuesToSet` function.
+ */
+export function objectValuesToReadonlySet<
+  K extends string | number | symbol,
+  V,
+>(object: Record<K, V>): ReadonlySet<V> {
+  return objectValuesToSet(object);
+}
+
+/**
+ * Helper function to convert the values of an object to a set.
+ *
+ * Note that the set values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectValuesToReadonlySet` function.
+ */
+export function objectValuesToSet<K extends string | number | symbol, V>(
+  object: Record<K, V>,
+): Set<V> {
+  const set = new Set<V>();
+
+  for (const key of Object.values(object)) {
+    set.add(key as V);
+  }
+
+  return set;
 }
 
 /**
@@ -168,6 +236,6 @@ export function setHas<T>(
 
 /** Helper function to sum every value in a set together. */
 export function sumSet(set: Set<number> | ReadonlySet<number>): number {
-  const values = [...set.values()];
+  const values = [...set];
   return sumArray(values);
 }

package/src/functions/stage.ts

@@ -11,7 +11,7 @@ import { ROOM_TYPE_SPECIAL_GOTO_PREFIXES } from "../objects/roomTypeSpecialGotoP
 import { STAGE_TO_STAGE_ID } from "../objects/stageToStageID";
 import { STAGE_TYPE_SUFFIXES } from "../objects/stageTypeSuffixes";
 import { log } from "./log";
-import { asLevelStage, asNumber } from "./types";
+import { asLevelStage } from "./types";
 import { inRange } from "./utils";
 
 /**
@@ -62,7 +62,7 @@ export function calculateStageTypeRepentance(stage: LevelStage): StageType {
   // This algorithm is from Kilburn. We add one because the alt path is offset by 1 relative to the
   // normal path.
   const seeds = game.GetSeeds();
-  const adjustedStage = asLevelStage(asNumber(stage) + 1);
+  const adjustedStage = asLevelStage(stage + 1);
   const stageSeed = seeds.GetStageSeed(adjustedStage);
 
   // Kilburn does not know why he divided the stage seed by 2 first.
@@ -84,7 +84,7 @@ export function getEffectiveStage(): LevelStage {
   const stage = level.GetStage();
 
   if (onRepentanceStage()) {
-    return asNumber(stage) + 1;
+    return stage + 1;
   }
 
   return stage;

package/src/functions/trinkets.ts

@@ -42,7 +42,7 @@ const TRINKET_SPRITE_LAYER = 0;
 export function getGoldenTrinketType(trinketType: TrinketType): TrinketType {
   return isGoldenTrinketType(trinketType)
     ? trinketType
-    : asNumber(trinketType) + GOLDEN_TRINKET_ADJUSTMENT;
+    : trinketType + GOLDEN_TRINKET_ADJUSTMENT;
 }
 
 /**
@@ -88,7 +88,7 @@ export function getMysteriousPaperEffectForFrame(
  */
 export function getNormalTrinketType(trinketType: TrinketType): TrinketType {
   return isGoldenTrinketType(trinketType)
-    ? asNumber(trinketType) - GOLDEN_TRINKET_ADJUSTMENT
+    ? trinketType - GOLDEN_TRINKET_ADJUSTMENT
     : trinketType;
 }
 

package/src/functions/types.ts

@@ -1,3 +1,33 @@
+/**
+ * Consider the following code that uses a number enum:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ * }
+ *
+ * function asMyEnum(num: number): MyEnum {}
+ *
+ * declare const something: unknown;
+ *
+ * const foo = something as MyEnum; // no error
+ * const bar: MyEnum = something; // error
+ * const baz = asMyEnum(something); // error
+ * ```
+ *
+ * Here, using `as` does not give an error because TypeScript allows you to assert a type to a
+ * supertype or a subtype. Thus, using `as` to perform a type assertion is not as safe as using a
+ * variable declaration or a helper function. However, if we use a variable declaration, then the
+ * `isaacscript/strict-enums` rule is triggered, which requires suppressing the lint rule with a `//
+ * eslint-disable-next-line`. Thus, the safest and more concise way to do a type assertion is to use
+ * a helper function.
+ *
+ * This file contains helper functions for various number enums that might require type assertions.
+ * It also contains helper functions for run-time type checks.
+ *
+ * @module
+ */
+
 import type {
   CardType,
   CollectibleType,