@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.340.1

package/src/foundry/common/packages/base-system.d.mts

@@ -1,84 +1,12 @@
 import type BasePackage from "./base-package.d.mts";
-import type * as fields from "../data/fields.d.mts";
-import type AdditionalTypesField from "./sub-types.d.mts";
 
 declare namespace BaseSystem {
-  interface Schema extends ReturnType<typeof BasePackage.defineSchema> {
-    /**
-     * The current package version
-     * @remarks Actually defined in BasePackage but defined here to avoid conflict with BaseWorld
-     */
-    version: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-    /**
-     * Additional document subtypes provided by this system.
-     */
-    documentTypes: AdditionalTypesField;
-
-    /**
-     * A web URL or local file path which provides a default background banner for worlds which are created using this system
-     */
-    background: fields.StringField<{ required: false; blank: false }>;
-
-    /**
-     * A default initiative formula used for this system
-     */
-    initiative: fields.StringField;
-
-    /**
-     * The default grid settings to use for Scenes in this system
-     */
-    grid: fields.SchemaField<{
-      /** A default grid type to use for Scenes in this system */
-      type: fields.NumberField<{
-        required: true;
-        choices: typeof foundry.CONST.GRID_TYPES;
-        initial: typeof foundry.CONST.GRID_TYPES.SQUARE;
-      }>;
-
-      /** A default distance measurement to use for Scenes in this system */
-      distance: fields.NumberField<{
-        required: true;
-        nullable: false;
-        positive: true;
-        initial: 1;
-      }>;
-
-      /** A default unit of measure to use for distance measurement in this system */
-      units: fields.StringField<{
-        required: true;
-      }>;
-
-      /** The default rule used by this system for diagonal measurement on square grids */
-      diagonals: fields.NumberField<{
-        required: true;
-        choices: typeof foundry.CONST.GRID_DIAGONALS;
-        initial: typeof foundry.CONST.GRID_DIAGONALS.EQUIDISTANT;
-      }>;
-    }>;
-
-    /**
-     * An Actor data attribute path to use for Token primary resource bars
-     */
-    primaryTokenAttribute: fields.StringField;
-
-    /**
-     * An Actor data attribute path to use for Token secondary resource bars
-     */
-    secondaryTokenAttribute: fields.StringField;
-
-    /**
-     * A default distance measurement to use for Scenes in this system
-     * @deprecated since v12
-     */
-    gridDistance: fields.NumberField;
-
-    /**
-     * A default unit of measure to use for distance measurement in this system
-     * @deprecated since v12
-     */
-    gridUnits: fields.NumberField;
-  }
+  export import Source = System.Source;
+  export import PersistedData = System.Source;
+  export import CreateData = System.CreateData;
+  export import InitializedData = System.InitializedData;
+  export import UpdateData = System.UpdateData;
+  export import Schema = System.Schema;
 }
 
 /**

package/src/foundry/common/packages/base-world.d.mts

@@ -1,67 +1,14 @@
 import type BasePackage from "./base-package.d.mts";
-import type * as fields from "../data/fields.d.mts";
-import type { AnyMutableObject, InexactPartial, Merge } from "fvtt-types/utils";
+import type { AnyMutableObject, InexactPartial } from "fvtt-types/utils";
 import type { ReleaseData } from "../config.d.mts";
 
-type BaseWorldSchema = Merge<
-  ReturnType<typeof BasePackage.defineSchema>,
-  {
-    /**
-     * The game system name which this world relies upon
-     */
-    system: fields.StringField<{ required: true; blank: false }>;
-
-    /**
-     * A web URL or local file path which provides a background banner image
-     */
-    background: fields.StringField<{ required: false; blank: false }>;
-
-    /**
-     * The theme to use for this world's join page.
-     */
-    joinTheme: fields.StringField<{
-      required: false;
-      initial: undefined;
-      nullable: false;
-      blank: false;
-      choices: typeof foundry.CONST.WORLD_JOIN_THEMES;
-    }>;
-
-    /**
-     * The version of the core software for which this world has been migrated
-     */
-    coreVersion: fields.StringField<{ required: true; blank: false }>;
-
-    /**
-     * The version of the game system for which this world has been migrated
-     */
-    systemVersion: fields.StringField<{ required: true; blank: false; initial: "0" }>;
-
-    lastPlayed: fields.StringField;
-
-    playtime: fields.NumberField<{ integer: true; min: 0; initial: 0 }>;
-
-    /**
-     * An ISO datetime string when the next game session is scheduled to occur
-     */
-    nextSession: fields.StringField<{ blank: false; nullable: true; initial: null }>;
-
-    /**
-     * Should user access keys be reset as part of the next launch?
-     */
-    resetKeys: fields.BooleanField<{ required: false; initial: undefined }>;
-
-    /**
-     * Should the world launch in safe mode?
-     */
-    safeMode: fields.BooleanField<{ required: false; initial: undefined }>;
-
-    version: fields.StringField<{ required: true; blank: false; nullable: true; initial: null }>;
-  }
->;
-
 declare namespace BaseWorld {
-  interface Schema extends BaseWorldSchema {}
+  export import Source = World.Source;
+  export import PersistedData = World.Source;
+  export import CreateData = World.CreateData;
+  export import InitializedData = World.InitializedData;
+  export import UpdateData = World.UpdateData;
+  export import Schema = World.Schema;
 }
 
 /**

package/src/foundry/common/packages/sub-types.d.mts

@@ -5,7 +5,7 @@ import type { DataField, ObjectField } from "../data/fields.d.mts";
 export type DocumentTypesConfiguration = Record<string, Record<string, AnyObject>>;
 
 /**
- * A special [ObjectField]{@link ObjectField} available to packages which configures any additional Document subtypes
+ * A special {@link ObjectField | `ObjectField`} available to packages which configures any additional Document subtypes
  * provided by the package.
  */
 declare class AdditionalTypesField<

