isaacscript-common 13.3.4 → 14.1.0

package/dist/src/classes/features/other/RunInNFrames.d.ts

@@ -0,0 +1,123 @@
+/// <reference types="isaac-typescript-definitions" />
+import { Feature } from "../../private/Feature";
+/** Used for `runInNFrames` functions. */
+declare type QueuedFunctionTuple = [frameCountToFire: int, func: () => void];
+/**
+ * Used for `setInterval` functions.
+ *
+ * The return value is whether or not to continue the function from firing.
+ */
+declare type IntervalFunctionTuple = [
+    frameCountToFire: int,
+    func: () => boolean,
+    numIntervalFrames: int
+];
+export declare class RunInNFrames extends Feature {
+    v: {
+        run: {
+            queuedGameFunctionTuples: QueuedFunctionTuple[];
+            queuedRenderFunctionTuples: QueuedFunctionTuple[];
+            intervalGameFunctionTuples: IntervalFunctionTuple[];
+            intervalRenderFunctionTuples: IntervalFunctionTuple[];
+        };
+    };
+    constructor();
+    private postUpdate;
+    private postRender;
+    /**
+     * Supply a function to run N game frames from now in the `POST_UPDATE` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     */
+    runInNGameFrames(func: () => void, gameFrames: int): void;
+    /**
+     * Supply a function to run N render frames from now in the `POST_RENDER` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     */
+    runInNRenderFrames(func: () => void, renderFrames: int): void;
+    /**
+     * Supply a function to run on the next `POST_UPDATE` callback.
+     *
+     * For example:
+     *
+     * ```ts
+     * const NUM_EXPLODER_EXPLOSIONS = 5;
+     *
+     * function useItemExploder(player: EntityPlayer) {
+     *   playSound("exploderBegin");
+     *   explode(player, NUM_EXPLODER_EXPLOSIONS);
+     * }
+     *
+     * function explode(player: EntityPlayer, numFramesLeft: int) {
+     *   Isaac.Explode(player, undefined, 1);
+     *   numFramesLeft -= 1;
+     *   if (numFramesLeft === 0) {
+     *     runNextFrame(() => {
+     *       explode(player, numFramesLeft);
+     *     });
+     *   }
+     * }
+     * ```
+     *
+     * Note that this function will not handle saving and quitting. If a player saving and quitting
+     * before the deferred function fires would cause a bug in your mod, then you should handle
+     * deferred functions manually using serializable data.
+     */
+    runNextGameFrame(func: () => void): void;
+    /**
+     * Supply a function to run on the next `POST_RENDER` callback.
+     *
+     * For a usage example, see the documentation for the `runNextGameFrame`, which is used in a
+     * similar way.
+     *
+     * Note that this function will not handle saving and quitting.
+     */
+    runNextRenderFrame(func: () => void): void;
+    /**
+     * Supply a function to be repeatedly run on an interval of N game frames in the `POST_UPDATE`
+     * callback. The function will continue to be fired until `false` is returned from the function.
+     *
+     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
+     * is used to stop the interval.)
+     *
+     * Note that this function will not handle saving and quitting. You must manually restart any
+     * intervals if the player saves and quits in the middle of a run.
+     *
+     * @param func The function to repeatedly run on an interval.
+     * @param gameFrames The amount of game frames to wait between each run.
+     * @param runImmediately Whether or not to execute the function right now before waiting for the
+     *                       interval.
+     */
+    setIntervalGameFrames(func: () => boolean, gameFrames: int, runImmediately: boolean): void;
+    /**
+     * Supply a function to be repeatedly run on an interval of N render frames in the `POST_RENDER`
+     * callback. The function will continue to be fired until `false` is returned from the function.
+     *
+     * This is similar to the `setInterval` vanilla JavaScript function, except there is no
+     * corresponding `clearInterval` function. (Instead, the return value from the supplied function
+     * is used to stop the interval.)
+     *
+     * Note that this function will not handle saving and quitting. You must manually restart any
+     * intervals if the player saves and quits in the middle of a run.
+     *
+     * @param func The function to repeatedly run on an interval.
+     * @param renderFrames The amount of game frames to wait between each run.
+     * @param runImmediately Whether or not to execute the function right now before waiting for the
+     *                       interval.
+     */
+    setIntervalRenderFrames(func: () => boolean, renderFrames: int, runImmediately: boolean): void;
+}
+export {};
+//# sourceMappingURL=RunInNFrames.d.ts.map

