isaacscript-common 15.3.0 → 15.3.2

package/dist/index.d.ts

@@ -10690,7 +10690,7 @@ declare class ModdedElementSets extends Feature {
 }
 
 /**
- * Helper class for mods that wants to represent their individual features as classes. Extend your
+ * Helper class for mods that want to represent their individual features as classes. Extend your
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
@@ -10715,18 +10715,31 @@ declare class ModdedElementSets extends Feature {
  * }
  * ```
  *
+ * When instantiating a feature class, you must pass your upgraded mod as the first argument to the
+ * constructor.
+ *
  * In almost all cases, you will want the callback functions to be immediately subscribed after
  * instantiating the class. However, if this is not the case, you can pass `false` as the optional
  * second argument to the constructor.
  */
 export declare class ModFeature {
     private mod;
+    private initialized;
     constructor(mod: ModUpgradedBase, init?: boolean);
     /**
      * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
      * callbacks. Additionally, subscribes the `v` object to the save data manager, if present.
+     *
+     * @param init Optional. Whether to initialize or uninitialize. Default is true.
      */
     init(init?: boolean): void;
+    /**
+     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
+     * decorated callbacks. Additionally, unsubscribes the `v` object from the save data manager, if
+     * present.
+     *
+     * This is just an alias for `ModFeature.init(false)`.
+     */
     uninit(): void;
 }
 
