isaacscript-common 30.12.8 → 30.12.9

package/dist/index.rollup.d.ts

@@ -7566,16 +7566,16 @@ export declare function inHomeCloset(): boolean;
  * For example:
  *
  * ```ts
- * const features = [
+ * const MOD_FEATURES = [
  *   MyFeature1,
  *   MyFeature2,
  *   MyFeature3,
  * ] as const;
- * initModFeatures(mod, modFeatures);
+ * initModFeatures(mod, MOD_FEATURES);
  * ```
  *
  * @returns An array of the instantiated features in the same order that the constructors were
- *          passed in.
+ *          passed in. (In most cases, you probably won't need the returned array.)
  */
 export declare function initModFeatures<T extends ReadonlyArray<typeof ModFeature>>(mod: ModUpgraded, modFeatures: T): {
     [K in keyof T]: InstanceType<T[K]>;
@@ -12798,24 +12798,22 @@ declare class ModdedElementSets extends Feature {
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
- * When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
- * the constructor.
+ * It is recommended that you use the `initModFeatures` helper function to instantiate all of your
+ * mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
+ * are properly registered with the save data manager; see below.
  *
- * If your feature has variables that are managed by the save data manager, you need to explicitly
- * register them with the save data manager yourself in your class constructor. (It can't be
- * automatically done because parent classes don't have access to child class properties.)
+ * If you are manually instantiating a mod feature yourself, then:
  *
- * 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.
+ * - 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.
  *
  * If your mod feature has a property called `v`, it will be assumed that these are variables that
- * should be managed by the save data manager. Subsequently, they will automatically be registered
- * with the save data manager upon initialization. Unfortunately, due to technical limitations with
- * classes, this registration will only occur if you initialize the class with the `init` boolean
- * argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
- * class is constructed. (This is because the parent class does not have access to the child's
- * properties upon first construction.)
+ * should be managed by the save data manager. Unfortunately, due to technical limitations with
+ * classes, this registration will only occur if you initialize the class with the `initModFeatures`
+ * helper function. (This is because the parent class does not have access to the child's properties
+ * upon first construction.)
  */
 export declare class ModFeature {
     private readonly mod;
@@ -15169,21 +15167,20 @@ declare class SaveDataManager extends Feature {
      *    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.)
+     * You provide this function with an object containing your variables, and then it will
+     * automatically 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
+     * you should not put all of the variables 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 = {
@@ -15207,13 +15204,12 @@ declare class SaveDataManager extends Feature {
      *     foo4: 0,
      *   },
      * };
-     * // Every child object is optional; only create the ones that you need.
+     * // The child objects of "persistent", "run", "level", and "room are 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);
-     * }
+     * // Now, give `v` to the save data manager, and it will automatically manage the variables for
+     * // you.
+     * mod.saveDataManager("feature1", v);
      *
      * // Elsewhere in the file, use your variables.
      * function feature1Function() {

package/dist/isaacscript-common.lua

@@ -1,6 +1,6 @@
 --[[
 
-isaacscript-common 30.12.8
+isaacscript-common 30.12.9
 
 This is the "isaacscript-common" library, which was created with the IsaacScript tool.
 

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

@@ -8,24 +8,22 @@ export declare const MOD_FEATURE_CUSTOM_CALLBACKS_KEY = "__customCallbacks";
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
- * When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
- * the constructor.
+ * It is recommended that you use the `initModFeatures` helper function to instantiate all of your
+ * mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
+ * are properly registered with the save data manager; see below.
  *
- * If your feature has variables that are managed by the save data manager, you need to explicitly
- * register them with the save data manager yourself in your class constructor. (It can't be
- * automatically done because parent classes don't have access to child class properties.)
+ * If you are manually instantiating a mod feature yourself, then:
  *
- * 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.
+ * - 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.
  *
  * If your mod feature has a property called `v`, it will be assumed that these are variables that
- * should be managed by the save data manager. Subsequently, they will automatically be registered
- * with the save data manager upon initialization. Unfortunately, due to technical limitations with
- * classes, this registration will only occur if you initialize the class with the `init` boolean
- * argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
- * class is constructed. (This is because the parent class does not have access to the child's
- * properties upon first construction.)
+ * should be managed by the save data manager. Unfortunately, due to technical limitations with
+ * classes, this registration will only occur if you initialize the class with the `initModFeatures`
+ * helper function. (This is because the parent class does not have access to the child's properties
+ * upon first construction.)
  */
 export declare class ModFeature {
     private readonly mod;

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

@@ -1 +1 @@
-{"version":3,"file":"ModFeature.d.ts","sourceRoot":"","sources":["../../../src/classes/ModFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AASpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,yBAAyB,gBAAgB,CAAC;AACvD,eAAO,MAAM,gCAAgC,sBAAsB,CAAC;AAyBpE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAElC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,yBAAyB,EAC/B,CAAC,CAAC,CAAC,SAAS,OAAO,EACjB,OAAO,EAAE,CAAC,EACV,WAAW,EAAE,CAAC,SAAS,IAAI,GAAG,WAAW,GAAG,iBAAiB,EAC7D,GAAG,YAAY,EAAE,OAAO,EAAE,KACvB,OAAO,CAAC,GACb,IAAI,CAAQ;IAEhB;;;;;OAKG;IACI,WAAW,UAAS;gBAEf,GAAG,EAAE,WAAW,EAAE,IAAI,UAAO;IAQzC;;;;;OAKG;IACI,IAAI,CAAC,IAAI,UAAO,GAAG,IAAI;IAqB9B;;;;;OAKG;IACI,MAAM,IAAI,IAAI;CAGtB"}
+{"version":3,"file":"ModFeature.d.ts","sourceRoot":"","sources":["../../../src/classes/ModFeature.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AASpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,yBAAyB,gBAAgB,CAAC;AACvD,eAAO,MAAM,gCAAgC,sBAAsB,CAAC;AAyBpE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAElC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SAAS,CAAC,yBAAyB,EAC/B,CAAC,CAAC,CAAC,SAAS,OAAO,EACjB,OAAO,EAAE,CAAC,EACV,WAAW,EAAE,CAAC,SAAS,IAAI,GAAG,WAAW,GAAG,iBAAiB,EAC7D,GAAG,YAAY,EAAE,OAAO,EAAE,KACvB,OAAO,CAAC,GACb,IAAI,CAAQ;IAEhB;;;;;OAKG;IACI,WAAW,UAAS;gBAEf,GAAG,EAAE,WAAW,EAAE,IAAI,UAAO;IAQzC;;;;;OAKG;IACI,IAAI,CAAC,IAAI,UAAO,GAAG,IAAI;IAqB9B;;;;;OAKG;IACI,MAAM,IAAI,IAAI;CAGtB"}

package/dist/src/classes/ModFeature.lua

@@ -163,24 +163,22 @@ WRAPPED_CUSTOM_CALLBACK_METHODS_KEY = "__wrappedCustomCallbacksMethods"
 -- mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
 -- that automatically subscribe to callbacks.
 -- 
--- When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
--- the constructor.
+-- It is recommended that you use the `initModFeatures` helper function to instantiate all of your
+-- mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
+-- are properly registered with the save data manager; see below.
 -- 
--- If your feature has variables that are managed by the save data manager, you need to explicitly
--- register them with the save data manager yourself in your class constructor. (It can't be
--- automatically done because parent classes don't have access to child class properties.)
+-- If you are manually instantiating a mod feature yourself, then:
 -- 
--- 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.
+-- - 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.
 -- 
 -- If your mod feature has a property called `v`, it will be assumed that these are variables that
--- should be managed by the save data manager. Subsequently, they will automatically be registered
--- with the save data manager upon initialization. Unfortunately, due to technical limitations with
--- classes, this registration will only occur if you initialize the class with the `init` boolean
--- argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
--- class is constructed. (This is because the parent class does not have access to the child's
--- properties upon first construction.)
+-- should be managed by the save data manager. Unfortunately, due to technical limitations with
+-- classes, this registration will only occur if you initialize the class with the `initModFeatures`
+-- helper function. (This is because the parent class does not have access to the child's properties
+-- upon first construction.)
 ____exports.ModFeature = __TS__Class()
 local ModFeature = ____exports.ModFeature
 ModFeature.name = "ModFeature"

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

@@ -51,21 +51,20 @@ export declare class SaveDataManager extends Feature {
      *    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.)
+     * You provide this function with an object containing your variables, and then it will
+     * automatically 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
+     * you should not put all of the variables 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 = {
@@ -89,13 +88,12 @@ export declare class SaveDataManager extends Feature {
      *     foo4: 0,
      *   },
      * };
-     * // Every child object is optional; only create the ones that you need.
+     * // The child objects of "persistent", "run", "level", and "room are 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);
-     * }
+     * // Now, give `v` to the save data manager, and it will automatically manage the variables for
+     * // you.
+     * mod.saveDataManager("feature1", v);
      *
      * // Elsewhere in the file, use your variables.
      * function feature1Function() {

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":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAOzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAsBhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAM;IAE1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;IAE9D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IAEtE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAGvC;IAEJ;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAkC;IAE9E;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkC;IAGpE,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,qCAAqC,CAAS;IAmCtD,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAU1C;IAGF,OAAO,CAAC,QAAQ,CAAC,cAAc,CA0B7B;IAGF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAa1B;IAGF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAY3B;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAuB/B;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmGG;IAEI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAC3C,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,CAAC,EAAE,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,OAAO,GAC9B,IAAI;IAEA,eAAe,CACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,KAAK,GACrB,IAAI;IA6DP;;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;IAsB3E;;;;;;;;;;;;OAYG;IAEI,qBAAqB,IAAI,OAAO;IAKhC,6BAA6B,IAAI,IAAI;CAQ7C"}
+{"version":3,"file":"SaveDataManager.d.ts","sourceRoot":"","sources":["../../../../../src/classes/features/other/SaveDataManager.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAOzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAsBhD,qBAAa,eAAgB,SAAQ,OAAO;IAC1C;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAM;IAE1B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAkC;IAE9D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAkC;IAEtE;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAGvC;IAEJ;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAAkC;IAE9E;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAkC;IAGpE,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,qCAAqC,CAAS;IAmCtD,OAAO,CAAC,QAAQ,CAAC,2BAA2B,CAU1C;IAGF,OAAO,CAAC,QAAQ,CAAC,cAAc,CA0B7B;IAGF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAa1B;IAGF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAY3B;IAGF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAuB/B;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiGG;IAEI,eAAe,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAC3C,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,CAAC,EAAE,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,CAAC,EACnC,eAAe,CAAC,EAAE,MAAM,OAAO,GAC9B,IAAI;IAEA,eAAe,CACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,CAAC,EAAE,QAAQ,EACX,eAAe,EAAE,KAAK,GACrB,IAAI;IA6DP;;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;IAsB3E;;;;;;;;;;;;OAYG;IAEI,qBAAqB,IAAI,OAAO;IAKhC,6BAA6B,IAAI,IAAI;CAQ7C"}

package/dist/src/functions/modFeatures.d.ts

@@ -10,16 +10,16 @@ import type { ModUpgraded } from "../classes/ModUpgraded";
  * For example:
  *
  * ```ts
- * const features = [
+ * const MOD_FEATURES = [
  *   MyFeature1,
  *   MyFeature2,
  *   MyFeature3,
  * ] as const;
- * initModFeatures(mod, modFeatures);
+ * initModFeatures(mod, MOD_FEATURES);
  * ```
  *
  * @returns An array of the instantiated features in the same order that the constructors were
- *          passed in.
+ *          passed in. (In most cases, you probably won't need the returned array.)
  */
 export declare function initModFeatures<T extends ReadonlyArray<typeof ModFeature>>(mod: ModUpgraded, modFeatures: T): {
     [K in keyof T]: InstanceType<T[K]>;

package/dist/src/functions/modFeatures.lua

@@ -10,16 +10,16 @@ local ____exports = {}
 -- For example:
 -- 
 -- ```ts
--- const features = [
+-- const MOD_FEATURES = [
 --   MyFeature1,
 --   MyFeature2,
 --   MyFeature3,
 -- ] as const;
--- initModFeatures(mod, modFeatures);
+-- initModFeatures(mod, MOD_FEATURES);
 -- ```
 -- 
 -- @returns An array of the instantiated features in the same order that the constructors were
--- passed in.
+-- passed in. (In most cases, you probably won't need the returned array.)
 function ____exports.initModFeatures(self, mod, modFeatures)
     local instantiatedModFeatures = {}
     for ____, modFeature in ipairs(modFeatures) do

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "30.12.8",
+  "version": "30.12.9",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",
@@ -25,6 +25,6 @@
   "main": "dist/src/index",
   "types": "dist/index.rollup.d.ts",
   "dependencies": {
-    "isaac-typescript-definitions": "^13.0.21"
+    "isaac-typescript-definitions": "^13.0.22"
   }
 }

package/src/classes/ModFeature.ts

@@ -42,26 +42,23 @@ type ModFeatureConstructor = TSTLClassMetatable["constructor"] & {
  * mod features from this class in order to enable the `@Callback` and `@CustomCallback` decorators
  * that automatically subscribe to callbacks.
  *
- * When instantiating a mod feature class, you must pass your upgraded mod as the first argument to
- * the constructor.
+ * It is recommended that you use the `initModFeatures` helper function to instantiate all of your
+ * mod classes (instead of instantiating them yourself). This is so that any attached `v` objects
+ * are properly registered with the save data manager; see below.
  *
- * If your feature has variables that are managed by the save data manager, you need to explicitly
- * register them with the save data manager yourself in your class constructor. (It can't be
- * automatically done because parent classes don't have access to child class properties.)
+ * If you are manually instantiating a mod feature yourself, then:
  *
- * 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.
+ * - 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.
  *
  * If your mod feature has a property called `v`, it will be assumed that these are variables that
- * should be managed by the save data manager. Subsequently, they will automatically be registered
- * with the save data manager upon initialization. Unfortunately, due to technical limitations with
- * classes, this registration will only occur if you initialize the class with the `init` boolean
- * argument set to false, and then explicitly call the `ModFeature.init` method yourself after the
- * class is constructed. (This is because the parent class does not have access to the child's
- * properties upon first construction.)
+ * should be managed by the save data manager. Unfortunately, due to technical limitations with
+ * classes, this registration will only occur if you initialize the class with the `initModFeatures`
+ * helper function. (This is because the parent class does not have access to the child's properties
+ * upon first construction.)
  */
-
 export class ModFeature {
   private readonly mod: ModUpgraded;
 

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

@@ -221,21 +221,20 @@ export class SaveDataManager extends Feature {
    *    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.)
+   * You provide this function with an object containing your variables, and then it will
+   * automatically 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
+   * you should not put all of the variables 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 = {
@@ -259,13 +258,12 @@ export class SaveDataManager extends Feature {
    *     foo4: 0,
    *   },
    * };
-   * // Every child object is optional; only create the ones that you need.
+   * // The child objects of "persistent", "run", "level", and "room are 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);
-   * }
+   * // Now, give `v` to the save data manager, and it will automatically manage the variables for
+   * // you.
+   * mod.saveDataManager("feature1", v);
    *
    * // Elsewhere in the file, use your variables.
    * function feature1Function() {

package/src/functions/modFeatures.ts

@@ -11,16 +11,16 @@ import type { ModUpgraded } from "../classes/ModUpgraded";
  * For example:
  *
  * ```ts
- * const features = [
+ * const MOD_FEATURES = [
  *   MyFeature1,
  *   MyFeature2,
  *   MyFeature3,
  * ] as const;
- * initModFeatures(mod, modFeatures);
+ * initModFeatures(mod, MOD_FEATURES);
  * ```
  *
  * @returns An array of the instantiated features in the same order that the constructors were
- *          passed in.
+ *          passed in. (In most cases, you probably won't need the returned array.)
  */
 export function initModFeatures<T extends ReadonlyArray<typeof ModFeature>>(
   mod: ModUpgraded,