package/dist/src/classes/features/other/RunInNFrames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,yCAAyC;AACzC,aAAK,mBAAmB,GAAG,CAAC,gBAAgB,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC,CAAC;AAErE;;;;GAIG;AACH,aAAK,qBAAqB,GAAG;IAC3B,gBAAgB,EAAE,GAAG;IACrB,IAAI,EAAE,MAAM,OAAO;IACnB,iBAAiB,EAAE,GAAG;CACvB,CAAC;AAEF,qBAAa,YAAa,SAAQ,OAAO;IACvB,CAAC;;;;;;;MAQf;;IAYF,OAAO,CAAC,UAAU,CAWhB;IAGF,OAAO,CAAC,UAAU,CAWhB;IAMF;;;;;;;;;OASG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAOhE;;;;;;;;;OASG;IACI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C;;;;;;;OAOG;IACI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD;;;;;;;;;;;;;;;OAeG;IACI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,GACtB,IAAI;IAWP;;;;;;;;;;;;;;;OAeG;IACI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,OAAO,GACtB,IAAI;CAcR"}

package/dist/src/classes/features/other/RunInNFrames.lua

@@ -0,0 +1,109 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
+local ____exports = {}
+local checkExecuteQueuedFunctions, checkExecuteIntervalFunctions
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____array = require("src.functions.array")
+local arrayRemoveInPlace = ____array.arrayRemoveInPlace
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+function checkExecuteQueuedFunctions(self, frameCount, functionTuples)
+    local firingFunctions = __TS__ArrayFilter(
+        functionTuples,
+        function(____, ____bindingPattern0)
+            local frameCountToFire
+            frameCountToFire = ____bindingPattern0[1]
+            return frameCount >= frameCountToFire
+        end
+    )
+    for ____, tuple in ipairs(firingFunctions) do
+        local _frameCountToFire, func = table.unpack(tuple)
+        func(nil)
+        arrayRemoveInPlace(nil, functionTuples, tuple)
+    end
+end
+function checkExecuteIntervalFunctions(self, frameCount, functionTuples)
+    local firingFunctions = __TS__ArrayFilter(
+        functionTuples,
+        function(____, ____bindingPattern0)
+            local frameCountToFire
+            frameCountToFire = ____bindingPattern0[1]
+            return frameCount >= frameCountToFire
+        end
+    )
+    for ____, tuple in ipairs(firingFunctions) do
+        local _frameCountToFire, func, numIntervalFrames = table.unpack(tuple)
+        local returnValue = func(nil)
+        arrayRemoveInPlace(nil, functionTuples, tuple)
+        if returnValue then
+            local nextFireFrame = frameCount + numIntervalFrames
+            local newTuple = {nextFireFrame, func, numIntervalFrames}
+            functionTuples[#functionTuples + 1] = newTuple
+        end
+    end
+end
+____exports.RunInNFrames = __TS__Class()
+local RunInNFrames = ____exports.RunInNFrames
+RunInNFrames.name = "RunInNFrames"
+__TS__ClassExtends(RunInNFrames, Feature)
+function RunInNFrames.prototype.____constructor(self)
+    Feature.prototype.____constructor(self)
+    self.v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}, intervalGameFunctionTuples = {}, intervalRenderFunctionTuples = {}}}
+    self.postUpdate = function()
+        local gameFrameCount = game:GetFrameCount()
+        checkExecuteQueuedFunctions(nil, gameFrameCount, self.v.run.queuedGameFunctionTuples)
+        checkExecuteIntervalFunctions(nil, gameFrameCount, self.v.run.intervalGameFunctionTuples)
+    end
+    self.postRender = function()
+        local renderFrameCount = Isaac.GetFrameCount()
+        checkExecuteQueuedFunctions(nil, renderFrameCount, self.v.run.queuedRenderFunctionTuples)
+        checkExecuteIntervalFunctions(nil, renderFrameCount, self.v.run.intervalRenderFunctionTuples)
+    end
+    self.callbacksUsed = {{ModCallback.POST_UPDATE, {self.postUpdate}}, {ModCallback.POST_RENDER, {self.postRender}}}
+end
+function RunInNFrames.prototype.runInNGameFrames(self, func, gameFrames)
+    local gameFrameCount = game:GetFrameCount()
+    local functionFireFrame = gameFrameCount + gameFrames
+    local tuple = {functionFireFrame, func}
+    local ____self_v_run_queuedGameFunctionTuples_0 = self.v.run.queuedGameFunctionTuples
+    ____self_v_run_queuedGameFunctionTuples_0[#____self_v_run_queuedGameFunctionTuples_0 + 1] = tuple
+end
+function RunInNFrames.prototype.runInNRenderFrames(self, func, renderFrames)
+    local renderFrameCount = Isaac.GetFrameCount()
+    local functionFireFrame = renderFrameCount + renderFrames
+    local tuple = {functionFireFrame, func}
+    local ____self_v_run_queuedRenderFunctionTuples_1 = self.v.run.queuedRenderFunctionTuples
+    ____self_v_run_queuedRenderFunctionTuples_1[#____self_v_run_queuedRenderFunctionTuples_1 + 1] = tuple
+end
+function RunInNFrames.prototype.runNextGameFrame(self, func)
+    self:runInNGameFrames(func, 1)
+end
+function RunInNFrames.prototype.runNextRenderFrame(self, func)
+    self:runInNRenderFrames(func, 1)
+end
+function RunInNFrames.prototype.setIntervalGameFrames(self, func, gameFrames, runImmediately)
+    local gameFrameCount = game:GetFrameCount()
+    local functionFireFrame = gameFrameCount + gameFrames
+    local tuple = {functionFireFrame, func, gameFrames}
+    local ____self_v_run_intervalGameFunctionTuples_2 = self.v.run.intervalGameFunctionTuples
+    ____self_v_run_intervalGameFunctionTuples_2[#____self_v_run_intervalGameFunctionTuples_2 + 1] = tuple
+    if runImmediately then
+        func(nil)
+    end
+end
+function RunInNFrames.prototype.setIntervalRenderFrames(self, func, renderFrames, runImmediately)
+    local renderFrameCount = Isaac.GetFrameCount()
+    local functionFireFrame = renderFrameCount + renderFrames
+    local tuple = {functionFireFrame, func, renderFrames}
+    local ____self_v_run_intervalGameFunctionTuples_3 = self.v.run.intervalGameFunctionTuples
+    ____self_v_run_intervalGameFunctionTuples_3[#____self_v_run_intervalGameFunctionTuples_3 + 1] = tuple
+    if runImmediately then
+        func(nil)
+    end
+end
+return ____exports

package/dist/src/classes/private/CustomCallback.d.ts

@@ -0,0 +1,26 @@
+import { ModCallbackCustom2 } from "../../enums/ModCallbackCustom2";
+import { AddCallbackParametersCustom2 } from "../../interfaces/private/AddCallbackParametersCustom2";
+import { AllButFirst } from "../../types/private/AllButFirst";
+import { Feature } from "./Feature";
+export declare type FireArgs<T extends ModCallbackCustom2> = Parameters<AddCallbackParametersCustom2[T][0]>;
+export declare type OptionalArgs<T extends ModCallbackCustom2> = AllButFirst<AddCallbackParametersCustom2[T]>;
+/**
+ * The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
+ * extend from this class.
+ */
+export declare abstract class CustomCallback<T extends ModCallbackCustom2> extends Feature {
+    private subscriptions;
+    hasSubscriptions(): boolean;
+    add(...args: AddCallbackParametersCustom2[T]): void;
+    /**
+     * If the submitted function does not match any of the existing subscriptions, this method will do
+     * nothing.
+     */
+    remove(callback: AddCallbackParametersCustom2[T][0]): void;
+    fire: (...fireArgs: FireArgs<T>) => ReturnType<AddCallbackParametersCustom2[T][0]>;
+    /**
+     * This method needs to be overwritten for any callback that has optional filtration arguments.
+     */
+    protected shouldFire(fireArgs: FireArgs<T>, optionalArgs: OptionalArgs<T>): boolean;
+}
+//# sourceMappingURL=CustomCallback.d.ts.map

package/dist/src/classes/private/CustomCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomCallback.d.ts","sourceRoot":"","sources":["../../../../src/classes/private/CustomCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,4BAA4B,EAAE,MAAM,uDAAuD,CAAC;AACrG,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,oBAAY,QAAQ,CAAC,CAAC,SAAS,kBAAkB,IAAI,UAAU,CAC7D,4BAA4B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACnC,CAAC;AACF,oBAAY,YAAY,CAAC,CAAC,SAAS,kBAAkB,IAAI,WAAW,CAClE,4BAA4B,CAAC,CAAC,CAAC,CAChC,CAAC;AAEF;;;GAGG;AACH,8BAAsB,cAAc,CAClC,CAAC,SAAS,kBAAkB,CAC5B,SAAQ,OAAO;IACf,OAAO,CAAC,aAAa,CAA8C;IAE5D,gBAAgB,IAAI,OAAO;IAI3B,GAAG,CAAC,GAAG,IAAI,EAAE,4BAA4B,CAAC,CAAC,CAAC,GAAG,IAAI;IAI1D;;;OAGG;IACI,MAAM,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAY1D,IAAI,gBACI,SAAS,CAAC,CAAC,KACvB,WAAW,4BAA4B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAoB/C;IAEF;;OAEG;IAEH,SAAS,CAAC,UAAU,CAElB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAErB,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAC5B,OAAO;CAGX"}

package/dist/src/classes/private/CustomCallback.lua

@@ -0,0 +1,63 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__Spread = ____lualib.__TS__Spread
+local __TS__ArraySlice = ____lualib.__TS__ArraySlice
+local __TS__ArrayFindIndex = ____lualib.__TS__ArrayFindIndex
+local __TS__ArraySplice = ____lualib.__TS__ArraySplice
+local ____exports = {}
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+--- The base class for a custom callback. Individual custom callbacks (and validation callbacks) will
+-- extend from this class.
+____exports.CustomCallback = __TS__Class()
+local CustomCallback = ____exports.CustomCallback
+CustomCallback.name = "CustomCallback"
+__TS__ClassExtends(CustomCallback, Feature)
+function CustomCallback.prototype.____constructor(self, ...)
+    Feature.prototype.____constructor(self, ...)
+    self.subscriptions = {}
+    self.fire = function(____, ...)
+        local fireArgs = {...}
+        for ____, ____value in ipairs(self.subscriptions) do
+            local callback = ____value[1]
+            local optionalArgsArray = __TS__ArraySlice(____value, 1)
+            local optionalArgs = optionalArgsArray
+            if self:shouldFire(fireArgs, optionalArgs) then
+                local callbackCasted = callback
+                local value = callbackCasted(
+                    nil,
+                    __TS__Spread(fireArgs)
+                )
+                if value ~= nil then
+                    return value
+                end
+            end
+        end
+        return nil
+    end
+end
+function CustomCallback.prototype.hasSubscriptions(self)
+    return #self.subscriptions > 0
+end
+function CustomCallback.prototype.add(self, ...)
+    local args = {...}
+    local ____self_subscriptions_0 = self.subscriptions
+    ____self_subscriptions_0[#____self_subscriptions_0 + 1] = args
+end
+function CustomCallback.prototype.remove(self, callback)
+    local subscriptionIndexMatchingCallback = __TS__ArrayFindIndex(
+        self.subscriptions,
+        function(____, subscription)
+            local subscriptionCallback = subscription[1]
+            return callback == subscriptionCallback
+        end
+    )
+    if subscriptionIndexMatchingCallback ~= -1 then
+        __TS__ArraySplice(self.subscriptions, subscriptionIndexMatchingCallback, 1)
+    end
+end
+function CustomCallback.prototype.shouldFire(self, fireArgs, optionalArgs)
+    return true
+end
+return ____exports

package/dist/src/classes/private/Feature.d.ts

@@ -0,0 +1,19 @@
+import { ISCFeature } from "../../enums/ISCFeature";
+import { SaveData } from "../../interfaces/SaveData";
+import { CallbackTuple, CustomCallbackTuple } from "../../types/private/CallbackTuple";
+/**
+ * The IsaacScript standard library contains many optional features, such as the ability to create
+ * custom pickups. All features are optional and are only initialized when needed. This class
+ * contains elements to facilitate that.
+ *
+ * Additionally, all custom callbacks extend from this class.
+ */
+export declare class Feature {
+    initialized: boolean;
+    v?: SaveData;
+    featuresUsed?: ISCFeature[];
+    callbacksUsed?: CallbackTuple[];
+    customCallbacksUsed?: CustomCallbackTuple[];
+    exportedMethods: string[];
+}
+//# sourceMappingURL=Feature.d.ts.map

package/dist/src/classes/private/Feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Feature.d.ts","sourceRoot":"","sources":["../../../../src/classes/private/Feature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrD,OAAO,EACL,aAAa,EACb,mBAAmB,EACpB,MAAM,mCAAmC,CAAC;AAE3C;;;;;;GAMG;AACH,qBAAa,OAAO;IACX,WAAW,UAAS;IAEpB,CAAC,CAAC,EAAE,QAAQ,CAAC;IACb,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC;IAC5B,aAAa,CAAC,EAAE,aAAa,EAAE,CAAC;IAChC,mBAAmB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAE5C,eAAe,EAAE,MAAM,EAAE,CAAM;CACvC"}

package/dist/src/classes/private/Feature.lua

@@ -0,0 +1,16 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+--- The IsaacScript standard library contains many optional features, such as the ability to create
+-- custom pickups. All features are optional and are only initialized when needed. This class
+-- contains elements to facilitate that.
+-- 
+-- Additionally, all custom callbacks extend from this class.
+____exports.Feature = __TS__Class()
+local Feature = ____exports.Feature
+Feature.name = "Feature"
+function Feature.prototype.____constructor(self)
+    self.initialized = false
+    self.exportedMethods = {}
+end
+return ____exports

package/dist/src/core/upgradeMod.d.ts

@@ -1,6 +1,20 @@
 /// <reference types="isaac-typescript-definitions" />
 /// <reference types="isaac-typescript-definitions" />
 import { ModUpgraded } from "../classes/ModUpgraded";
+import { Feature } from "../classes/private/Feature";
+import { ISCFeature } from "../enums/ISCFeature";
+import { ISCFeatureToClass } from "../features";
+import { LowercaseKeys } from "../types/LowercaseKeys";
+import { UnionToIntersection } from "../types/UnionToIntersection";
+/**
+ * By specifying one or more optional features, end-users will get a version of `ModUpgraded` that
+ * has extra methods corresponding to the features.
+ *
+ * We have to explicitly account for the empty array case, since `never` will cause mess up the
+ * union.
+ */
+declare type ModUpgradedWithFeatures<T extends ISCFeature> = [T] extends [never] ? ModUpgraded : Omit<ModUpgraded & UnionToIntersection<ISCFeatureToClass[T]>, KeysToScrubFromModClass>;
+declare type KeysToScrubFromModClass = keyof Feature | LowercaseKeys<ModUpgraded>;
 /**
  * Use this function to enable the custom callbacks and other optional features provided by
  * `isaacscript-common`.
@@ -19,6 +33,8 @@ import { ModUpgraded } from "../classes/ModUpgraded";
  * ```
  *
  * @param modVanilla The mod object returned by the `RegisterMod` function.
+ * @param features Optional. An array containing the optional standard library features that you
+ *                 want to enable, if any. Default is an empty array.
  * @param debug Optional. Whether to log additional output when a callback is fired. Default is
  *              false.
  * @param timeThreshold Optional. If provided, will only log callbacks that take longer than the
@@ -26,5 +42,6 @@ import { ModUpgraded } from "../classes/ModUpgraded";
  *                      or milliseconds (if the "--luadebug" launch flag is turned off).
  * @returns The upgraded mod object.
  */
-export declare function upgradeMod(modVanilla: Mod, debug?: boolean, timeThreshold?: float): ModUpgraded;
+export declare function upgradeMod<T extends ISCFeature = never>(modVanilla: Mod, features?: T[], debug?: boolean, timeThreshold?: float): ModUpgradedWithFeatures<T>;
+export {};
 //# sourceMappingURL=upgradeMod.d.ts.map

package/dist/src/core/upgradeMod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgradeMod.d.ts","sourceRoot":"","sources":["../../../src/core/upgradeMod.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAWrD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,GAAG,EACf,KAAK,UAAQ,EACb,aAAa,CAAC,EAAE,KAAK,GACpB,WAAW,CAwBb"}
+{"version":3,"file":"upgradeMod.d.ts","sourceRoot":"","sources":["../../../src/core/upgradeMod.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAchD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAEnE;;;;;;GAMG;AACH,aAAK,uBAAuB,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,GACpE,WAAW,GACX,IAAI,CACF,WAAW,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,EACvD,uBAAuB,CACxB,CAAC;AAEN,aAAK,uBAAuB,GAAG,MAAM,OAAO,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,UAAU,GAAG,KAAK,EACrD,UAAU,EAAE,GAAG,EACf,QAAQ,GAAE,CAAC,EAAO,EAClB,KAAK,UAAQ,EACb,aAAa,CAAC,EAAE,KAAK,GACpB,uBAAuB,CAAC,CAAC,CAAC,CA8B5B"}

package/dist/src/core/upgradeMod.lua

@@ -1,12 +1,15 @@
 local ____lualib = require("lualib_bundle")
 local __TS__New = ____lualib.__TS__New
 local ____exports = {}
+local legacyInit
 local ____postNewRoomEarly = require("src.callbacks.postNewRoomEarly")
 local postNewRoomEarlyCallbackInit = ____postNewRoomEarly.postNewRoomEarlyCallbackInit
 local ____ModUpgraded = require("src.classes.ModUpgraded")
 local ModUpgraded = ____ModUpgraded.ModUpgraded
 local ____main = require("src.features.saveDataManager.main")
 local saveDataManagerInit = ____main.saveDataManagerInit
+local SAVE_DATA_MANAGER_CALLBACKS = ____main.SAVE_DATA_MANAGER_CALLBACKS
+local SAVE_DATA_MANAGER_CUSTOM_CALLBACKS = ____main.SAVE_DATA_MANAGER_CUSTOM_CALLBACKS
 local ____featuresInitialized = require("src.featuresInitialized")
 local areFeaturesInitialized = ____featuresInitialized.areFeaturesInitialized
 local setFeaturesInitialized = ____featuresInitialized.setFeaturesInitialized
@@ -18,6 +21,26 @@ local ____patchErrorFunctions = require("src.patchErrorFunctions")
 local patchErrorFunction = ____patchErrorFunctions.patchErrorFunction
 local ____shaderCrashFix = require("src.shaderCrashFix")
 local loadShaderCrashFix = ____shaderCrashFix.loadShaderCrashFix
+function legacyInit(self, mod)
+    postNewRoomEarlyCallbackInit(nil, mod)
+    saveDataManagerInit(nil, mod)
+    for ____, callbackTuple in ipairs(SAVE_DATA_MANAGER_CALLBACKS) do
+        local modCallback, callbackArgs = table.unpack(callbackTuple)
+        mod:AddCallback(
+            modCallback,
+            table.unpack(callbackArgs)
+        )
+    end
+    for ____, callbackTuple in ipairs(SAVE_DATA_MANAGER_CUSTOM_CALLBACKS) do
+        local modCallback, callbackArgs = table.unpack(callbackTuple)
+        mod:AddCallbackCustom(
+            modCallback,
+            table.unpack(callbackArgs)
+        )
+    end
+    initCustomCallbacks(nil, mod)
+    initFeatures(nil, mod)
+end
 --- Use this function to enable the custom callbacks and other optional features provided by
 -- `isaacscript-common`.
 -- 
@@ -35,25 +58,37 @@ local loadShaderCrashFix = ____shaderCrashFix.loadShaderCrashFix
 -- ```
 -- 
 -- @param modVanilla The mod object returned by the `RegisterMod` function.
+-- @param features Optional. An array containing the optional standard library features that you
+-- want to enable, if any. Default is an empty array.
 -- @param debug Optional. Whether to log additional output when a callback is fired. Default is
 -- false.
 -- @param timeThreshold Optional. If provided, will only log callbacks that take longer than the
 -- specified number of seconds (if the "--luadebug" launch flag is turned on)
 -- or milliseconds (if the "--luadebug" launch flag is turned off).
 -- @returns The upgraded mod object.
-function ____exports.upgradeMod(self, modVanilla, ____debug, timeThreshold)
+function ____exports.upgradeMod(self, modVanilla, features, ____debug, timeThreshold)
+    if features == nil then
+        features = {}
+    end
     if ____debug == nil then
         ____debug = false
     end
     local mod = __TS__New(ModUpgraded, modVanilla, ____debug, timeThreshold)
-    if not areFeaturesInitialized(nil) then
-        setFeaturesInitialized(nil)
-        patchErrorFunction(nil)
-        loadShaderCrashFix(nil, modVanilla)
-        postNewRoomEarlyCallbackInit(nil, mod)
-        saveDataManagerInit(nil, mod)
-        initCustomCallbacks(nil, mod)
-        initFeatures(nil, mod)
+    if areFeaturesInitialized(nil) then
+        error("Failed to upgrade the mod since a mod has already been initialized. (You can only upgrade one mod per IsaacScript project.)")
+    end
+    setFeaturesInitialized(nil)
+    patchErrorFunction(nil)
+    loadShaderCrashFix(nil, modVanilla)
+    legacyInit(nil, mod)
+    for ____, feature in ipairs(features) do
+        local tstlClassMethods = mod:initOptionalFeature(feature)
+        local modRecord = mod
+        for ____, ____value in ipairs(tstlClassMethods) do
+            local funcName = ____value[1]
+            local func = ____value[2]
+            modRecord[funcName] = func
+        end
     end
     return mod
 end

package/dist/src/decorators.d.ts

@@ -0,0 +1,9 @@
+import { Feature } from "./classes/private/Feature";
+/**
+ * A decorator function that signifies that the decorated class method should be added to the
+ * `ModUpgraded` object.
+ *
+ * This is only meant to be used internally.
+ */
+export declare function Exported(): <T extends Feature>(target: T, propertyKey: keyof T) => void;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/src/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEpD;;;;;GAKG;AACH,wBAAgB,QAAQ,4DACuC,IAAI,CAGlE"}

package/dist/src/decorators.lua

@@ -0,0 +1,12 @@
+local ____exports = {}
+--- A decorator function that signifies that the decorated class method should be added to the
+-- `ModUpgraded` object.
+-- 
+-- This is only meant to be used internally.
+function ____exports.Exported(self)
+    return function(____, target, propertyKey)
+        local ____target_exportedMethods_0 = target.exportedMethods
+        ____target_exportedMethods_0[#____target_exportedMethods_0 + 1] = propertyKey
+    end
+end
+return ____exports

package/dist/src/enums/ISCFeature.d.ts

@@ -0,0 +1,12 @@
+export declare enum ISCFeature {
+    CUSTOM_REVIVE = "CustomRevive",
+    ESAU_JR_DETECTION = "EsauJrDetection",
+    FLIP_DETECTION = "FlipDetection",
+    GRID_ENTITY_COLLISION_DETECTION = "GridEntityCollisionDetection",
+    GRID_ENTITY_DETECTION = "GridEntityDetection",
+    GAME_REORDERED_CALLBACKS = "GameReorderedCallbacks",
+    PLAYER_REORDERED_CALLBACKS = "PlayerReorderedCallbacks",
+    CUSTOM_GRID_ENTITIES = "CustomGridEntities",
+    RUN_IN_N_FRAMES = "runInNFrames"
+}
+//# sourceMappingURL=ISCFeature.d.ts.map

package/dist/src/enums/ISCFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISCFeature.d.ts","sourceRoot":"","sources":["../../../src/enums/ISCFeature.ts"],"names":[],"mappings":"AAGA,oBAAY,UAAU;IAEpB,aAAa,iBAAiB;IAC9B,iBAAiB,oBAAoB;IACrC,cAAc,kBAAkB;IAChC,+BAA+B,iCAAiC;IAChE,qBAAqB,wBAAwB;IAC7C,wBAAwB,2BAA2B;IACnD,0BAA0B,6BAA6B;IAMvD,oBAAoB,uBAAuB;IAuB3C,eAAe,iBAAiB;CAMjC"}

package/dist/src/enums/ISCFeature.lua

@@ -0,0 +1,12 @@
+local ____exports = {}
+____exports.ISCFeature = {}
+____exports.ISCFeature.CUSTOM_REVIVE = "CustomRevive"
+____exports.ISCFeature.ESAU_JR_DETECTION = "EsauJrDetection"
+____exports.ISCFeature.FLIP_DETECTION = "FlipDetection"
+____exports.ISCFeature.GRID_ENTITY_COLLISION_DETECTION = "GridEntityCollisionDetection"
+____exports.ISCFeature.GRID_ENTITY_DETECTION = "GridEntityDetection"
+____exports.ISCFeature.GAME_REORDERED_CALLBACKS = "GameReorderedCallbacks"
+____exports.ISCFeature.PLAYER_REORDERED_CALLBACKS = "PlayerReorderedCallbacks"
+____exports.ISCFeature.CUSTOM_GRID_ENTITIES = "CustomGridEntities"
+____exports.ISCFeature.RUN_IN_N_FRAMES = "runInNFrames"
+return ____exports

package/dist/src/enums/LadderSubTypeCustom.d.ts

@@ -0,0 +1,17 @@
+/**
+ * For `EntityType.EFFECT` (1000), `EffectVariant.LADDER` (8).
+ *
+ * Note that vanilla ladders only use a sub-type of 0. The `isaacscript-common` library uses ladders
+ * to represent custom objects, since they are non-interacting and will not automatically despawn
+ * after time passes, unlike most other effects.
+ *
+ * This enum tracks the kinds of custom objects that are represented by vanilla ladders. We start
+ * assigning sub-types after 100 as to not interfere with any possible modded ladder variants.
+ */
+export declare enum LadderSubTypeCustom {
+    LADDER = 0,
+    CUSTOM_BACKDROP = 101,
+    CUSTOM_SHADOW = 102,
+    CUSTOM_PICKUP = 103
+}
+//# sourceMappingURL=LadderSubTypeCustom.d.ts.map

package/dist/src/enums/LadderSubTypeCustom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LadderSubTypeCustom.d.ts","sourceRoot":"","sources":["../../../src/enums/LadderSubTypeCustom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,oBAAY,mBAAmB;IAC7B,MAAM,IAAI;IAEV,eAAe,MAAM;IACrB,aAAa,MAAM;IACnB,aAAa,MAAM;CACpB"}

package/dist/src/enums/LadderSubTypeCustom.lua

@@ -0,0 +1,19 @@
+local ____exports = {}
+--- For `EntityType.EFFECT` (1000), `EffectVariant.LADDER` (8).
+-- 
+-- Note that vanilla ladders only use a sub-type of 0. The `isaacscript-common` library uses ladders
+-- to represent custom objects, since they are non-interacting and will not automatically despawn
+-- after time passes, unlike most other effects.
+-- 
+-- This enum tracks the kinds of custom objects that are represented by vanilla ladders. We start
+-- assigning sub-types after 100 as to not interfere with any possible modded ladder variants.
+____exports.LadderSubTypeCustom = {}
+____exports.LadderSubTypeCustom.LADDER = 0
+____exports.LadderSubTypeCustom[____exports.LadderSubTypeCustom.LADDER] = "LADDER"
+____exports.LadderSubTypeCustom.CUSTOM_BACKDROP = 101
+____exports.LadderSubTypeCustom[____exports.LadderSubTypeCustom.CUSTOM_BACKDROP] = "CUSTOM_BACKDROP"
+____exports.LadderSubTypeCustom.CUSTOM_SHADOW = 102
+____exports.LadderSubTypeCustom[____exports.LadderSubTypeCustom.CUSTOM_SHADOW] = "CUSTOM_SHADOW"
+____exports.LadderSubTypeCustom.CUSTOM_PICKUP = 103
+____exports.LadderSubTypeCustom[____exports.LadderSubTypeCustom.CUSTOM_PICKUP] = "CUSTOM_PICKUP"
+return ____exports