@@ -12430,6 +12443,7 @@ export declare function round(num: float, numDecimalPlaces?: number): float;
 export declare function runDeepCopyTests(): void;
 
 declare class RunInNFrames extends Feature {
+    vConditionalFunc: () => boolean;
     private postUpdate;
     private postRender;
     /**
@@ -12667,6 +12681,8 @@ declare class SaveDataManager extends Feature {
      * manage them for you. (See below for an example.)
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
+     * (Upgrade your mod before registering any of your own callbacks so that the save data manager
+     * will run before any of your code does.)
      *
      * The save data manager is meant to be called once for each feature of your mod. In other words,
      * you should not put all of the data for your mod on the same object. Instead, scope your
@@ -12723,10 +12739,6 @@ declare class SaveDataManager extends Feature {
      * supported. For the specific things that are supported, see the documentation for the `deepCopy`
      * helper function.
      *
-     * Note that before using the save data manager, you must call the `upgradeMod` function. (Upgrade
-     * your mod before registering any of your own callbacks so that the save data manager will run
-     * before any of your code does.)
-     *
      * If you want the save data manager to load data before the `POST_PLAYER_INIT` callback (i.e. in
      * the main menu), then you should explicitly call the `saveDataManagerLoad` function. (The save
      * data manager cannot do this on its own because it cannot know when your mod features are

package/dist/isaacscript-common.lua

@@ -1,6 +1,6 @@
 --[[
 
-isaacscript-common 15.3.0
+isaacscript-common 15.3.2
 
 This is the "isaacscript-common" library, which was created with the IsaacScript tool.
 
@@ -30390,6 +30390,7 @@ __TS__ClassExtends(RunInNFrames, Feature)
 function RunInNFrames.prototype.____constructor(self)
     Feature.prototype.____constructor(self)
     self.v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}, intervalGameFunctionTuples = {}, intervalRenderFunctionTuples = {}}}
+    self.vConditionalFunc = function() return false end
     self.postUpdate = function()
         local gameFrameCount = game:GetFrameCount()
         checkExecuteQueuedFunctions(nil, gameFrameCount, self.v.run.queuedGameFunctionTuples)
@@ -48341,8 +48342,9 @@ return ____exports
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
 local ____exports = {}
-local initDecoratedCallbacks, initSaveDataManager, WRAPPED_CALLBACK_METHODS_KEY, WRAPPED_CUSTOM_CALLBACK_METHODS_KEY
+local initDecoratedCallbacks, addCallback, removeCallback, initSaveDataManager, WRAPPED_CALLBACK_METHODS_KEY, WRAPPED_CUSTOM_CALLBACK_METHODS_KEY
 local ____array = require("src.functions.array")
 local isArray = ____array.isArray
 local ____deepCopy = require("src.functions.deepCopy")
@@ -48351,6 +48353,8 @@ local ____tstlClass = require("src.functions.tstlClass")
 local getTSTLClassConstructor = ____tstlClass.getTSTLClassConstructor
 local getTSTLClassName = ____tstlClass.getTSTLClassName
 local ____types = require("src.functions.types")
+local isFunction = ____types.isFunction
+local isNumber = ____types.isNumber
 local isTable = ____types.isTable
 function initDecoratedCallbacks(self, modFeature, constructor, tstlClassName, vanilla, init)
     local modFeatureConstructor = constructor
@@ -48368,53 +48372,90 @@ function initDecoratedCallbacks(self, modFeature, constructor, tstlClassName, va
         end
         local parameters = deepCopy(nil, args)
         local modCallback = table.remove(parameters, 1)
-        if modCallback == nil then
+        if not isNumber(nil, modCallback) then
             error("Failed to get the callback number from the parameters for class: " .. tstlClassName)
         end
         local callback = table.remove(parameters, 1)
-        if callback == nil then
+        if not isFunction(nil, callback) then
             error("Failed to get the callback function from the parameters for class: " .. tstlClassName)
         end
         local mod = modFeature.mod
         if init then
-            local function wrappedCallback(____, ...)
-                callback(modFeature, ...)
-            end
-            if vanilla then
-                local modCallbackVanilla = modCallback
-                local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-                wrappedMethodsMap:set(modCallbackVanilla, wrappedCallback)
-            else
-                local modCallbackCustom = modCallback
-                local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-                wrappedMethodsMap:set(modCallbackCustom, wrappedCallback)
-            end
-            if vanilla then
-                mod:AddCallback(
-                    modCallback,
-                    wrappedCallback,
-                    table.unpack(parameters)
-                )
-            else
-                mod:AddCallbackCustom(
-                    modCallback,
-                    wrappedCallback,
-                    table.unpack(parameters)
-                )
-            end
-        elseif vanilla then
-            local modCallbackVanilla = modCallback
-            local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-            local wrappedCallback = wrappedMethodsMap:get(modCallbackVanilla)
-            mod:RemoveCallback(modCallback, wrappedCallback)
+            addCallback(
+                nil,
+                modFeature,
+                modFeatureConstructor,
+                mod,
+                modCallback,
+                callback,
+                parameters,
+                vanilla
+            )
         else
-            local modCallbackCustom = modCallback
-            local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-            local wrappedCallback = wrappedMethodsMap:get(modCallbackCustom)
-            mod:RemoveCallbackCustom(modCallback, wrappedCallback)
+            removeCallback(
+                nil,
+                modFeatureConstructor,
+                mod,
+                modCallback,
+                vanilla
+            )
         end
     end
 end
+function addCallback(self, modFeature, modFeatureConstructor, mod, modCallback, callback, parameters, vanilla)
+    local function wrappedCallback(____, ...)
+        callback(nil, modFeature, ...)
+    end
+    if vanilla then
+        local modCallbackVanilla = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            wrappedMethodsMap = __TS__New(Map)
+            modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY] = wrappedMethodsMap
+        end
+        wrappedMethodsMap:set(modCallbackVanilla, wrappedCallback)
+    else
+        local modCallbackCustom = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            wrappedMethodsMap = __TS__New(Map)
+            modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY] = wrappedMethodsMap
+        end
+        wrappedMethodsMap:set(modCallbackCustom, wrappedCallback)
+    end
+    if vanilla then
+        mod:AddCallback(
+            modCallback,
+            wrappedCallback,
+            table.unpack(parameters)
+        )
+    else
+        mod:AddCallbackCustom(
+            modCallback,
+            wrappedCallback,
+            table.unpack(parameters)
+        )
+    end
+end
+function removeCallback(self, modFeatureConstructor, mod, modCallback, vanilla)
+    if vanilla then
+        local modCallbackVanilla = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            return
+        end
+        local wrappedCallback = wrappedMethodsMap:get(modCallbackVanilla)
+        mod:RemoveCallback(modCallback, wrappedCallback)
+    else
+        local modCallbackCustom = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            return
+        end
+        local wrappedCallback = wrappedMethodsMap:get(modCallbackCustom)
+        mod:RemoveCallbackCustom(modCallback, wrappedCallback)
+    end
+end
 function initSaveDataManager(self, modFeature, tstlClassName, init)
     local ____modFeature_0 = modFeature
     local v = ____modFeature_0.v
@@ -48450,6 +48491,7 @@ function ModFeature.prototype.____constructor(self, mod, init)
     if init == nil then
         init = true
     end
+    self.initialized = false
     self.mod = mod
     if init then
         self:init()
@@ -48459,11 +48501,15 @@ function ModFeature.prototype.init(self, init)
     if init == nil then
         init = true
     end
+    if self.initialized == init then
+        return
+    end
+    self.initialized = init
     local constructor = getTSTLClassConstructor(nil, self)
     if constructor == nil then
         error("Failed to get the TSTL class constructor for a mod feature.")
     end
-    local tstlClassName = getTSTLClassName(nil, constructor)
+    local tstlClassName = getTSTLClassName(nil, self)
     if tstlClassName == nil then
         error("Failed to get the TSTL class name for a mod feature.")
     end

package/dist/src/classes/ModFeature.d.ts

@@ -2,7 +2,7 @@ import { ModUpgradedBase } from "./ModUpgradedBase";
 export declare const ADD_CALLBACK_ARGS_KEY = "__addCallbackArgs";
 export declare const ADD_CALLBACK_CUSTOM_ARGS_KEY = "__addCallbackCustomArgs";
 /**
- * Helper class for mods that wants to represent their individual features as classes. Extend your
+ * Helper class for mods that want to represent their individual features as classes. Extend your
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
@@ -27,18 +27,31 @@ export declare const ADD_CALLBACK_CUSTOM_ARGS_KEY = "__addCallbackCustomArgs";
  * }
  * ```
  *
+ * When instantiating a feature class, you must pass your upgraded mod as the first argument to the
+ * constructor.
+ *
  * In almost all cases, you will want the callback functions to be immediately subscribed after
  * instantiating the class. However, if this is not the case, you can pass `false` as the optional
  * second argument to the constructor.
  */
 export declare class ModFeature {
     private mod;
+    private initialized;
     constructor(mod: ModUpgradedBase, init?: boolean);
     /**
      * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
      * callbacks. Additionally, subscribes the `v` object to the save data manager, if present.
+     *
+     * @param init Optional. Whether to initialize or uninitialize. Default is true.
      */
     init(init?: boolean): void;
+    /**
+     * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
+     * decorated callbacks. Additionally, unsubscribes the `v` object from the save data manager, if
+     * present.
+     *
+     * This is just an alias for `ModFeature.init(false)`.
+     */
     uninit(): void;
 }
 //# sourceMappingURL=ModFeature.d.ts.map

package/dist/src/classes/ModFeature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModFeature.d.ts","sourceRoot":"","sources":["../../../src/classes/ModFeature.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AACzD,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAWtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAkB;gBAEjB,GAAG,EAAE,eAAe,EAAE,IAAI,UAAO;IAQ7C;;;OAGG;IACI,IAAI,CAAC,IAAI,UAAO,GAAG,IAAI;IAgBvB,MAAM,IAAI,IAAI;CAGtB"}
+{"version":3,"file":"ModFeature.d.ts","sourceRoot":"","sources":["../../../src/classes/ModFeature.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AACzD,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAatE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,WAAW,CAAS;gBAEhB,GAAG,EAAE,eAAe,EAAE,IAAI,UAAO;IAQ7C;;;;;OAKG;IACI,IAAI,CAAC,IAAI,UAAO,GAAG,IAAI;IAqB9B;;;;;;OAMG;IACI,MAAM,IAAI,IAAI;CAGtB"}

package/dist/src/classes/ModFeature.lua

@@ -1,8 +1,9 @@
 local ____lualib = require("lualib_bundle")
 local __TS__Class = ____lualib.__TS__Class
 local Map = ____lualib.Map
+local __TS__New = ____lualib.__TS__New
 local ____exports = {}
-local initDecoratedCallbacks, initSaveDataManager, WRAPPED_CALLBACK_METHODS_KEY, WRAPPED_CUSTOM_CALLBACK_METHODS_KEY
+local initDecoratedCallbacks, addCallback, removeCallback, initSaveDataManager, WRAPPED_CALLBACK_METHODS_KEY, WRAPPED_CUSTOM_CALLBACK_METHODS_KEY
 local ____array = require("src.functions.array")
 local isArray = ____array.isArray
 local ____deepCopy = require("src.functions.deepCopy")
@@ -11,6 +12,8 @@ local ____tstlClass = require("src.functions.tstlClass")
 local getTSTLClassConstructor = ____tstlClass.getTSTLClassConstructor
 local getTSTLClassName = ____tstlClass.getTSTLClassName
 local ____types = require("src.functions.types")
+local isFunction = ____types.isFunction
+local isNumber = ____types.isNumber
 local isTable = ____types.isTable
 function initDecoratedCallbacks(self, modFeature, constructor, tstlClassName, vanilla, init)
     local modFeatureConstructor = constructor
@@ -28,53 +31,90 @@ function initDecoratedCallbacks(self, modFeature, constructor, tstlClassName, va
         end
         local parameters = deepCopy(nil, args)
         local modCallback = table.remove(parameters, 1)
-        if modCallback == nil then
+        if not isNumber(nil, modCallback) then
             error("Failed to get the callback number from the parameters for class: " .. tstlClassName)
         end
         local callback = table.remove(parameters, 1)
-        if callback == nil then
+        if not isFunction(nil, callback) then
             error("Failed to get the callback function from the parameters for class: " .. tstlClassName)
         end
         local mod = modFeature.mod
         if init then
-            local function wrappedCallback(____, ...)
-                callback(modFeature, ...)
-            end
-            if vanilla then
-                local modCallbackVanilla = modCallback
-                local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-                wrappedMethodsMap:set(modCallbackVanilla, wrappedCallback)
-            else
-                local modCallbackCustom = modCallback
-                local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-                wrappedMethodsMap:set(modCallbackCustom, wrappedCallback)
-            end
-            if vanilla then
-                mod:AddCallback(
-                    modCallback,
-                    wrappedCallback,
-                    table.unpack(parameters)
-                )
-            else
-                mod:AddCallbackCustom(
-                    modCallback,
-                    wrappedCallback,
-                    table.unpack(parameters)
-                )
-            end
-        elseif vanilla then
-            local modCallbackVanilla = modCallback
-            local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
-            local wrappedCallback = wrappedMethodsMap:get(modCallbackVanilla)
-            mod:RemoveCallback(modCallback, wrappedCallback)
+            addCallback(
+                nil,
+                modFeature,
+                modFeatureConstructor,
+                mod,
+                modCallback,
+                callback,
+                parameters,
+                vanilla
+            )
         else
-            local modCallbackCustom = modCallback
-            local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
-            local wrappedCallback = wrappedMethodsMap:get(modCallbackCustom)
-            mod:RemoveCallbackCustom(modCallback, wrappedCallback)
+            removeCallback(
+                nil,
+                modFeatureConstructor,
+                mod,
+                modCallback,
+                vanilla
+            )
         end
     end
 end
+function addCallback(self, modFeature, modFeatureConstructor, mod, modCallback, callback, parameters, vanilla)
+    local function wrappedCallback(____, ...)
+        callback(nil, modFeature, ...)
+    end
+    if vanilla then
+        local modCallbackVanilla = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            wrappedMethodsMap = __TS__New(Map)
+            modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY] = wrappedMethodsMap
+        end
+        wrappedMethodsMap:set(modCallbackVanilla, wrappedCallback)
+    else
+        local modCallbackCustom = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            wrappedMethodsMap = __TS__New(Map)
+            modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY] = wrappedMethodsMap
+        end
+        wrappedMethodsMap:set(modCallbackCustom, wrappedCallback)
+    end
+    if vanilla then
+        mod:AddCallback(
+            modCallback,
+            wrappedCallback,
+            table.unpack(parameters)
+        )
+    else
+        mod:AddCallbackCustom(
+            modCallback,
+            wrappedCallback,
+            table.unpack(parameters)
+        )
+    end
+end
+function removeCallback(self, modFeatureConstructor, mod, modCallback, vanilla)
+    if vanilla then
+        local modCallbackVanilla = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            return
+        end
+        local wrappedCallback = wrappedMethodsMap:get(modCallbackVanilla)
+        mod:RemoveCallback(modCallback, wrappedCallback)
+    else
+        local modCallbackCustom = modCallback
+        local wrappedMethodsMap = modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]
+        if wrappedMethodsMap == nil then
+            return
+        end
+        local wrappedCallback = wrappedMethodsMap:get(modCallbackCustom)
+        mod:RemoveCallbackCustom(modCallback, wrappedCallback)
+    end
+end
 function initSaveDataManager(self, modFeature, tstlClassName, init)
     local ____modFeature_0 = modFeature
     local v = ____modFeature_0.v
