isaacscript-common 2.3.0 → 2.3.1

package/src/callbacks/subscriptions/postTearInitVeryLate.ts

@@ -1,32 +0,0 @@
-import { TearVariant } from "isaac-typescript-definitions";
-
-export type PostTearInitVeryLateRegisterParameters = [
-  callback: (tear: EntityTear) => void,
-  tearVariant?: TearVariant,
-];
-
-const subscriptions: PostTearInitVeryLateRegisterParameters[] = [];
-
-/** @internal */
-export function postTearInitVeryLateHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function postTearInitVeryLateRegister(
-  ...args: PostTearInitVeryLateRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function postTearInitVeryLateFire(tear: EntityTear): void {
-  for (const [callback, tearVariant] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (tearVariant !== undefined && tearVariant !== tear.Variant) {
-      continue;
-    }
-
-    callback(tear);
-  }
-}

package/src/callbacks/subscriptions/postTransformation.ts

@@ -1,40 +0,0 @@
-import { PlayerForm } from "isaac-typescript-definitions";
-
-export type PostTransformationRegisterParameters = [
-  callback: (
-    player: EntityPlayer,
-    playerForm: PlayerForm,
-    hasForm: boolean,
-  ) => void,
-  playerForm?: PlayerForm,
-];
-
-const subscriptions: PostTransformationRegisterParameters[] = [];
-
-/** @internal */
-export function postTransformationHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function postTransformationRegister(
-  ...args: PostTransformationRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function postTransformationFire(
-  player: EntityPlayer,
-  playerForm: PlayerForm,
-  hasForm: boolean,
-): void {
-  for (const [callback, callbackPlayerForm] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (callbackPlayerForm !== undefined && callbackPlayerForm !== playerForm) {
-      continue;
-    }
-
-    callback(player, playerForm, hasForm);
-  }
-}

package/src/callbacks/subscriptions/postTrinketBreak.ts

@@ -1,38 +0,0 @@
-import { TrinketType } from "isaac-typescript-definitions";
-
-export type PostTrinketBreakRegisterParameters = [
-  callback: (player: EntityPlayer, trinketType: TrinketType) => void,
-  trinketType?: TrinketType,
-];
-
-const subscriptions: PostTrinketBreakRegisterParameters[] = [];
-
-/** @internal */
-export function postTrinketBreakHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function postTrinketBreakRegister(
-  ...args: PostTrinketBreakRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function postTrinketBreakFire(
-  player: EntityPlayer,
-  trinketType: TrinketType,
-): void {
-  for (const [callback, callbackTrinketType] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (
-      callbackTrinketType !== undefined &&
-      callbackTrinketType !== trinketType
-    ) {
-      continue;
-    }
-
-    callback(player, trinketType);
-  }
-}

package/src/callbacks/subscriptions/preBerserkDeath.ts

@@ -1,42 +0,0 @@
-import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
-
-export type PreBerserkDeathRegisterParameters = [
-  callback: (player: EntityPlayer) => boolean | void,
-  playerVariant?: PlayerVariant,
-  character?: PlayerType,
-];
-
-const subscriptions: PreBerserkDeathRegisterParameters[] = [];
-
-/** @internal */
-export function preBerserkDeathHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function preBerserkDeathRegister(
-  ...args: PreBerserkDeathRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function preBerserkDeathFire(player: EntityPlayer): boolean | void {
-  const character = player.GetPlayerType();
-
-  for (const [callback, playerVariant, callbackCharacter] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (playerVariant !== undefined && playerVariant !== player.Variant) {
-      continue;
-    }
-
-    // Handle the optional 3rd callback argument.
-    if (callbackCharacter !== undefined && callbackCharacter !== character) {
-      continue;
-    }
-
-    callback(player);
-  }
-
-  return undefined;
-}

package/src/callbacks/subscriptions/preCustomRevive.ts

@@ -1,45 +0,0 @@
-import { PlayerType, PlayerVariant } from "isaac-typescript-definitions";
-
-export type PreCustomReviveRegisterParameters = [
-  callback: (player: EntityPlayer) => int | void,
-  playerVariant?: PlayerVariant,
-  character?: PlayerType,
-];
-
-const subscriptions: PreCustomReviveRegisterParameters[] = [];
-
-/** @internal */
-export function preCustomReviveHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function preCustomReviveRegister(
-  ...args: PreCustomReviveRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function preCustomReviveFire(player: EntityPlayer): int | void {
-  const character = player.GetPlayerType();
-
-  for (const [callback, playerVariant, callbackCharacter] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (playerVariant !== undefined && playerVariant !== player.Variant) {
-      continue;
-    }
-
-    // Handle the optional 3rd callback argument.
-    if (callbackCharacter !== undefined && callbackCharacter !== character) {
-      continue;
-    }
-
-    const revivalType = callback(player);
-    if (revivalType !== undefined) {
-      return revivalType;
-    }
-  }
-
-  return undefined;
-}

package/src/callbacks/subscriptions/preItemPickup.ts

@@ -1,64 +0,0 @@
-import {
-  CollectibleType,
-  ItemType,
-  TrinketType,
-} from "isaac-typescript-definitions";
-import {
-  PickingUpItem,
-  PickingUpItemCollectible,
-  PickingUpItemTrinket,
-} from "../../types/PickingUpItem";
-
-export type PreItemPickupRegisterParameters =
-  | [callback: (player: EntityPlayer, pickingUpItem: PickingUpItem) => void]
-  | [
-      callback: (
-        player: EntityPlayer,
-        pickingUpItem: PickingUpItemCollectible,
-      ) => void,
-      itemType: ItemType.PASSIVE | ItemType.ACTIVE | ItemType.FAMILIAR,
-      collectibleType?: CollectibleType,
-    ]
-  | [
-      callback: (
-        player: EntityPlayer,
-        pickingUpItem: PickingUpItemTrinket,
-      ) => void,
-      itemType: ItemType.TRINKET,
-      trinketType?: TrinketType,
-    ];
-
-const subscriptions: PreItemPickupRegisterParameters[] = [];
-
-/** @internal */
-export function preItemPickupHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function preItemPickupRegister(
-  ...args: PreItemPickupRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function preItemPickupFire(
-  player: EntityPlayer,
-  pickingUpItem: PickingUpItem,
-): void {
-  for (const [callback, itemType, subType] of subscriptions) {
-    // Handle the optional 2nd callback argument.
-    if (itemType !== undefined && itemType !== pickingUpItem.itemType) {
-      continue;
-    }
-
-    // Handle the optional 3rd callback argument.
-    if (subType !== undefined && subType !== pickingUpItem.subType) {
-      continue;
-    }
-
-    // @ts-expect-error TypeScript isn't smart enough to treat the above checks as type narrowing.
-    callback(player, pickingUpItem);
-  }
-}

package/src/callbacks/subscriptions/preNewLevel.ts

@@ -1,24 +0,0 @@
-export type PreNewLevelRegisterParameters = [
-  callback: (player: EntityPlayer) => void,
-];
-
-const subscriptions: PreNewLevelRegisterParameters[] = [];
-
-/** @internal */
-export function preNewLevelHasSubscriptions(): boolean {
-  return subscriptions.length > 0;
-}
-
-/** @internal */
-export function preNewLevelRegister(
-  ...args: PreNewLevelRegisterParameters
-): void {
-  subscriptions.push(args);
-}
-
-/** @internal */
-export function preNewLevelFire(player: EntityPlayer): void {
-  for (const [callback] of subscriptions) {
-    callback(player);
-  }
-}

package/src/classes/DefaultMap.ts

@@ -1,220 +0,0 @@
-/* eslint-disable sort-exports/sort-exports */
-
-/**
- * A function that creates the value for your default map. For example, if it was a default map
- * containing maps, the factory function would be: `() => new Map()`
- */
-export type FactoryFunction<V, Args extends unknown[]> = (
-  ...extraArgs: Args
-) => V;
-
-type FirstArg<K, V, Args extends unknown[]> =
-  | Iterable<[K, V]>
-  | V
-  | FactoryFunction<V, Args>;
-type SecondArg<V, Args extends unknown[]> = V | FactoryFunction<V, Args>;
-
-interface ParsedArgs<K, V, Args extends unknown[]> {
-  iterable: Iterable<[K, V]> | undefined;
-  defaultValue: V | undefined;
-  defaultValueFactory: FactoryFunction<V, Args> | undefined;
-}
-
-/**
- * An extended `Map` with some new methods:
- *
- * - `getAndSetDefault` - If the key exists, this will return the same thing as the `get` method.
- *   Otherwise, it will set a default value to the key, and then return the default value.
- * - `getDefaultValue` - Returns the default value to be used for a new key. (If a factory function
- *   was provided during instantiation, this will execute the factory function.)
- * - `getConstructorArg` - Helper method for cloning the map. Returns either the default value or
- *   the reference to the factory function.
- *
- * When instantiating a new DefaultMap, you must specify either a default value or a function that
- * returns a default value.
- *
- * For example:
- *
- * ```ts
- * // Initializes a new empty DefaultMap with a default value of "foo".
- * const defaultMapWithPrimitive = new DefaultMap<string, string>("foo");
- *
- * // Initializes a new empty DefaultMap with a default value of a new Map.
- * const defaultMapWithFactory = new DefaultMap<string, Map<string, string>>(() => {
- *   return new Map();
- * })
- *
- * // Initializes a DefaultMap with some initial values and a default value of "bar".
- * const defaultMapWithInitialValues = new DefaultMap<string, string>([
- *   ["a1", "a2"],
- *   ["b1", "b2"],
- * ], "bar");
- * ```
- *
- * If specified, the first argument of a factory function must always be equal to the key:
- *
- * ```ts
- * const defaultMapWithConditionalDefaultValue = new DefaultMap<number, number>((key: number) => {
- *   return isOdd(key) ? 0 : 1;
- * });
- * ```
- *
- * You can also specify a factory function that takes a generic amount of arguments beyond the
- * first:
- *
- * ```ts
- * const factoryFunction = (arg: boolean) => arg ? 0 : 1;
- * const defaultMapWithExtraArgs = new DefaultMap<string, string, [arg: boolean]>(factoryFunction);
- * ```
- */
-export class DefaultMap<K, V, Args extends unknown[] = []> extends Map<K, V> {
-  private defaultValue: V | undefined;
-  private defaultValueFactory: FactoryFunction<V, Args> | undefined;
-
-  /**
-   * See the main `DefaultMap` documentation:
-   * https://isaacscript.github.io/isaacscript-common/classes/classes_DefaultMap.DefaultMap
-   */
-  constructor(
-    iterableOrDefaultValueOrDefaultValueFactory: FirstArg<K, V, Args>,
-    defaultValueOrDefaultValueFactory?: SecondArg<V, Args>,
-  ) {
-    const { iterable, defaultValue, defaultValueFactory } = parseArguments(
-      iterableOrDefaultValueOrDefaultValueFactory,
-      defaultValueOrDefaultValueFactory,
-    );
-
-    if (defaultValue === undefined && defaultValueFactory === undefined) {
-      error(
-        "A DefaultMap must be instantiated with either a default value or a function that returns a default value.",
-      );
-    }
-
-    if (iterable === undefined) {
-      super();
-    } else {
-      super(iterable);
-    }
-
-    this.defaultValue = defaultValue;
-    this.defaultValueFactory = defaultValueFactory;
-  }
-
-  /**
-   * If the key exists, this will return the same thing as the `get` method. Otherwise, it will set
-   * a default value to the key, and then return the default value.
-   */
-  getAndSetDefault(key: K, ...extraArgs: Args): V {
-    const value = this.get(key);
-    if (value !== undefined) {
-      return value;
-    }
-
-    const defaultValue = this.getDefaultValue(...extraArgs);
-    this.set(key, defaultValue);
-    return defaultValue;
-  }
-
-  /**
-   * Returns the default value to be used for a new key. (If a factory function was provided during
-   * instantiation, this will execute the factory function.)
-   */
-  getDefaultValue(...extraArgs: Args): V {
-    if (this.defaultValue !== undefined) {
-      return this.defaultValue;
-    }
-
-    if (this.defaultValueFactory !== undefined) {
-      return this.defaultValueFactory(...extraArgs);
-    }
-
-    return error("A DefaultMap was incorrectly instantiated.");
-  }
-
-  /**
-   * Helper method for cloning the map. Returns either the default value or a reference to the
-   * factory function.
-   */
-  getConstructorArg(): V | FactoryFunction<V, Args> {
-    if (this.defaultValue !== undefined) {
-      return this.defaultValue;
-    }
-
-    if (this.defaultValueFactory !== undefined) {
-      return this.defaultValueFactory;
-    }
-
-    return error("A DefaultMap was incorrectly instantiated.");
-  }
-}
-
-function parseArguments<K, V, Args extends unknown[]>(
-  firstArg: FirstArg<K, V, Args>,
-  secondArg?: SecondArg<V, Args>,
-): ParsedArgs<K, V, Args> {
-  return secondArg === undefined
-    ? parseArgumentsOne(firstArg)
-    : parseArgumentsTwo(firstArg, secondArg);
-}
-
-function parseArgumentsOne<K, V, Args extends unknown[]>(
-  firstArg: FirstArg<K, V, Args>,
-): ParsedArgs<K, V, Args> {
-  const arg = firstArg as SecondArg<V, Args>;
-  const { defaultValue, defaultValueFactory } =
-    parseDefaultValueOrDefaultValueFactory(arg);
-  return {
-    iterable: undefined,
-    defaultValue,
-    defaultValueFactory,
-  };
-}
-
-function parseArgumentsTwo<K, V, Args extends unknown[]>(
-  firstArg: FirstArg<K, V, Args>,
-  secondArg: SecondArg<V, Args>,
-): ParsedArgs<K, V, Args> {
-  const firstArgType = type(firstArg);
-  if (firstArgType !== "table") {
-    error(
-      "A DefaultMap constructor with two arguments must have the first argument be the initializer list.",
-    );
-  }
-
-  const { defaultValue, defaultValueFactory } =
-    parseDefaultValueOrDefaultValueFactory(secondArg);
-  return {
-    iterable: firstArg as Iterable<[K, V]>,
-    defaultValue,
-    defaultValueFactory,
-  };
-}
-
-function parseDefaultValueOrDefaultValueFactory<V, Args extends unknown[]>(
-  arg: SecondArg<V, Args>,
-): {
-  defaultValue: V | undefined;
-  defaultValueFactory: FactoryFunction<V, Args> | undefined;
-} {
-  if (typeof arg === "function") {
-    return {
-      defaultValue: undefined,
-      defaultValueFactory: arg as FactoryFunction<V, Args>,
-    };
-  }
-
-  if (
-    typeof arg === "boolean" ||
-    typeof arg === "number" ||
-    typeof arg === "string"
-  ) {
-    return {
-      defaultValue: arg as V,
-      defaultValueFactory: undefined,
-    };
-  }
-
-  return error(
-    `A DefaultMap was instantiated with an unknown type of: ${typeof arg}`,
-  );
-}

package/src/classes/ModUpgraded.ts

@@ -1,83 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { AddCallbackParameterCustom } from "../interfaces/AddCallbackParameterCustom";
-import { CALLBACK_REGISTER_FUNCTIONS } from "../objects/callbackRegisterFunctions";
-
-/**
- * `isaacscript-common` has many custom callbacks that you can use in your mods. Instead of
- * hijacking the vanilla `Mod` object, we provide a `ModUpgraded` object for you to use, which
- * extends the base class and adds a new method of `AddCallbackCustom`.
- *
- * To upgrade your mod, use the `upgradeMod` helper function.
- */
-export class ModUpgraded implements Mod {
-  // -----------------
-  // Vanilla variables
-  // -----------------
-
-  Name: string; // The vanilla mod object stores this for some reason
-
-  // ----------------
-  // Custom variables
-  // ----------------
-
-  /** We store a copy of the original mod object so that we can re-implement its functions. */
-  Mod: Mod;
-
-  constructor(mod: Mod) {
-    this.Name = mod.Name;
-
-    this.Mod = mod;
-  }
-
-  // ---------------
-  // Vanilla methods
-  // ---------------
-
-  AddCallback<T extends ModCallback>(
-    modCallback: T,
-    ...args: AddCallbackParameter[T]
-  ): void {
-    this.Mod.AddCallback(modCallback, ...args);
-  }
-
-  HasData(): boolean {
-    return this.Mod.HasData();
-  }
-
-  LoadData(): string {
-    return this.Mod.LoadData();
-  }
-
-  RemoveCallback(callbackID: ModCallback, callback: () => void): void {
-    this.Mod.RemoveCallback(callbackID, callback);
-  }
-
-  RemoveData(): void {
-    this.Mod.RemoveData();
-  }
-
-  SaveData(data: string): void {
-    this.Mod.SaveData(data);
-  }
-
-  // --------------
-  // Custom methods
-  // --------------
-
-  // eslint-disable-next-line class-methods-use-this
-  AddCallbackCustom<T extends ModCallbackCustom>(
-    modCallbackCustom: T,
-    ...args: AddCallbackParameterCustom[T]
-  ): void {
-    const callbackRegisterFunction =
-      CALLBACK_REGISTER_FUNCTIONS[modCallbackCustom];
-    if (callbackRegisterFunction === undefined) {
-      error(
-        `Failed to find a callback registration function for custom callback: ${modCallbackCustom}`,
-      );
-    }
-
-    callbackRegisterFunction(...args);
-  }
-}