isaacscript-common 14.1.3 → 14.2.0

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

@@ -0,0 +1,215 @@
+/// <reference types="isaac-typescript-definitions" />
+import { SaveDataKey } from "../../../enums/SaveDataKey";
+import { SaveData } from "../../../interfaces/SaveData";
+import { AnyClass } from "../../../types/AnyClass";
+import { Feature } from "../../private/Feature";
+export declare class SaveDataManager extends Feature {
+    /**
+     * We store a local reference to the mod object so that we can access the corresponding methods
+     * that read and write to the "save#.dat" file.
+     */
+    private mod;
+    /**
+     * The save data map is indexed by subscriber name. We use Lua tables instead of TypeScriptToLua
+     * Maps for the master map so that we can access the variables via the in-game console when
+     * debugging. (TSTL Maps don't expose the map keys as normal keys.)
+     */
+    private saveDataMap;
+    /**
+     * When mod feature data is initialized, we copy the initial values into a separate map so that we
+     * can restore them later on.
+     */
+    private saveDataDefaultsMap;
+    /**
+     * Each mod feature can optionally provide a function that can control whether or not the save
+     * data is written to disk.
+     */
+    private saveDataConditionalFuncMap;
+    /**
+     * We backup some save data keys on every new room for the purposes of restoring it when Glowing
+     * Hour Glass is used.
+     *
+     * Note that the save data is backed up in serialized form so that we can use the `merge` function
+     * to restore it.
+     */
+    private saveDataGlowingHourGlassMap;
+    /**
+     * End-users can register their classes with the save data manager for proper serialization when
+     * contained in nested maps, sets, and arrays.
+     */
+    private classConstructors;
+    private loadedDataOnThisRun;
+    private restoreGlowingHourGlassDataOnNextRoom;
+    constructor(mod: Mod);
+    private postUseItemGlowingHourGlass;
+    private postPlayerInit;
+    private preGameExit;
+    private postNewLevel;
+    private postNewRoomEarly;
+    /**
+     * This is the entry point to the save data manager, a system which provides two major features:
+     *
+     * 1. automatic resetting of variables on a new run, on a new level, or on a new room (as desired)
+     * 2. automatic saving and loading of all tracked data to the "save#.dat" file
+     *
+     * You feed this function with an object containing your variables, and then it will automatically
+     * manage them for you. (See below for an example.)
+     *
+     * 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
+     * variables locally to a single file that contains a mod feature, and then call this function to
+     * register them. For example:
+     *
+     * ```ts
+     * // In file: feature1.ts
+     * import { saveDataManager } from "isaacscript-common";
+     *
+     * // Declare local variables for this file or feature.
+     * const v = {
+     *   // These variables are never reset; manage them yourself at will.
+     *   persistent: {
+     *     foo1: 0,
+     *   },
+     *
+     *   // These variables are reset at the beginning of every run.
+     *   run: {
+     *     foo2: 0,
+     *   },
+     *
+     *   // These variables are reset at the beginning of every level.
+     *   level: {
+     *     foo3: 0,
+     *   },
+     *
+     *   // These variables are reset at the beginning of every room.
+     *   room: {
+     *     foo4: 0,
+     *   },
+     * };
+     * // Every child object is optional; only create the ones that you need.
+     *
+     * // Register the variables with the save data manager. (We need to provide a string key that
+     * // matches the name of this file.)
+     * function feature1Init() {
+     *   saveDataManager("feature1", v);
+     * }
+     *
+     * // Elsewhere in the file, use your variables.
+     * function feature1Function() {
+     *   if (v.run.foo1 > 0) {
+     *     // Insert code here.
+     *   }
+     * }
+     * ```
+     *
+     * - Save data is loaded from disk in the `POST_PLAYER_INIT` callback (i.e. the first callback
+     *   that can possibly run).
+     * - Save data is recorded to disk in the `PRE_GAME_EXIT` callback.
+     *
+     * You can use many different variable types on your variable object, but not everything is
+     * 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
+     * finished initializing.)
+     *
+     * Some features may have variables that need to be automatically reset per run/level, but not
+     * saved to disk on game exit. (For example, if they contain functions or other non-serializable
+     * data.) For these cases, set the second argument to `false`.
+     *
+     * Note that when the player uses Glowing Hour Glass, the save data manager will automatically
+     * restore any variables on a "run" or "level" object with a backup that was created when the room
+     * was entered. Thus, you should not have to explicitly program support for Glowing Hour Glass
+     * into your mod features that use the save data manager. If this is undesired for your specific
+     * use-case, then add a key of `__ignoreGlowingHourGlass: true` to your "run" or "level" object.
+     *
+     * @param key The name of the file or feature that is submitting data to be managed by the save
+     *            data manager. The save data manager will throw an error if the key is already
+     *            registered.
+     * @param v An object that corresponds to the `SaveData` interface. The object is conventionally
+     *          called "v" for brevity. ("v" is short for "local variables").
+     * @param conditionalFunc Optional. A function to run to check if this save data should be written
+     *                        to disk. Default is `() => true`, meaning that this save data will
+     *                        always be written to disk. Use a conditional function for the situations
+     *                        when the local variables are for a feature that the end-user can
+     *                        disable. (If the feature is disabled, then there would be no point in
+     *                        writing any of the variables to the "save#.dat" file.) You can also
+     *                        specify `false` to this argument in order to completely disable saving
+     *                        data. (Specifying `false` will allow you to use non-serializable objects
+     *                        in your save data, such as `EntityPtr`.
+     */
+    saveDataManager<Persistent, Run, Level>(key: string, // This is the overload for the standard case with serializable data.
+    v: SaveData<Persistent, Run, Level>, conditionalFunc?: () => boolean): void;
+    saveDataManager(key: string, // This is the overload for the case when saving data is disabled.
+    v: SaveData, conditionalFunc: false): void;
+    /**
+     * Recursively traverses an object, collecting all of the class constructors that it encounters.
+     */
+    private storeClassConstructorsFromObject;
+    /**
+     * The save data manager will automatically load variables from disk at the appropriate times
+     * (i.e. when a new run is started). Use this function to explicitly force the save data manager
+     * to load all of its variables from disk immediately.
+     *
+     * Obviously, doing this will overwrite the current data, so using this function can potentially
+     * result in lost state.
+     */
+    saveDataManagerLoad(): void;
+    /**
+     * The save data manager will automatically save variables to disk at the appropriate times (i.e.
+     * when the run is exited). Use this function to explicitly force the save data manager to write
+     * all of its variables to disk immediately.
+     */
+    saveDataManagerSave(): void;
+    /**
+     * Sets the global variable of "g" equal to all of the save data variables for this mod.
+     *
+     * This can make debugging easier, as you can access the variables from the game's debug console.
+     * e.g. `l print(g.feature1.run.foo)`
+     */
+    saveDataManagerSetGlobal(): void;
+    /**
+     * By default, the save data manager will not be able to serialize/deserialize classes that are
+     * nested inside of maps, sets, and arrays, because it does not have access to the corresponding
+     * class constructor. If you want to use nested classes in this way, then use this function to
+     * register the class constructor with the save data manager. Once registered, the save data
+     * manager will automatically run the constructor when deserializing (in addition to copying over
+     * the data fields).
+     *
+     * This function is variadic, which means you can pass as many classes as you want to register.
+     */
+    saveDataManagerRegisterClass(...tstlClasses: AnyClass[]): void;
+    /**
+     * Removes a previously registered key from the save data manager. This is the opposite of the
+     * "saveDataManager" method.
+     */
+    saveDataManagerRemove(key: string): void;
+    /**
+     * The save data manager will automatically reset variables at the appropriate times, like when a
+     * player enters a new room. Use this function to explicitly force the save data manager to reset
+     * a specific variable group.
+     *
+     * For example:
+     *
+     * ```ts
+     * const v = {
+     *   room: {
+     *     foo: 123,
+     *   },
+     * };
+     *
+     * mod.saveDataManager("file1", v);
+     *
+     * // Then, later on, to explicit reset all of the "room" variables:
+     * mod.saveDataManagerReset("file1", "room");
+     * ```
+     */
+    saveDataManagerReset(key: string, childObjectKey: SaveDataKey): void;
+}
+//# sourceMappingURL=SaveDataManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SaveDataManager.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/SaveDataManager.ts"],"names":[],"mappings":";AAGA,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;gBAE1C,GAAG,EAAE,GAAG;IAkBpB,OAAO,CAAC,2BAA2B,CAGjC;IAIF,OAAO,CAAC,cAAc,CA0BpB;IAGF,OAAO,CAAC,WAAW,CAUjB;IAGF,OAAO,CAAC,YAAY,CAYlB;IAGF,OAAO,CAAC,gBAAgB,CAuBtB;IAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;OAOG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;OAIG;IAEI,mBAAmB,IAAI,IAAI;IAIlC;;;;;OAKG;IAEI,wBAAwB,IAAI,IAAI;IAIvC;;;;;;;;;OASG;IAEI,4BAA4B,CAAC,GAAG,WAAW,EAAE,QAAQ,EAAE,GAAG,IAAI;IAcrE;;;OAGG;IAEI,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAoB/C;;;;;;;;;;;;;;;;;;;OAmBG;IAEI,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,GAAG,IAAI;CAqB5E"}

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