@@ -103,7 +143,7 @@ ____exports.ADD_CALLBACK_ARGS_KEY = "__addCallbackArgs"
 ____exports.ADD_CALLBACK_CUSTOM_ARGS_KEY = "__addCallbackCustomArgs"
 WRAPPED_CALLBACK_METHODS_KEY = "__wrappedCallbackMethods"
 WRAPPED_CUSTOM_CALLBACK_METHODS_KEY = "__wrappedCustomCallbacksMethods"
---- Helper class for mods that wants to represent their individual features as classes. Extend your
+--- Helper class for mods that want to represent their individual features as classes. Extend your
 -- mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
 -- that automatically subscribe to callbacks.
 -- 
@@ -128,6 +168,9 @@ WRAPPED_CUSTOM_CALLBACK_METHODS_KEY = "__wrappedCustomCallbacksMethods"
 -- }
 -- ```
 -- 
+-- When instantiating a feature class, you must pass your upgraded mod as the first argument to the
+-- constructor.
+-- 
 -- In almost all cases, you will want the callback functions to be immediately subscribed after
 -- instantiating the class. However, if this is not the case, you can pass `false` as the optional
 -- second argument to the constructor.
@@ -138,6 +181,7 @@ function ModFeature.prototype.____constructor(self, mod, init)
     if init == nil then
         init = true
     end
+    self.initialized = false
     self.mod = mod
     if init then
         self:init()
@@ -147,11 +191,15 @@ function ModFeature.prototype.init(self, init)
     if init == nil then
         init = true
     end
+    if self.initialized == init then
+        return
+    end
+    self.initialized = init
     local constructor = getTSTLClassConstructor(nil, self)
     if constructor == nil then
         error("Failed to get the TSTL class constructor for a mod feature.")
     end
-    local tstlClassName = getTSTLClassName(nil, constructor)
+    local tstlClassName = getTSTLClassName(nil, self)
     if tstlClassName == nil then
         error("Failed to get the TSTL class name for a mod feature.")
     end

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

@@ -1,6 +1,7 @@
 import { PlayerType } from "isaac-typescript-definitions";
 import { Feature } from "../../private/Feature";
 export declare class RunInNFrames extends Feature {
+    vConditionalFunc: () => boolean;
     private postUpdate;
     private postRender;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAgBhD,qBAAa,YAAa,SAAQ,OAAO;IAuBvC,OAAO,CAAC,UAAU,CAWhB;IAGF,OAAO,CAAC,UAAU,CAWhB;IAEF;;;;;;;;OAQG;IAEI,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAM3D;;;;;;;;;;;OAWG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAOhE;;;;;;;;;;;OAWG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C;;;;;;;;;OASG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD;;;;;;;;;;;;;;;;;OAiBG;IAEI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,GACtB,IAAI;IAWP;;;;;;;;;;;;;;;;;OAiBG;IAEI,uBAAuB,CAC5B,IAAI,EAAE,MAAM,OAAO,EACnB,YAAY,EAAE,GAAG,EACjB,cAAc,EAAE,OAAO,GACtB,IAAI;CAcR"}
+{"version":3,"file":"RunInNFrames.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/RunInNFrames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAKvE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAgBhD,qBAAa,YAAa,SAAQ,OAAO;IAavB,gBAAgB,QAAO,OAAO,CAAU;IAaxD,OAAO,CAAC,UAAU,CAWhB;IAGF,OAAO,CAAC,UAAU,CAWhB;IAEF;;;;;;;;OAQG;IAEI,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAM3D;;;;;;;;;;;OAWG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IAOhE;;;;;;;;;;;OAWG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,YAAY,EAAE,GAAG,GAAG,IAAI;IAOpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IAEI,gBAAgB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAI/C;;;;;;;;;OASG;IAEI,kBAAkB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD;;;;;;;;;;;;;;;;;OAiBG;IAEI,qBAAqB,CAC1B,IAAI,EAAE,MAAM,OAAO,EACnB,UAAU,EAAE,GAAG,EACf,cAAc,EAAE,OAAO,GACtB,IAAI;IAWP;;;;;;;;;;;;;;;;;OAiBG;IAEI,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

@@ -59,6 +59,7 @@ __TS__ClassExtends(RunInNFrames, Feature)
 function RunInNFrames.prototype.____constructor(self)
     Feature.prototype.____constructor(self)
     self.v = {run = {queuedGameFunctionTuples = {}, queuedRenderFunctionTuples = {}, intervalGameFunctionTuples = {}, intervalRenderFunctionTuples = {}}}
+    self.vConditionalFunc = function() return false end
     self.postUpdate = function()
         local gameFrameCount = game:GetFrameCount()
         checkExecuteQueuedFunctions(nil, gameFrameCount, self.v.run.queuedGameFunctionTuples)

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

@@ -54,6 +54,8 @@ export declare class SaveDataManager extends Feature {
      * manage them for you. (See below for an example.)
      *
      * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
+     * (Upgrade your mod before registering any of your own callbacks so that the save data manager
+     * will run before any of your code does.)
      *
      * The save data manager is meant to be called once for each feature of your mod. In other words,
      * you should not put all of the data for your mod on the same object. Instead, scope your
@@ -110,10 +112,6 @@ export declare class SaveDataManager extends Feature {
      * supported. For the specific things that are supported, see the documentation for the `deepCopy`
      * helper function.
      *
-     * Note that before using the save data manager, you must call the `upgradeMod` function. (Upgrade
-     * your mod before registering any of your own callbacks so that the save data manager will run
-     * before any of your code does.)
-     *
      * If you want the save data manager to load data before the `POST_PLAYER_INIT` callback (i.e. in
      * the main menu), then you should explicitly call the `saveDataManagerLoad` function. (The save
      * data manager cannot do this on its own because it cannot know when your mod features are

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

@@ -1 +1 @@
-{"version":3,"file":"SaveDataManager.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/SaveDataManager.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAMzD,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAsBhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;IACH,OAAO,CAAC,GAAG,CAAM;IAEjB;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAAkC;IAErD;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAkC;IAE7D;;;OAGG;IACH,OAAO,CAAC,0BAA0B,CAAuC;IAEzE;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B,CAAkC;IAErE;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAkC;IAG3D,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,qCAAqC,CAAS;IAyBtD,OAAO,CAAC,2BAA2B,CAUjC;IAGF,OAAO,CAAC,cAAc,CA0BpB;IAGF,OAAO,CAAC,WAAW,CAUjB;IAGF,OAAO,CAAC,YAAY,CAYlB;IAGF,OAAO,CAAC,gBAAgB,CAuBtB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmGG;IACI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAC3C,GAAG,EAAE,MAAM,EAAE,qEAAqE;IAClF,CAAC,EAAE,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,OAAO,GAC9B,IAAI;IACA,eAAe,CACpB,GAAG,EAAE,MAAM,EAAE,kEAAkE;IAC/E,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,KAAK,GACrB,IAAI;IAkDP;;OAEG;IACH,OAAO,CAAC,gCAAgC;IAgBxC;;;;;;;;;OASG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;;OAMG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;;;OAOG;IAEI,wBAAwB,IAAI,IAAI;IAIvC;;;;;;;;;;;OAWG;IAEI,4BAA4B,CAAC,GAAG,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI;IAcrE;;;;;OAKG;IAEI,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAoB/C;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEI,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,GAAG,IAAI;CAqB5E"}
+{"version":3,"file":"SaveDataManager.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/SaveDataManager.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAMzD,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAsBhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;IACH,OAAO,CAAC,GAAG,CAAM;IAEjB;;;;OAIG;IACH,OAAO,CAAC,WAAW,CAAkC;IAErD;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAkC;IAE7D;;;OAGG;IACH,OAAO,CAAC,0BAA0B,CAAuC;IAEzE;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B,CAAkC;IAErE;;;OAGG;IACH,OAAO,CAAC,iBAAiB,CAAkC;IAG3D,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,qCAAqC,CAAS;IAyBtD,OAAO,CAAC,2BAA2B,CAUjC;IAGF,OAAO,CAAC,cAAc,CA0BpB;IAGF,OAAO,CAAC,WAAW,CAUjB;IAGF,OAAO,CAAC,YAAY,CAYlB;IAGF,OAAO,CAAC,gBAAgB,CAuBtB;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiGG;IACI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAC3C,GAAG,EAAE,MAAM,EAAE,qEAAqE;IAClF,CAAC,EAAE,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,OAAO,GAC9B,IAAI;IACA,eAAe,CACpB,GAAG,EAAE,MAAM,EAAE,kEAAkE;IAC/E,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,KAAK,GACrB,IAAI;IAkDP;;OAEG;IACH,OAAO,CAAC,gCAAgC;IAgBxC;;;;;;;;;OASG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;;OAMG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;;;OAOG;IAEI,wBAAwB,IAAI,IAAI;IAIvC;;;;;;;;;;;OAWG;IAEI,4BAA4B,CAAC,GAAG,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI;IAcrE;;;;;OAKG;IAEI,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAoB/C;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEI,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,GAAG,IAAI;CAqB5E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "15.3.0",
+  "version": "15.3.2",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",
@@ -22,6 +22,6 @@
   "main": "dist/src/index",
   "types": "dist/src/index.d.ts",
   "dependencies": {
-    "isaac-typescript-definitions": "^9.0.3"
+    "isaac-typescript-definitions": "^9.0.4"
   }
 }

package/src/classes/ModFeature.ts

@@ -6,7 +6,7 @@ import {
   getTSTLClassConstructor,
   getTSTLClassName,
 } from "../functions/tstlClass";
-import { isTable } from "../functions/types";
+import { isFunction, isNumber, isTable } from "../functions/types";
 import { TSTLClassMetatable } from "../interfaces/TSTLClassMetatable";
 import { AnyFunction } from "../types/AnyFunction";
 import { ModUpgradedBase } from "./ModUpgradedBase";
@@ -19,12 +19,14 @@ const WRAPPED_CUSTOM_CALLBACK_METHODS_KEY = "__wrappedCustomCallbacksMethods";
 type ModFeatureConstructor = TSTLClassMetatable["constructor"] & {
   [ADD_CALLBACK_ARGS_KEY]: unknown | undefined;
   [ADD_CALLBACK_CUSTOM_ARGS_KEY]: unknown | undefined;
-  [WRAPPED_CALLBACK_METHODS_KEY]: Map<ModCallback, AnyFunction>;
-  [WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]: Map<ModCallbackCustom, AnyFunction>;
+  [WRAPPED_CALLBACK_METHODS_KEY]: Map<ModCallback, AnyFunction> | undefined;
+  [WRAPPED_CUSTOM_CALLBACK_METHODS_KEY]:
+    | Map<ModCallbackCustom, AnyFunction>
+    | undefined;
 };
 
 /**
- * Helper class for mods that wants to represent their individual features as classes. Extend your
+ * Helper class for mods that want to represent their individual features as classes. Extend your
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
@@ -49,6 +51,9 @@ type ModFeatureConstructor = TSTLClassMetatable["constructor"] & {
  * }
  * ```
  *
