isaacscript-common 1.2.62 → 1.2.63

package/dist/types/DefaultMap.d.ts

@@ -1,6 +1,6 @@
-declare type FactoryFunction<K, V> = (k: K) => V;
-declare type FirstArg<K, V> = Iterable<[K, V]> | V | FactoryFunction<K, V>;
-declare type SecondArg<K, V> = V | FactoryFunction<K, V>;
+declare type FactoryFunction<K, V, A extends unknown[]> = (k: K, ...extraArgs: A) => V;
+declare type FirstArg<K, V, A extends unknown[]> = Iterable<[K, V]> | V | FactoryFunction<K, V, A>;
+declare type SecondArg<K, V, A extends unknown[]> = V | FactoryFunction<K, V, A>;
 /**
  * An extended Map with some new methods:
  *
@@ -31,36 +31,45 @@ declare type SecondArg<K, V> = V | FactoryFunction<K, V>;
  * ], "bar");
  * ```
  *
- * If specified, the first argument of a factory function must be equal to the key:
+ * If specified, the first argument of a factory function must always be equal to the key:
  *
  * ```ts
  * const defaultMapWithConditionalDefaultValue = new DefaultMap<number, number>((key: number) => {
  *   return isOdd(key) ? 0 : 1;
  * });
  * ```
+ *
+ * You can also specify a factory function that takes a generic amount of arguments beyond the
+ * first:
+ *
+ * ```ts
+ * const defaultMapWithExtraArgs = new DefaultMap<string, string>((_key: string, arg2: boolean) => {
+ *   return arg2 ? 0 : 1;
+ * })
+ * ```
  */
-export declare class DefaultMap<K, V> extends Map<K, V> {
+export declare class DefaultMap<K, V, A extends unknown[] = []> extends Map<K, V> {
     private defaultValue;
     private defaultValueFactory;
     /**
      * See the DefaultMap documentation:
      * https://isaacscript.github.io/isaacscript-common/classes/types_DefaultMap.DefaultMap.html
      */
-    constructor(iterableOrDefaultValueOrDefaultValueFactory: FirstArg<K, V>, defaultValueOrDefaultValueFactory?: SecondArg<K, V>);
+    constructor(iterableOrDefaultValueOrDefaultValueFactory: FirstArg<K, V, A>, defaultValueOrDefaultValueFactory?: SecondArg<K, V, A>);
     /**
      * If the key exists, this will return the same thing as the `get` method. Otherwise, it will set
      * a default value to the key, and then return the default value.
      */
-    getAndSetDefault(key: K): V;
+    getAndSetDefault(key: K, ...extraArgs: A): V;
     /**
      * Returns the default value to be used for a new key. (If a factory function was provided during
      * instantiation, this will execute the factory function.)
      */
-    getDefaultValue(key: K): V;
+    getDefaultValue(key: K, ...extraArgs: A): V;
     /**
      * Helper method for cloning the map. Returns either the default value or a reference to the
      * factory function.
      */
-    getConstructorArg(): V | FactoryFunction<K, V>;
+    getConstructorArg(): V | FactoryFunction<K, V, A>;
 }
 export {};

package/dist/types/DefaultMap.lua

@@ -55,21 +55,21 @@ function DefaultMap.prototype.____constructor(self, iterableOrDefaultValueOrDefa
     self.defaultValue = defaultValue
     self.defaultValueFactory = defaultValueFactory
 end
-function DefaultMap.prototype.getAndSetDefault(self, key)
+function DefaultMap.prototype.getAndSetDefault(self, key, ...)
     local value = self:get(key)
     if value ~= nil then
         return value
     end
-    local defaultValue = self:getDefaultValue(key)
+    local defaultValue = self:getDefaultValue(key, ...)
     self:set(key, defaultValue)
     return defaultValue
 end
-function DefaultMap.prototype.getDefaultValue(self, key)
+function DefaultMap.prototype.getDefaultValue(self, key, ...)
     if self.defaultValue ~= nil then
         return self.defaultValue
     end
     if self.defaultValueFactory ~= nil then
-        return self:defaultValueFactory(key)
+        return self:defaultValueFactory(key, ...)
     end
     return error("A DefaultMap was incorrectly instantiated.")
 end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isaacscript-common",
-  "version": "1.2.62",
+  "version": "1.2.63",
   "description": "Helper functions for IsaacScript mods",
   "keywords": [
     "isaac",