@@ -0,0 +1,190 @@
+local ____lualib = require("lualib_bundle")
+local Set = ____lualib.Set
+local __TS__New = ____lualib.__TS__New
+local __TS__Class = ____lualib.__TS__Class
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local __TS__TypeOf = ____lualib.__TS__TypeOf
+local __TS__ObjectKeys = ____lualib.__TS__ObjectKeys
+local __TS__Decorate = ____lualib.__TS__Decorate
+local ____exports = {}
+local ____isaac_2Dtypescript_2Ddefinitions = require("isaac-typescript-definitions")
+local CollectibleType = ____isaac_2Dtypescript_2Ddefinitions.CollectibleType
+local ModCallback = ____isaac_2Dtypescript_2Ddefinitions.ModCallback
+local ____cachedClasses = require("src.core.cachedClasses")
+local game = ____cachedClasses.game
+local ____decorators = require("src.decorators")
+local Exported = ____decorators.Exported
+local ____SaveDataKey = require("src.enums.SaveDataKey")
+local SaveDataKey = ____SaveDataKey.SaveDataKey
+local ____SerializationType = require("src.enums.SerializationType")
+local SerializationType = ____SerializationType.SerializationType
+local ____deepCopy = require("src.functions.deepCopy")
+local deepCopy = ____deepCopy.deepCopy
+local ____stage = require("src.functions.stage")
+local onFirstFloor = ____stage.onFirstFloor
+local ____tstlClass = require("src.functions.tstlClass")
+local getTSTLClassName = ____tstlClass.getTSTLClassName
+local ____types = require("src.functions.types")
+local isString = ____types.isString
+local isTable = ____types.isTable
+local ____Feature = require("src.classes.private.Feature")
+local Feature = ____Feature.Feature
+local ____glowingHourGlass = require("src.classes.features.other.saveDataManager.glowingHourGlass")
+local makeGlowingHourGlassBackup = ____glowingHourGlass.makeGlowingHourGlassBackup
+local restoreGlowingHourGlassBackup = ____glowingHourGlass.restoreGlowingHourGlassBackup
+local ____loadFromDisk = require("src.classes.features.other.saveDataManager.loadFromDisk")
+local loadFromDisk = ____loadFromDisk.loadFromDisk
+local ____restoreDefaults = require("src.classes.features.other.saveDataManager.restoreDefaults")
+local restoreDefaultForFeatureKey = ____restoreDefaults.restoreDefaultForFeatureKey
+local restoreDefaultsForAllFeaturesAndKeys = ____restoreDefaults.restoreDefaultsForAllFeaturesAndKeys
+local restoreDefaultsForAllFeaturesKey = ____restoreDefaults.restoreDefaultsForAllFeaturesKey
+local ____saveToDisk = require("src.classes.features.other.saveDataManager.saveToDisk")
+local saveToDisk = ____saveToDisk.saveToDisk
+local NON_USER_DEFINED_CLASS_NAMES = __TS__New(Set, {"Map", "Set", "DefaultMap"})
+____exports.SaveDataManager = __TS__Class()
+local SaveDataManager = ____exports.SaveDataManager
+SaveDataManager.name = "SaveDataManager"
+__TS__ClassExtends(SaveDataManager, Feature)
+function SaveDataManager.prototype.____constructor(self, mod)
+    Feature.prototype.____constructor(self)
+    self.saveDataMap = {}
+    self.saveDataDefaultsMap = {}
+    self.saveDataConditionalFuncMap = {}
+    self.saveDataGlowingHourGlassMap = {}
+    self.classConstructors = {}
+    self.loadedDataOnThisRun = false
+    self.restoreGlowingHourGlassDataOnNextRoom = false
+    self.postUseItemGlowingHourGlass = function()
+        self.restoreGlowingHourGlassDataOnNextRoom = true
+        return nil
+    end
+    self.postPlayerInit = function()
+        if self.loadedDataOnThisRun then
+            return
+        end
+        self.loadedDataOnThisRun = true
+        self.restoreGlowingHourGlassDataOnNextRoom = false
+        loadFromDisk(nil, self.mod, self.saveDataMap, self.classConstructors)
+        local gameFrameCount = game:GetFrameCount()
+        local isContinued = gameFrameCount ~= 0
+        if not isContinued then
+            restoreDefaultsForAllFeaturesAndKeys(nil, self.saveDataMap, self.saveDataDefaultsMap)
+        end
+    end
+    self.preGameExit = function()
+        saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+        restoreDefaultsForAllFeaturesAndKeys(nil, self.saveDataMap, self.saveDataDefaultsMap)
+        self.loadedDataOnThisRun = false
+    end
+    self.postNewLevel = function()
+        restoreDefaultsForAllFeaturesKey(nil, self.saveDataMap, self.saveDataDefaultsMap, SaveDataKey.LEVEL)
+        if not onFirstFloor(nil) then
+            saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+        end
+    end
+    self.postNewRoomEarly = function()
+        restoreDefaultsForAllFeaturesKey(nil, self.saveDataMap, self.saveDataDefaultsMap, SaveDataKey.ROOM)
+        if self.restoreGlowingHourGlassDataOnNextRoom then
+            self.restoreGlowingHourGlassDataOnNextRoom = false
+            restoreGlowingHourGlassBackup(
+                nil,
+                self.saveDataMap,
+                self.saveDataConditionalFuncMap,
+                self.saveDataGlowingHourGlassMap,
+                self.classConstructors
+            )
+        else
+            makeGlowingHourGlassBackup(nil, self.saveDataMap, self.saveDataConditionalFuncMap, self.saveDataGlowingHourGlassMap)
+        end
+    end
+    self.callbacksUsed = {{ModCallback.POST_USE_ITEM, {self.postUseItemGlowingHourGlass, CollectibleType.GLOWING_HOUR_GLASS}}, {ModCallback.POST_PLAYER_INIT, {self.postPlayerInit}}, {ModCallback.PRE_GAME_EXIT, {self.preGameExit}}, {ModCallback.POST_NEW_LEVEL, {self.postNewLevel}}}
+    self.mod = mod
+end
+function SaveDataManager.prototype.saveDataManager(self, key, v, conditionalFunc)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    if self.saveDataMap[key] ~= nil then
+        error("The save data manager is already managing save data for a key of: " .. key)
+    end
+    self:storeClassConstructorsFromObject(v)
+    self.saveDataMap[key] = v
+    if conditionalFunc == false then
+        conditionalFunc = function() return false end
+    end
+    local saveDataKeys = __TS__ObjectKeys(v)
+    if #saveDataKeys == 1 and saveDataKeys[1] == "room" then
+        conditionalFunc = function() return false end
+    end
+    local saveDataCopy = deepCopy(nil, v, SerializationType.NONE, key)
+    self.saveDataDefaultsMap[key] = saveDataCopy
+    if conditionalFunc ~= nil then
+        self.saveDataConditionalFuncMap[key] = conditionalFunc
+    end
+end
+function SaveDataManager.prototype.storeClassConstructorsFromObject(self, luaMap)
+    local tstlClassName = getTSTLClassName(nil, luaMap)
+    if tstlClassName ~= nil and not NON_USER_DEFINED_CLASS_NAMES:has(tstlClassName) then
+        self.classConstructors[tstlClassName] = luaMap
+    end
+    for _key, value in pairs(luaMap) do
+        if isTable(nil, value) then
+            self:storeClassConstructorsFromObject(value)
+        end
+    end
+end
+function SaveDataManager.prototype.saveDataManagerLoad(self)
+    loadFromDisk(nil, self.mod, self.saveDataMap, self.classConstructors)
+end
+function SaveDataManager.prototype.saveDataManagerSave(self)
+    saveToDisk(nil, self.mod, self.saveDataMap, self.saveDataConditionalFuncMap)
+end
+function SaveDataManager.prototype.saveDataManagerSetGlobal(self)
+    g = self.saveDataMap
+end
+function SaveDataManager.prototype.saveDataManagerRegisterClass(self, ...)
+    local tstlClasses = {...}
+    for ____, tstlClass in ipairs(tstlClasses) do
+        local name = tstlClass.name
+        if name == nil then
+            error("Failed to register a class with the save data manager due to not being able to derive the name of the class.")
+        end
+        self.classConstructors[name] = tstlClass
+    end
+end
+function SaveDataManager.prototype.saveDataManagerRemove(self, key)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    if not (self.saveDataMap[key] ~= nil) then
+        error("The save data manager is not managing save data for a key of: " .. key)
+    end
+    self.saveDataMap[key] = nil
+    self.saveDataDefaultsMap[key] = nil
+    self.saveDataConditionalFuncMap[key] = nil
+    self.saveDataGlowingHourGlassMap[key] = nil
+end
+function SaveDataManager.prototype.saveDataManagerReset(self, key, childObjectKey)
+    if not isString(nil, key) then
+        error("The save data manager requires that keys are strings. You tried to use a key of type: " .. __TS__TypeOf(key))
+    end
+    local saveData = self.saveDataMap[key]
+    if saveData == nil then
+        error("The save data manager is not managing save data for a key of: " .. key)
+    end
+    restoreDefaultForFeatureKey(
+        nil,
+        self.saveDataDefaultsMap,
+        key,
+        saveData,
+        childObjectKey
+    )
+end
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManager", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerLoad", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerSave", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerSetGlobal", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerRegisterClass", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerRemove", true)
+__TS__Decorate({Exported}, SaveDataManager.prototype, "saveDataManagerReset", true)
+return ____exports