+ * When instantiating a feature class, you must pass your upgraded mod as the first argument to the
+ * constructor.
+ *
  * In almost all cases, you will want the callback functions to be immediately subscribed after
  * instantiating the class. However, if this is not the case, you can pass `false` as the optional
  * second argument to the constructor.
@@ -56,6 +61,7 @@ type ModFeatureConstructor = TSTLClassMetatable["constructor"] & {
 
 export class ModFeature {
   private mod: ModUpgradedBase;
+  private initialized = false;
 
   constructor(mod: ModUpgradedBase, init = true) {
     this.mod = mod;
@@ -68,14 +74,21 @@ export class ModFeature {
   /**
    * Runs the `Mod.AddCallback` and `ModUpgraded.AddCallbackCustom` methods for all of the decorated
    * callbacks. Additionally, subscribes the `v` object to the save data manager, if present.
+   *
+   * @param init Optional. Whether to initialize or uninitialize. Default is true.
    */
   public init(init = true): void {
+    if (this.initialized === init) {
+      return;
+    }
+    this.initialized = init;
+
     const constructor = getTSTLClassConstructor(this);
     if (constructor === undefined) {
       error("Failed to get the TSTL class constructor for a mod feature.");
     }
 
-    const tstlClassName = getTSTLClassName(constructor);
+    const tstlClassName = getTSTLClassName(this);
     if (tstlClassName === undefined) {
       error("Failed to get the TSTL class name for a mod feature.");
     }
@@ -85,6 +98,13 @@ export class ModFeature {
     initSaveDataManager(this, tstlClassName, init);
   }
 
+  /**
+   * Runs the `Mod.RemoveCallback` and `ModUpgraded.RemoveCallbackCustom` methods for all of the
+   * decorated callbacks. Additionally, unsubscribes the `v` object from the save data manager, if
+   * present.
+   *
+   * This is just an alias for `ModFeature.init(false)`.
+   */
   public uninit(): void {
     this.init(false);
   }
@@ -122,16 +142,14 @@ function initDecoratedCallbacks(
     const parameters = deepCopy(args);
 
     const modCallback = parameters.shift();
-    if (modCallback === undefined) {
+    if (!isNumber(modCallback)) {
       error(
         `Failed to get the callback number from the parameters for class: ${tstlClassName}`,
       );
     }
 
-    const callback = parameters.shift() as
-      | ((this: void, ...callbackArgs: unknown[]) => void)
-      | undefined;
-    if (callback === undefined) {
+    const callback = parameters.shift();
+    if (!isFunction(callback)) {
       error(
         `Failed to get the callback function from the parameters for class: ${tstlClassName}`,
       );
@@ -141,51 +159,99 @@ function initDecoratedCallbacks(
     const mod = modFeature["mod"];
 
     if (init) {
-      // We need to wrap the callback in a new function so that we can explicitly pass the class as
-      // the first argument. (Otherwise, the method will not be able to properly access `this`.
-      const wrappedCallback = (...callbackArgs: unknown[]) => {
-        callback(modFeature, ...callbackArgs);
-      };
-
-      // We need to save the wrapped function for later (so we can unregister them).
-      if (vanilla) {
-        const modCallbackVanilla = modCallback as ModCallback;
-        const wrappedMethodsMap =
-          modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY];
-        wrappedMethodsMap.set(modCallbackVanilla, wrappedCallback);
-      } else {
-        const modCallbackCustom = modCallback as ModCallbackCustom;
-        const wrappedMethodsMap =
-          modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY];
-        wrappedMethodsMap.set(modCallbackCustom, wrappedCallback);
-      }
-
-      if (vanilla) {
-        (mod.AddCallback as AnyFunction)(
-          modCallback,
-          wrappedCallback,
-          ...parameters,
-        );
-      } else {
-        (mod.AddCallbackCustom as AnyFunction)(
-          modCallback,
-          wrappedCallback,
-          ...parameters,
-        );
-      }
-    } else if (vanilla) {
-      const modCallbackVanilla = modCallback as ModCallback;
-      const wrappedMethodsMap =
-        modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY];
-      const wrappedCallback = wrappedMethodsMap.get(modCallbackVanilla);
-      (mod.RemoveCallback as AnyFunction)(modCallback, wrappedCallback);
+      addCallback(
+        modFeature,
+        modFeatureConstructor,
+        mod,
+        modCallback,
+        callback,
+        parameters,
+        vanilla,
+      );
     } else {
-      const modCallbackCustom = modCallback as ModCallbackCustom;
-      const wrappedMethodsMap =
-        modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY];
-      const wrappedCallback = wrappedMethodsMap.get(modCallbackCustom);
-      (mod.RemoveCallbackCustom as AnyFunction)(modCallback, wrappedCallback);
+      removeCallback(modFeatureConstructor, mod, modCallback, vanilla);
+    }
+  }
+}
+
+function addCallback(
+  modFeature: ModFeature,
+  modFeatureConstructor: ModFeatureConstructor,
+  mod: ModUpgradedBase,
+  modCallback: unknown,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  callback: Function,
+  parameters: unknown[],
+  vanilla: boolean,
+) {
+  // We need to wrap the callback in a new function so that we can explicitly pass the class as the
+  // first argument. (Otherwise, the method will not be able to properly access `this`.
+  const wrappedCallback = (...callbackArgs: unknown[]) => {
+    callback(modFeature, ...callbackArgs);
+  };
+
+  // We need to save the wrapped function for later (so we can unregister them).
+  if (vanilla) {
+    const modCallbackVanilla = modCallback as ModCallback;
+    let wrappedMethodsMap = modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY];
+    if (wrappedMethodsMap === undefined) {
+      wrappedMethodsMap = new Map();
+      modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY] = wrappedMethodsMap;
+    }
+    wrappedMethodsMap.set(modCallbackVanilla, wrappedCallback);
+  } else {
+    const modCallbackCustom = modCallback as ModCallbackCustom;
+    let wrappedMethodsMap =
+      modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY];
+    if (wrappedMethodsMap === undefined) {
+      wrappedMethodsMap = new Map();
+      modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY] =
+        wrappedMethodsMap;
     }
+    wrappedMethodsMap.set(modCallbackCustom, wrappedCallback);
+  }
+
+  if (vanilla) {
+    (mod.AddCallback as AnyFunction)(
+      modCallback,
+      wrappedCallback,
+      ...parameters,
+    );
+  } else {
+    (mod.AddCallbackCustom as AnyFunction)(
+      modCallback,
+      wrappedCallback,
+      ...parameters,
+    );
+  }
+}
+
+function removeCallback(
+  modFeatureConstructor: ModFeatureConstructor,
+  mod: ModUpgradedBase,
+  modCallback: unknown,
+  vanilla: boolean,
+) {
+  if (vanilla) {
+    const modCallbackVanilla = modCallback as ModCallback;
+    const wrappedMethodsMap =
+      modFeatureConstructor[WRAPPED_CALLBACK_METHODS_KEY];
+    if (wrappedMethodsMap === undefined) {
+      return;
+    }
+
+    const wrappedCallback = wrappedMethodsMap.get(modCallbackVanilla);
+    (mod.RemoveCallback as AnyFunction)(modCallback, wrappedCallback);
+  } else {
+    const modCallbackCustom = modCallback as ModCallbackCustom;
+    const wrappedMethodsMap =
+      modFeatureConstructor[WRAPPED_CUSTOM_CALLBACK_METHODS_KEY];
+    if (wrappedMethodsMap === undefined) {
+      return;
+    }
+
+    const wrappedCallback = wrappedMethodsMap.get(modCallbackCustom);
+    (mod.RemoveCallbackCustom as AnyFunction)(modCallback, wrappedCallback);
   }
 }
 

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