package/src/foundry/common/primitives/array.d.mts

@@ -25,8 +25,8 @@ declare global {
      * @param rule - The rule to partition by
      * @returns An Array of length two whose elements are the partitioned pieces of the original
      */
-    partition<S extends T>(rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
-    partition(rule: (val: T) => boolean): [T[], T[]];
+    partition<S extends T>(/** @immediate */ rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
+    partition(/** @immediate */ rule: (val: T) => boolean): [T[], T[]];
 
     /**
      * Join an Array using a string separator, first filtering out any parts which return a false-y value
@@ -41,7 +41,7 @@ declare global {
      * @param replace - A replacement for the spliced element
      * @returns The replacement element, the removed element, or null if no element was found.
      */
-    findSplice(find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
+    findSplice(/** @immediate */ find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
   }
 
   interface ArrayConstructor {

package/src/foundry/common/primitives/math.d.mts

@@ -98,6 +98,12 @@ declare global {
      *                  Its period must be 2π
      * @returns The oscillation according to t. `((maxValue - minValue) * (f(2π * t / p) + 1) / 2) + minValue`
      */
-    oscillation(minVal: number, maxVal: number, t: number, p?: number, func?: (radians: number) => number): number;
+    oscillation(
+      minVal: number,
+      maxVal: number,
+      t: number,
+      p?: number,
+      /** @immediate */ func?: (radians: number) => number,
+    ): number;
   }
 }

package/src/foundry/common/primitives/number.d.mts

@@ -69,7 +69,7 @@ declare global {
 
   interface NumberConstructor {
     /**
-     * @see {@link Number#between}
+     * @see {@link NumberInstance.between | `Number#between`}
      */
     between(num: number, a: number, b: number, inclusive?: boolean): boolean;
 

package/src/foundry/common/primitives/set.d.mts

@@ -53,53 +53,56 @@ declare global {
 
     /**
      * Test whether every element in this Set satisfies a certain test criterion.
-     * @see {@link Array#every}
+     * @see {@link Array.every | `Array#every`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does every element in the set satisfy the test criterion?
      */
-    every(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    every(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
 
     /**
      * Filter this set to create a subset of elements which satisfy a certain test criterion.
-     * @see {@link Array#filter}
+     * @see {@link Array.filter | `Array#filter`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being filtered.
      * @returns A new Set containing only elements which satisfy the test criterion.
      */
-    filter<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
-    filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
+    filter<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
+    filter(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
 
     /**
      * Find the first element in this set which satisfies a certain test criterion.
-     * @see {@link Array#find}
+     * @see {@link Array.find | `Array#find`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.
      * @returns The first element in the set which satisfies the test criterion, or undefined.
      */
-    find<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
-    find(test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
+    find<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
+    find(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
 
     /**
      * Create a new Set where every element is modified by a provided transformation function.
-     * @see {@link Array#map}
+     * @see {@link Array.map | `Array#map`}
      * @param transform - The transformation function to apply.Positional arguments are the value, the index of iteration, and the set being transformed.
      * @returns A new Set of equal size containing transformed elements.
      */
-    map<V>(transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
+    map<V>(/** @immediate */ transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
 
     /**
      * Create a new Set with elements that are filtered and transformed by a provided reducer function.
-     * @see {@link Array#reduce}
+     * @see {@link Array.reduce | `Array#reduce`}
      * @param reducer - A reducer function applied to each value. Positional arguments are the accumulator, the value, the index of iteration, and the set being reduced.
      * @param accumulator - The initial value of the returned accumulator.
      * @returns The final value of the accumulator.
      */
-    reduce<V>(reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V, accumulator: V): V;
+    reduce<V>(
+      /** @immediate */ reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V,
+      accumulator: V,
+    ): V;
 
     /**
      * Test whether any element in this Set satisfies a certain test criterion.
-     * @see {@link Array#some}
+     * @see {@link Array.some | `Array#some`}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does any element in the set satisfy the test criterion?
      */
-    some(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    some(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
   }
 }

package/src/foundry/common/prosemirror/_types.d.mts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
 // After seeing that none of these types add anything or are even exported a
 // very reasonable question may be: Why on earth does this file exist?
 //

package/src/foundry/common/prosemirror/dropdown.d.mts

@@ -47,7 +47,7 @@ declare class ProseMirrorDropDown {
    * Recurse through the menu structure and apply a function to each item in it.
    * @param fn - The function to call on each item. Return false to prevent iterating over any further items.
    */
-  forEachItem(fn: (entry: ProseMirrorDropDownMenu.Entry) => boolean): void;
+  forEachItem(/** @immediate */ fn: (entry: ProseMirrorDropDownMenu.Entry) => boolean): void;
 
   /**
    * Render a list of drop-down menu items.

package/src/foundry/common/prosemirror/highlight-matches-plugin.d.mts

@@ -67,7 +67,7 @@ declare namespace ProseMirrorHighlightMatchesPlugin {
 }
 
 /**
- * A ProseMirrorPlugin wrapper around the {@link PossibleMatchesTooltip} class.
+ * A ProseMirrorPlugin wrapper around the {@link PossibleMatchesTooltip | `PossibleMatchesTooltip`} class.
  */
 declare class ProseMirrorHighlightMatchesPlugin extends ProseMirrorPlugin {
   /**

package/src/foundry/common/prosemirror/menu.d.mts

@@ -30,7 +30,7 @@ export declare namespace ProseMirrorMenu {
     /** The node to wrap the selected text in. */
     node?: NodeType;
     /** An object of attributes for the node or mark. */
-    attrs?: Attrs; //object
+    attrs?: Attrs; // object
     /** A numeric priority which determines whether this item is displayed as the dropdown title. Lower priority takes precedence. */
     priority?: number;
     /** The command to run when the menu item is clicked. */
@@ -161,14 +161,14 @@ declare class ProseMirrorMenu extends ProseMirrorPlugin {
 
   /**
    * Determine whether the given menu item representing a mark is active or not.
-   * @param item - The menu item representing a {@link MarkType}.
+   * @param item - The menu item representing a {@link MarkType | `MarkType`}.
    * @returns Whether the cursor or selection is in a state represented by the given mark.
    */
   protected _isMarkActive(item: ProseMirrorMenu.Item): boolean;
 
   /**
    * Determine whether the given menu item representing a node is active or not.
-   * @param item - The menu item representing a {@link NodeType}.
+   * @param item - The menu item representing a {@link NodeType | `NodeType`}.
    * @returns Whether the cursor or selection is currently within a block of this menu item's node type.
    */
   protected _isNodeActive(item: ProseMirrorMenu.Item): boolean;

package/src/foundry/common/prosemirror/plugin.d.mts

@@ -6,7 +6,7 @@ export default ProseMirrorPlugin;
 declare abstract class ProseMirrorPlugin {
   /**
    * An abstract class for building a ProseMirror Plugin.
-   * @see Plugin
+   * @see {@link Plugin | `Plugin`}
    * @param schema - The schema to build the plugin against.
    */
   constructor(schema: Schema);

package/src/foundry/common/prosemirror/schema/index.d.mts

@@ -9,4 +9,3 @@ import "./other.d.mts";
 import "./schema-definition.d.mts";
 import "./secret-node.d.mts";
 import "./tables.d.mts";
-import "../../../../utils/index.d.mts";

package/src/foundry/common/prosemirror/util.d.mts

@@ -23,7 +23,7 @@ export declare function serializeHTMLString(
   options?: {
     /** The ProseMirror schema to use instead of the default one. */
     schema?: Schema;
-    /** The number of spaces to use for indentation. See {@link StringNode#toString} for details. */
+    /** The number of spaces to use for indentation. See {@link StringNode.toString | `StringNode#toString`} for details. */
     spaces?: string | number;
   },
 ): string;

package/src/foundry/common/utils/bitmask.d.mts

@@ -1,3 +1,5 @@
+import type { Identity } from "fvtt-types/utils";
+
 declare class InternalBitMask<T extends Record<string, boolean>> extends Number {
   /**
    * Create a new BitMask instance.
@@ -110,7 +112,8 @@ declare class InternalBitMask<T extends Record<string, boolean>> extends Number
 }
 
 declare namespace BitMask {
-  export type Any = InternalBitMask<Record<string, boolean>>;
+  interface Any extends InternalBitMask<Record<string, boolean>> {}
+  interface AnyConstructor extends Identity<typeof BitMask> {}
 }
 
 declare const BitMask: typeof InternalBitMask & (new (...args: any) => number);

package/src/foundry/common/utils/collection.d.mts

@@ -1,18 +1,20 @@
 // This class exists make it as sound as possible to override these parts of the class and make them
+
+import type { AnyArray, Identity } from "fvtt-types/utils";
+
 // completely unrelated. It's done this way specifically to avoid situations with broken inheritance.
-declare class LenientMap<K, V> extends globalThis.Map<K, V> {
+declare class Map<K, V> extends globalThis.Map<K, V> {
   [Symbol.iterator](): any;
-  forEach(...args: any[]): any;
+  forEach(...args: AnyArray): any;
+  get(...args: AnyArray): any;
 }
 
-declare const Map: typeof LenientMap;
-
 /**
  * A reusable storage concept which blends the functionality of an Array with the efficient key-based lookup of a Map.
  * This concept is reused throughout Foundry VTT where a collection of uniquely identified elements is required.
  * @typeParam T - The type of the objects contained in the Collection
  */
-declare class Collection<V> extends Map<string, V> {
+declare class Collection<V, Methods extends Collection.Methods.Any = Collection.Methods<V>> extends Map<string, V> {
   constructor(entries?: Iterable<readonly [string, V]> | null);
 
   /**
@@ -27,7 +29,7 @@ declare class Collection<V> extends Map<string, V> {
 
   /**
    * Find an entry in the Map using an functional condition.
-   * @see {@link Array#find}
+   * @see {@link Array.find | `Array#find`}
    *
    * @param condition - The functional condition to test. Positional arguments are the value, the index of
    *                    iteration, and the collection being searched.
@@ -39,12 +41,14 @@ declare class Collection<V> extends Map<string, V> {
    * c.get("a") === c.find(entry => entry === "A"); // true
    * ```
    */
-  find<S extends V>(condition: (e: V, index: number, collection: Collection<V>) => e is S): S | undefined;
-  find(condition: (e: V, index: number, collection: Collection<V>) => boolean): V | undefined;
+  find<S extends V>(
+    /** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => e is S,
+  ): S | undefined;
+  find(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): V | undefined;
 
   /**
    * Filter the Collection, returning an Array of entries which match a functional condition.
-   * @see {@link Array#filter}
+   * @see {@link Array.filter | `Array#filter`}
    *
    * @param condition - The functional condition to test. Positional arguments are the value, the
    *                    index of iteration, and the collection being filtered.
@@ -56,12 +60,12 @@ declare class Collection<V> extends Map<string, V> {
    * let hasA = c.filters(entry => entry.slice(0) === "A");
    * ```
    */
-  filter<S extends V>(condition: (e: V, index: number, collection: Collection<V>) => e is S): S[];
-  filter(condition: (e: V, index: number, collection: Collection<V>) => boolean): V[];
+  filter<S extends V>(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => e is S): S[];
+  filter(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): V[];
 
   /**
    * Apply a function to each element of the collection
-   * @see Array#forEach
+   * @see {@link Array.forEach | `Array#forEach`}
    * @param fn - The function to apply to each element
    *
    * @example Apply a function to each value in the collection
@@ -70,7 +74,7 @@ declare class Collection<V> extends Map<string, V> {
    * c.forEach(e => e.active = true);
    * ```
    */
-  forEach(fn: (e: V) => void): void;
+  forEach(/** @immediate */ fn: (e: V) => void): void;
 
   /**
    * Get an element from the Collection by its key.
@@ -87,8 +91,7 @@ declare class Collection<V> extends Map<string, V> {
    * c.get("d", {strict: true}); // throws Error
    * ```
    */
-  get(key: string, { strict }: { strict: true }): V;
-  get(key: string, { strict }?: { strict?: false }): V | undefined;
+  get: Methods["get"];
 
   /**
    * Get an entry from the Collection by name.
@@ -116,11 +119,11 @@ declare class Collection<V> extends Map<string, V> {
    * @typeParam M       - The type of the mapped values
    * @returns An Array of transformed values
    */
-  map<M>(transformer: (entity: V, index: number, collection: Collection<V>) => M): M[];
+  map<M>(/** @immediate */ transformer: (entity: V, index: number, collection: Collection<V>) => M): M[];
 
   /**
    * Reduce the Collection by applying an evaluator function and accumulating entries
-   * @see {@link Array#reduce}
+   * @see {@link Array.reduce | `Array#reduce`}
    * @param reducer   - A reducer function applied to each entry value. Positional arguments are the accumulator, the
    *                    value, the index of iteration, and the collection being reduced.
    * @param initial   - An initial value which accumulates with each iteration
@@ -135,30 +138,62 @@ declare class Collection<V> extends Map<string, V> {
    * }, ""); // "ABC"
    * ```
    */
-  reduce<A>(evaluator: (accumulator: A, entity: V, index: number, collection: Collection<V>) => A, initial: A): A;
+  reduce<A>(
+    /** @immediate */ evaluator: (accumulator: A, entity: V, index: number, collection: Collection<V>) => A,
+    initial: A,
+  ): A;
 
   /**
    * Test whether a condition is met by some entry in the Collection.
-   * @see Array#some
+   * @see {@link Array.some | `Array#some`}
    * @param condition - The functional condition to test. Positional arguments are the value, the index of iteration,
    *                    and the collection being tested.
    * @returns Was the test condition passed by at least one entry?
    */
-  some(condition: (e: V, index: number, collection: Collection<V>) => boolean): boolean;
+  some(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): boolean;
 
   /**
    * Convert the Collection to a primitive array of its contents.
    * @returns An array of contained values
    */
-  toJSON(): Array<V extends { toJSON: (...args: any[]) => infer U } ? U : V>;
+  toJSON(): Array<V extends { toJSON: (...args: infer _1) => infer U } ? U : V>;
 }
 
 declare namespace Collection {
-  type AnyConstructor = typeof AnyCollection;
+  interface Any extends AnyCollection {}
+  interface AnyConstructor extends Identity<typeof AnyCollection> {}
+
+  interface GetOptions {
+    /**
+     * Throw an Error if the requested Embedded Document does not exist.
+     * @defaultValue `false`
+     */
+    strict?: boolean | undefined;
+  }
+
+  interface Methods<V> {
+    get<Options extends DocumentCollection.GetOptions>(
+      key: string,
+      { strict }?: Options,
+    ): Collection.GetReturnType<V, Options>;
+  }
+
+  namespace Methods {
+    interface Any {
+      get(key: string, options?: never): unknown;
+    }
+  }
+
+  type GetReturnType<T, Options extends GetOptions> = _ApplyStrict<T, Options["strict"]>;
+
+  /** @internal */
+  type _ApplyStrict<ConcreteDocument, Strict extends boolean | undefined> =
+    | (Strict extends false | undefined ? undefined : never)
+    | ConcreteDocument;
 }
 
-declare abstract class AnyCollection extends Collection<any> {
-  constructor(arg0: never, ...args: never[]);
+declare abstract class AnyCollection extends Collection<unknown, Collection.Methods.Any> {
+  constructor(...args: never);
 }
 
 export default Collection;