package/dist/src/classes/features/other/saveDataManager/glowingHourGlass.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+import { SaveData } from "../../../../interfaces/SaveData";
+import { AnyClass } from "../../../../types/AnyClass";
+export declare function makeGlowingHourGlassBackup(saveDataMap: LuaMap<string, SaveData>, saveDataConditionalFuncMap: LuaMap<string, () => boolean>, saveDataGlowingHourGlassMap: LuaMap<string, SaveData>): void;
+export declare function restoreGlowingHourGlassBackup(saveDataMap: LuaMap<string, SaveData>, saveDataConditionalFuncMap: LuaMap<string, () => boolean>, saveDataGlowingHourGlassMap: LuaMap<string, SaveData>, classConstructors: LuaMap<string, AnyClass>): void;
+//# sourceMappingURL=glowingHourGlass.d.ts.map

package/dist/src/classes/features/other/saveDataManager/glowingHourGlass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glowingHourGlass.d.ts","sourceRoot":"","sources":["../../../../../../src/classes/features/other/saveDataManager/glowingHourGlass.ts"],"names":[],"mappings":";AASA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAatD,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,EACzD,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GACpD,IAAI,CAkDN;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,EACzD,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrD,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC1C,IAAI,CAqDN"}

package/dist/src/classes/features/other/saveDataManager/glowingHourGlass.lua