@@ -31,6 +31,9 @@ export class RunInNFrames extends Feature {
     },
   };
 
+  // eslint-disable-next-line class-methods-use-this
+  public override vConditionalFunc = (): boolean => false;
+
   /** @internal */
   constructor() {
     super();

package/src/classes/features/other/SaveDataManager.ts

@@ -210,6 +210,8 @@ export class SaveDataManager extends Feature {
    * manage them for you. (See below for an example.)
    *
    * In order to use this function, you must upgrade your mod with `ISCFeature.SAVE_DATA_MANAGER`.
+   * (Upgrade your mod before registering any of your own callbacks so that the save data manager
+   * will run before any of your code does.)
    *
    * The save data manager is meant to be called once for each feature of your mod. In other words,
    * you should not put all of the data for your mod on the same object. Instead, scope your
@@ -266,10 +268,6 @@ export class SaveDataManager extends Feature {
    * supported. For the specific things that are supported, see the documentation for the `deepCopy`
    * helper function.
    *
-   * Note that before using the save data manager, you must call the `upgradeMod` function. (Upgrade
-   * your mod before registering any of your own callbacks so that the save data manager will run
-   * before any of your code does.)
-   *
    * If you want the save data manager to load data before the `POST_PLAYER_INIT` callback (i.e. in
    * the main menu), then you should explicitly call the `saveDataManagerLoad` function. (The save
    * data manager cannot do this on its own because it cannot know when your mod features are