isaacscript-common 14.1.0 → 14.1.2

package/dist/src/interfaces/TSTLClassMetatable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TSTLClassMetatable.d.ts","sourceRoot":"","sources":["../../../src/interfaces/TSTLClassMetatable.ts"],"names":[],"mappings":";;;;AAAA,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;KACrD,CAAC;CACH"}
+{"version":3,"file":"TSTLClassMetatable.d.ts","sourceRoot":"","sources":["../../../src/interfaces/TSTLClassMetatable.ts"],"names":[],"mappings":";;;;AAAA,MAAM,WAAW,kBAAkB;IACjC,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,YAAY,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC;KAErD,CAAC;CACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "14.1.0",
+  "version": "14.1.2",
   "description": "Helper functions and features for IsaacScript mods.",
   "keywords": [
     "isaac",

package/src/callbacks.ts

@@ -48,6 +48,7 @@ import { PostSpikesRender } from "./classes/callbacks/PostSpikesRender";
 import { PreBerserkDeath } from "./classes/callbacks/PreBerserkDeath";
 import { PreCustomRevive } from "./classes/callbacks/PreCustomRevive";
 import { ModCallbackCustom2 } from "./enums/ModCallbackCustom2";
+import { getEnumValues } from "./functions/enums";
 import { newObjectWithEnumKeys } from "./functions/utils";
 
 const MOD_CALLBACK_CUSTOM_TO_CLASS = newObjectWithEnumKeys(ModCallbackCustom2, {
@@ -116,19 +117,18 @@ const MOD_CALLBACK_CUSTOM_TO_CLASS = newObjectWithEnumKeys(ModCallbackCustom2, {
 } as const);
 
 export type ModCallbackCustomToClass = {
-  [Property in keyof typeof MOD_CALLBACK_CUSTOM_TO_CLASS]: InstanceType<
-    typeof MOD_CALLBACK_CUSTOM_TO_CLASS[Property]
+  readonly [key in keyof typeof MOD_CALLBACK_CUSTOM_TO_CLASS]: InstanceType<
+    typeof MOD_CALLBACK_CUSTOM_TO_CLASS[key]
   >;
 };
 
 export function getCallbacks(): ModCallbackCustomToClass {
-  const entries = Object.entries(MOD_CALLBACK_CUSTOM_TO_CLASS);
-  const instantiatedClasses = entries.map(
-    ([modCallbackCustom, constructor]) => [
-      modCallbackCustom,
-      new constructor(),
-    ],
-  );
+  const instantiatedClasses: Record<number, unknown> = {};
+
+  for (const modCallbackCustom of getEnumValues(ModCallbackCustom2)) {
+    const constructor = MOD_CALLBACK_CUSTOM_TO_CLASS[modCallbackCustom];
+    instantiatedClasses[modCallbackCustom] = new constructor();
+  }
 
   return instantiatedClasses as unknown as ModCallbackCustomToClass;
 }

package/src/classes/ModUpgraded.ts

@@ -1,5 +1,6 @@
 import { ModCallback } from "isaac-typescript-definitions";
 import { getCallbacks } from "../callbacks";
+import { EXPORTED_METHOD_NAMES_KEY } from "../decorators";
 import { ISCFeature } from "../enums/ISCFeature";
 import { ModCallbackCustom } from "../enums/ModCallbackCustom";
 import { ModCallbackCustom2 } from "../enums/ModCallbackCustom2";
@@ -10,7 +11,10 @@ import {
 } from "../features/saveDataManager/exports";
 import { getTime } from "../functions/debugFunctions";
 import { getParentFunctionDescription } from "../functions/log";
-import { getTSTLClassMethods, getTSTLClassName } from "../functions/tstlClass";
+import {
+  getTSTLClassConstructor,
+  getTSTLClassName,
+} from "../functions/tstlClass";
 import { AddCallbackParametersCustom } from "../interfaces/private/AddCallbackParametersCustom";
 import { AddCallbackParametersCustom2 } from "../interfaces/private/AddCallbackParametersCustom2";
 import { CALLBACK_REGISTER_FUNCTIONS } from "../objects/callbackRegisterFunctions";
@@ -213,14 +217,14 @@ export class ModUpgraded implements Mod {
   }
 
   /**
-   * This method should only be used by the `upgradeMod` function. Returns the class methods from
-   * the features that were added.
+   * This method should only be used by the `upgradeMod` function. Returns the names of the exported
+   * class methods from the features that were added.
    */
   public initOptionalFeature(feature: ISCFeature): FunctionTuple[] {
     const featureClass = this.features[feature];
     this.initFeature(featureClass);
 
-    return getTSTLClassMethods(featureClass);
+    return getExportedMethodsFromFeature(featureClass);
   }
 
   // ----------------------
@@ -302,3 +306,41 @@ export class ModUpgraded implements Mod {
     }
   }
 }
+
+/**
+ * In this context, "exported" methods are methods that are annotated with the "@Exported"
+ * decorator, which signify that the method should be attached to the `ModUpgraded` class.
+ *
+ * Exported methods are stored in an internal static array on the class that is created by the
+ * decorator.
+ */
+function getExportedMethodsFromFeature(featureClass: unknown): FunctionTuple[] {
+  const constructor = getTSTLClassConstructor(featureClass) as Record<
+    string,
+    unknown
+  >;
+  const exportedMethodNames = constructor[
+    EXPORTED_METHOD_NAMES_KEY
+  ] as string[];
+
+  return exportedMethodNames.map((name) => {
+    const featureClassRecord = featureClass as Record<
+      string,
+      (...args: unknown[]) => unknown
+    >;
+    const method = featureClassRecord[name];
+    if (method === undefined) {
+      error(`Failed to find a decorated exported method: ${name}`);
+    }
+
+    // In order for "this" to work properly in the method, we have to wrap the method invocation in
+    // an arrow function.
+    const wrappedMethod = (...args: unknown[]) =>
+      // We cannot split out the method to a separate variable or else the "self" parameter will not
+      // be properly passed to the method.
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      featureClassRecord[name]!(...args);
+
+    return [name, wrappedMethod];
+  });
+}

package/src/classes/private/Feature.ts

@@ -19,6 +19,4 @@ export class Feature {
   public featuresUsed?: ISCFeature[];
   public callbacksUsed?: CallbackTuple[];
   public customCallbacksUsed?: CustomCallbackTuple[];
-
-  public exportedMethods: string[] = [];
 }

package/src/core/upgradeMod.ts

@@ -83,7 +83,7 @@ export function upgradeMod<T extends ISCFeature = never>(
   legacyInit(mod); // TODO: remove
 
   for (const feature of features) {
-    const tstlClassMethods = mod.initOptionalFeature(feature);
+    const exportedMethodTuples = mod.initOptionalFeature(feature);
 
     // If the optional feature provides helper functions, attach them to the base mod object. (This
     // provides a convenient API for end-users.)
@@ -91,7 +91,7 @@ export function upgradeMod<T extends ISCFeature = never>(
       string,
       (...args: unknown[]) => unknown
     >;
-    for (const [funcName, func] of tstlClassMethods) {
+    for (const [funcName, func] of exportedMethodTuples) {
       modRecord[funcName] = func;
     }
   }

package/src/decorators.ts

@@ -1,5 +1,7 @@
 import { Feature } from "./classes/private/Feature";
 
+export const EXPORTED_METHOD_NAMES_KEY = "__exportedMethodNames";
+
 /**
  * A decorator function that signifies that the decorated class method should be added to the
  * `ModUpgraded` object.
@@ -8,6 +10,19 @@ import { Feature } from "./classes/private/Feature";
  */
 export function Exported() {
   return <T extends Feature>(target: T, propertyKey: keyof T): void => {
-    target.exportedMethods.push(propertyKey as string);
+    // Since the decorator runs prior to instantiation, we only have access to get and set static
+    // properties, which are located on the "constructor" table.
+    const constructor = target.constructor as unknown as LuaTable<
+      AnyNotNil,
+      unknown
+    >;
+    if (!constructor.has(EXPORTED_METHOD_NAMES_KEY)) {
+      constructor.set(EXPORTED_METHOD_NAMES_KEY, []);
+    }
+
+    const exportedMethodNames = constructor.get(
+      EXPORTED_METHOD_NAMES_KEY,
+    ) as string[];
+    exportedMethodNames.push(propertyKey as string);
   };
 }

package/src/functions/tstlClass.ts

@@ -1,6 +1,5 @@
 import { DefaultMap } from "../classes/DefaultMap";
 import { TSTLClassMetatable } from "../interfaces/TSTLClassMetatable";
-import { FunctionTuple } from "../types/FunctionTuple";
 import { TSTLClass } from "../types/TSTLClass";
 import { isString, isTable } from "./types";
 
@@ -33,20 +32,6 @@ export function getTSTLClassConstructor(
   return metatable.constructor;
 }
 
-export function getTSTLClassMethods(object: unknown): FunctionTuple[] {
-  const constructor = getTSTLClassConstructor(object);
-  if (constructor === undefined) {
-    return [];
-  }
-
-  const classEntries = Object.entries(constructor.prototype);
-  return classEntries.filter(
-    ([key, value]) =>
-      // Ignore the stock TSTL keys that are baked into every class.
-      !TSTL_CLASS_METATABLE_KEYS.has(key) && type(value) === "function",
-  );
-}
-
 /**
  * Helper function to get the name of a TypeScriptToLua class from the instantiated class object.
  *

package/src/interfaces/TSTLClassMetatable.ts

@@ -4,5 +4,6 @@ export interface TSTLClassMetatable {
   constructor: {
     name: string;
     prototype: LuaMetatable<LuaMap<AnyNotNil, unknown>>;
+    // Other static things on the class will be here, if any.
   };
 }