@@ -0,0 +1,98 @@
+local ____exports = {}
+local ____SaveDataKey = require("src.enums.SaveDataKey")
+local SaveDataKey = ____SaveDataKey.SaveDataKey
+local ____SerializationType = require("src.enums.SerializationType")
+local SerializationType = ____SerializationType.SerializationType
+local ____constants = require("src.features.saveDataManager.constants")
+local SAVE_DATA_MANAGER_DEBUG = ____constants.SAVE_DATA_MANAGER_DEBUG
+local ____deepCopy = require("src.functions.deepCopy")
+local deepCopy = ____deepCopy.deepCopy
+local ____merge = require("src.functions.merge")
+local merge = ____merge.merge
+local ____table = require("src.functions.table")
+local iterateTableInOrder = ____table.iterateTableInOrder
+--- When the Glowing Hour Glass is used, certain save data keys will automatically be restored to a
+-- backup.
+local GLOWING_HOUR_GLASS_BACKUP_KEYS = {SaveDataKey.RUN, SaveDataKey.LEVEL}
+local IGNORE_GLOWING_HOUR_GLASS_KEY = "__ignoreGlowingHourGlass"
+function ____exports.makeGlowingHourGlassBackup(self, saveDataMap, saveDataConditionalFuncMap, saveDataGlowingHourGlassMap)
+    iterateTableInOrder(
+        nil,
+        saveDataMap,
+        function(____, subscriberName, saveData)
+            local conditionalFunc = saveDataConditionalFuncMap[subscriberName]
+            if conditionalFunc ~= nil then
+                local shouldSave = conditionalFunc(nil)
+                if not shouldSave then
+                    return
+                end
+            end
+            for ____, saveDataKey in ipairs(GLOWING_HOUR_GLASS_BACKUP_KEYS) do
+                do
+                    local childTable = saveData[saveDataKey]
+                    if childTable == nil then
+                        goto __continue6
+                    end
+                    local childTableLuaMap = childTable
+                    if childTableLuaMap[IGNORE_GLOWING_HOUR_GLASS_KEY] ~= nil then
+                        goto __continue6
+                    end
+                    local saveDataGlowingHourGlass = saveDataGlowingHourGlassMap[subscriberName]
+                    if saveDataGlowingHourGlass == nil then
+                        saveDataGlowingHourGlass = {}
+                        saveDataGlowingHourGlassMap[subscriberName] = saveDataGlowingHourGlass
+                    end
+                    local copiedChildTable = deepCopy(nil, childTable, SerializationType.SERIALIZE)
+                    saveDataGlowingHourGlass[saveDataKey] = copiedChildTable
+                end
+                ::__continue6::
+            end
+        end,
+        SAVE_DATA_MANAGER_DEBUG
+    )
+end
+function ____exports.restoreGlowingHourGlassBackup(self, saveDataMap, saveDataConditionalFuncMap, saveDataGlowingHourGlassMap, classConstructors)
+    iterateTableInOrder(
+        nil,
+        saveDataMap,
+        function(____, subscriberName, saveData)
+            local conditionalFunc = saveDataConditionalFuncMap[subscriberName]
+            if conditionalFunc ~= nil then
+                local shouldSave = conditionalFunc(nil)
+                if not shouldSave then
+                    return
+                end
+            end
+            for ____, saveDataKey in ipairs(GLOWING_HOUR_GLASS_BACKUP_KEYS) do
+                do
+                    local childTable = saveData[saveDataKey]
+                    if childTable == nil then
+                        goto __continue15
+                    end
+                    local childTableLuaMap = childTable
+                    if childTableLuaMap[IGNORE_GLOWING_HOUR_GLASS_KEY] ~= nil then
+                        goto __continue15
+                    end
+                    local saveDataGlowingHourGlass = saveDataGlowingHourGlassMap[subscriberName]
+                    if saveDataGlowingHourGlass == nil then
+                        goto __continue15
+                    end
+                    local childTableBackup = saveDataGlowingHourGlass[saveDataKey]
+                    if childTableBackup == nil then
+                        goto __continue15
+                    end
+                    merge(
+                        nil,
+                        childTable,
+                        childTableBackup,
+                        subscriberName .. "__glowingHourGlass",
+                        classConstructors
+                    )
+                end
+                ::__continue15::
+            end
+        end,
+        SAVE_DATA_MANAGER_DEBUG
+    )
+end
+return ____exports

package/dist/src/classes/features/other/saveDataManager/loadFromDisk.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="isaac-typescript-definitions" />
+/// <reference types="@typescript-to-lua/language-extensions" />
+import { SaveData } from "../../../../interfaces/SaveData";
+import { AnyClass } from "../../../../types/AnyClass";
+export declare function loadFromDisk(mod: Mod, oldSaveData: LuaMap<string, SaveData>, classConstructors: LuaMap<string, AnyClass>): void;
+//# sourceMappingURL=loadFromDisk.d.ts.map

package/dist/src/classes/features/other/saveDataManager/loadFromDisk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadFromDisk.d.ts","sourceRoot":"","sources":["../../../../../../src/classes/features/other/saveDataManager/loadFromDisk.ts"],"names":[],"mappings":";;AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAItD,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC1C,IAAI,CAsDN"}

package/dist/src/classes/features/other/saveDataManager/loadFromDisk.lua

@@ -0,0 +1,81 @@
+local ____lualib = require("lualib_bundle")
+local __TS__StringTrim = ____lualib.__TS__StringTrim
+local ____exports = {}
+local readSaveDatFile, tryLoadModData, DEFAULT_MOD_DATA
+local ____constants = require("src.features.saveDataManager.constants")
+local SAVE_DATA_MANAGER_DEBUG = ____constants.SAVE_DATA_MANAGER_DEBUG
+local ____jsonHelpers = require("src.functions.jsonHelpers")
+local jsonDecode = ____jsonHelpers.jsonDecode
+local ____log = require("src.functions.log")
+local log = ____log.log
+local ____logMisc = require("src.functions.logMisc")
+local logError = ____logMisc.logError
+local ____merge = require("src.functions.merge")
+local merge = ____merge.merge
+local ____table = require("src.functions.table")
+local iterateTableInOrder = ____table.iterateTableInOrder
+local ____types = require("src.functions.types")
+local isString = ____types.isString
+local isTable = ____types.isTable
+function readSaveDatFile(self, mod)
+    local renderFrameCount = Isaac.GetFrameCount()
+    local ok, jsonStringOrErrMsg = pcall(tryLoadModData, mod)
+    if not ok then
+        logError(
+            nil,
+            (("Failed to read from the \"save#.dat\" file on render frame " .. tostring(renderFrameCount)) .. ": ") .. jsonStringOrErrMsg
+        )
+        return DEFAULT_MOD_DATA
+    end
+    if jsonStringOrErrMsg == nil then
+        return DEFAULT_MOD_DATA
+    end
+    local jsonStringTrimmed = __TS__StringTrim(jsonStringOrErrMsg)
+    if jsonStringTrimmed == "" then
+        return DEFAULT_MOD_DATA
+    end
+    return jsonStringTrimmed
+end
+function tryLoadModData(mod)
+    return mod:LoadData()
+end
+DEFAULT_MOD_DATA = "{}"
+function ____exports.loadFromDisk(self, mod, oldSaveData, classConstructors)
+    if not mod:HasData() then
+        return
+    end
+    local jsonString = readSaveDatFile(nil, mod)
+    local newSaveData = jsonDecode(nil, jsonString)
+    if SAVE_DATA_MANAGER_DEBUG then
+        log(nil, "Converted data from the \"save#.dat\" to a Lua table.")
+    end
+    iterateTableInOrder(
+        nil,
+        newSaveData,
+        function(____, subscriberName, saveData)
+            if not isString(nil, subscriberName) then
+                return
+            end
+            if not isTable(nil, saveData) then
+                return
+            end
+            local oldSaveDataForSubscriber = oldSaveData[subscriberName]
+            if oldSaveDataForSubscriber == nil then
+                return
+            end
+            if SAVE_DATA_MANAGER_DEBUG then
+                log(nil, "Merging in stored data for feature: " .. subscriberName)
+            end
+            merge(
+                nil,
+                oldSaveDataForSubscriber,
+                saveData,
+                subscriberName,
+                classConstructors
+            )
+        end,
+        SAVE_DATA_MANAGER_DEBUG
+    )
+    log(nil, "The save data manager loaded data from the \"save#.dat\" file.")
+end
+return ____exports

package/dist/src/classes/features/other/saveDataManager/restoreDefaults.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="@typescript-to-lua/language-extensions" />
+import { SaveDataKey } from "../../../../enums/SaveDataKey";
+import { SaveData } from "../../../../interfaces/SaveData";
+export declare function restoreDefaultsForAllFeaturesAndKeys(saveDataMap: LuaMap<string, SaveData>, saveDataDefaultsMap: LuaMap<string, SaveData>): void;
+export declare function restoreDefaultsForAllFeaturesKey(saveDataMap: LuaMap<string, SaveData>, saveDataDefaultsMap: LuaMap<string, SaveData>, saveDataKey: SaveDataKey): void;
+export declare function restoreDefaultForFeatureKey(saveDataDefaultsMap: LuaMap<string, SaveData>, subscriberName: string, saveData: SaveData, saveDataKey: SaveDataKey): void;
+//# sourceMappingURL=restoreDefaults.d.ts.map

package/dist/src/classes/features/other/saveDataManager/restoreDefaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restoreDefaults.d.ts","sourceRoot":"","sources":["../../../../../../src/classes/features/other/saveDataManager/restoreDefaults.ts"],"names":[],"mappings":";AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAM5D,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAQ3D,wBAAgB,oCAAoC,CAClD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAC5C,IAAI,CAQN;AAED,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACrC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC7C,WAAW,EAAE,WAAW,GACvB,IAAI,CAaN;AAED,wBAAgB,2BAA2B,CACzC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC7C,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,WAAW,GACvB,IAAI,CA8CN"}