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

package/src/foundry/client/game.d.mts

@@ -1,41 +1,31 @@
 import type { Socket } from "socket.io-client";
-import type { ConfiguredModule, GetKey, EmptyObject, ValueOf, FixedInstanceType } from "fvtt-types/utils";
-import type BasePackage from "../common/packages/base-package.d.mts";
-import type { Document } from "../common/abstract/_module.d.mts";
-
-interface EarlierEvents {
-  none: never;
-  init: "none";
-  i18nInit: "none" | "init";
-  setup: "none" | "init" | "i18nInit";
-  ready: "none" | "init" | "i18nInit" | "setup";
-}
-
-type InitializationEvent = keyof EarlierEvents;
+import type {
+  ConfiguredModule,
+  GetKey,
+  EmptyObject,
+  ValueOf,
+  FixedInstanceType,
+  InitializationHook,
+  InitializedOn,
+} from "fvtt-types/utils";
+import type BasePackage from "#common/packages/base-package.d.mts";
+import type { Document } from "#common/abstract/_module.d.mts";
 
 // Must be called with all hooks in a union.
 // Do not increase the complexity of this type. If you do Game related types may get complex enough to complain about not being statically known.
-type GameInitialized<Data, MustRun extends InitializationEvent, RunEvents extends InitializationEvent, D = undefined> =
-  Extract<RunEvents, MustRun> extends never ? D : Data;
-
-type HooksRan<T extends InitializationEvent> = EarlierEvents[T] | T;
-
-// May be called with just one hook.
-type MaybeInitialized<Data, MustRun extends InitializationEvent> = GameInitialized<
-  Data,
-  MustRun,
-  HooksRan<ValidHooksRan>,
-  Data | undefined
->;
-
-type ValidHooksRan = Extract<keyof AssumeHookRan, InitializationEvent>;
+type SimpleInitializedOn<
+  InitializedTo,
+  MustRun extends InitializationHook,
+  RunHooks extends InitializationHook,
+  BeforeInitialization = undefined,
+> = Extract<RunHooks, MustRun> extends never ? BeforeInitialization : InitializedTo;
 
 /**
  * @privateRemarks In v12 many of these properties were mistakenly stripped of their readonly quality;
  *                 This is preserved in the types despite them being technically writable.
  *                 See https://github.com/foundryvtt/foundryvtt/issues/11813
  */
-declare class InternalGame<RunEvents extends InitializationEvent> {
+declare class InternalGame<RunEvents extends InitializationHook> {
   /**
    * @param view      - The named view which is active for this game instance.
    * @param data      - An object of all the World data vended by the server when the client first connects
@@ -90,7 +80,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A mapping of CompendiumCollection instances, one per Compendium pack.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly packs: GameInitialized<CompendiumPacks, "setup", RunEvents>;
+  readonly packs: SimpleInitializedOn<CompendiumPacks, "setup", RunEvents>;
 
   /**
    * A registry of document sub-types and their respective data models.
@@ -114,7 +104,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The global document index.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly documentIndex: GameInitialized<DocumentIndex, "setup", RunEvents>;
+  readonly documentIndex: SimpleInitializedOn<DocumentIndex, "setup", RunEvents>;
 
   /**
    * The UUID redirects tree.
@@ -126,7 +116,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A mapping of WorldCollection instances, one per primary Document type.
    * @remarks Initialized just before the `"setup"` hook event is called.
    */
-  readonly collections: GameInitialized<
+  readonly collections: SimpleInitializedOn<
     foundry.utils.Collection<WorldCollection<Document.AnyConstructor, string>>,
     "setup",
     RunEvents
@@ -136,73 +126,73 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The collection of Actor documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly actors: GameInitialized<ConfiguredCollectionClassForName<"Actor">, "setup", RunEvents>;
+  readonly actors: SimpleInitializedOn<ConfiguredCollectionClassForName<"Actor">, "setup", RunEvents>;
 
   /**
    * The collection of Cards documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly cards: GameInitialized<ConfiguredCollectionClassForName<"Cards">, "setup", RunEvents>;
+  readonly cards: SimpleInitializedOn<ConfiguredCollectionClassForName<"Cards">, "setup", RunEvents>;
 
   /**
    * The collection of Combat documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly combats: GameInitialized<ConfiguredCollectionClassForName<"Combat">, "setup", RunEvents>;
+  readonly combats: SimpleInitializedOn<ConfiguredCollectionClassForName<"Combat">, "setup", RunEvents>;
 
   /**
    * The collection of Folder documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly folders: GameInitialized<ConfiguredCollectionClassForName<"Folder">, "setup", RunEvents>;
+  readonly folders: SimpleInitializedOn<ConfiguredCollectionClassForName<"Folder">, "setup", RunEvents>;
 
   /**
    * The collection of Item documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly items: GameInitialized<ConfiguredCollectionClassForName<"Item">, "setup", RunEvents>;
+  readonly items: SimpleInitializedOn<ConfiguredCollectionClassForName<"Item">, "setup", RunEvents>;
 
   /**
    * The collection of JournalEntry documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly journal: GameInitialized<ConfiguredCollectionClassForName<"JournalEntry">, "setup", RunEvents>;
+  readonly journal: SimpleInitializedOn<ConfiguredCollectionClassForName<"JournalEntry">, "setup", RunEvents>;
 
   /**
    * The collection of Macro documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly macros: GameInitialized<ConfiguredCollectionClassForName<"Macro">, "setup", RunEvents>;
+  readonly macros: SimpleInitializedOn<ConfiguredCollectionClassForName<"Macro">, "setup", RunEvents>;
 
   /**
    * The collection of ChatMessage documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly messages: GameInitialized<ConfiguredCollectionClassForName<"ChatMessage">, "setup", RunEvents>;
+  readonly messages: SimpleInitializedOn<ConfiguredCollectionClassForName<"ChatMessage">, "setup", RunEvents>;
 
   /**
    * The collection of Playlist documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly playlists: GameInitialized<ConfiguredCollectionClassForName<"Playlist">, "setup", RunEvents>;
+  readonly playlists: SimpleInitializedOn<ConfiguredCollectionClassForName<"Playlist">, "setup", RunEvents>;
 
   /**
    * The collection of Scene documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly scenes: GameInitialized<ConfiguredCollectionClassForName<"Scene">, "setup", RunEvents>;
+  readonly scenes: SimpleInitializedOn<ConfiguredCollectionClassForName<"Scene">, "setup", RunEvents>;
 
   /**
    * The collection of RollTable documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly tables: GameInitialized<ConfiguredCollectionClassForName<"RollTable">, "setup", RunEvents>;
+  readonly tables: SimpleInitializedOn<ConfiguredCollectionClassForName<"RollTable">, "setup", RunEvents>;
 
   /**
    * The collection of User documents which exists in the World.
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly users: GameInitialized<ConfiguredCollectionClassForName<"User">, "setup", RunEvents>;
+  readonly users: SimpleInitializedOn<ConfiguredCollectionClassForName<"User">, "setup", RunEvents>;
 
   /**
    * The Release data for this version of Foundry
@@ -230,13 +220,13 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The user role permissions setting
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  readonly permissions: GameInitialized<Game.Permissions, "setup", RunEvents>;
+  readonly permissions: SimpleInitializedOn<Game.Permissions, "setup", RunEvents>;
 
   /**
    * A flag for whether the Game has successfully reached the "ready" hook
    * @defaultValue `false`
    */
-  readonly ready: GameInitialized<true, "ready", RunEvents, false>;
+  readonly ready: SimpleInitializedOn<true, "ready", RunEvents, false>;
 
   /**
    * The singleton compendium art manager.
@@ -253,7 +243,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A singleton reference to the Canvas object which may be used.
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly canvas: GameInitialized<Canvas, "ready", RunEvents>;
+  readonly canvas: SimpleInitializedOn<Canvas, "ready", RunEvents>;
 
   /**
    * The singleton Clipboard Helper.
@@ -264,7 +254,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * Localization support
    * @remarks Initialized just before the `"i18nInit"` hook event.
    */
-  readonly i18n: GameInitialized<Localization, "i18nInit", RunEvents>;
+  readonly i18n: SimpleInitializedOn<Localization, "i18nInit", RunEvents>;
 
   /**
    * The singleton instance of the ClientIssues manager.
@@ -275,25 +265,25 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * The Gamepad Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly gamepad: GameInitialized<GamepadManager, "ready", RunEvents>;
+  readonly gamepad: SimpleInitializedOn<GamepadManager, "ready", RunEvents>;
 
   /**
    * The Keyboard Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly keyboard: GameInitialized<KeyboardManager, "ready", RunEvents>;
+  readonly keyboard: SimpleInitializedOn<KeyboardManager, "ready", RunEvents>;
 
   /**
    * Client keybindings which are used to configure application behavior
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly keybindings: GameInitialized<ClientKeybindings, "ready", RunEvents>;
+  readonly keybindings: SimpleInitializedOn<ClientKeybindings, "ready", RunEvents>;
 
   /**
    * The Mouse Manager
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  readonly mouse: GameInitialized<MouseManager, "ready", RunEvents>;
+  readonly mouse: SimpleInitializedOn<MouseManager, "ready", RunEvents>;
 
   /**
    * The New User Experience manager.
@@ -316,19 +306,19 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    * A singleton instance of the TooltipManager class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly tooltip: GameInitialized<TooltipManager, "setup", RunEvents>;
+  readonly tooltip: SimpleInitializedOn<TooltipManager, "setup", RunEvents>;
 
   /**
    * A singleton instance of the Tour collection class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly tours: GameInitialized<Tours, "setup", RunEvents>;
+  readonly tours: SimpleInitializedOn<Tours, "setup", RunEvents>;
 
   /**
    * A singleton instance of the Video Helper class
    * @remarks Initialized just before the `"setup"` hook events is called.
    */
-  readonly video: GameInitialized<VideoHelper, "setup", RunEvents>;
+  readonly video: SimpleInitializedOn<VideoHelper, "setup", RunEvents>;
 
   /**
    * A singleton web Worker manager.
@@ -426,7 +416,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
   /**
    * @remarks Initialized just before the `"ready"` hook event.
    */
-  webrtc: GameInitialized<AVMaster, "ready", RunEvents>;
+  webrtc: SimpleInitializedOn<AVMaster, "ready", RunEvents>;
 
   /**
    * Initialize core UI elements
@@ -473,7 +463,7 @@ declare class InternalGame<RunEvents extends InitializationEvent> {
    *
    * @remarks Initialized just before the `"setup"` hook event.
    */
-  get user(): GameInitialized<Document.Stored<User.ConfiguredInstance>, "setup", RunEvents, null>;
+  get user(): SimpleInitializedOn<User.Stored, "setup", RunEvents, null>;
 
   /**
    * A convenience accessor for the currently viewed Combat encounter
@@ -628,29 +618,15 @@ declare global {
   interface SetupGame extends _SetupGame {}
   interface ReadyGame extends _ReadyGame {}
 
-  interface HotReloadData {
-    /** The type of package which was modified */
-    packageType: string;
-
-    /** The id of the package which was modified */
-    packageId: string;
-
-    /** The updated stringified file content */
-    content: string;
-
-    /** The relative file path which was modified */
-    path: string;
-
-    /** The file extension which was modified, e.g. "js", "css", "html" */
-    extension: string;
-  }
+  /** @deprecated {@link Hooks.HotReloadData | `HotReloadData`} */
+  type HotReloadData = Hooks.HotReloadData;
 
   namespace Game {
     interface ModuleCollection extends Collection<Module> {
       /**
        * Gets the module requested for by ID
-       * @see {@link ModuleConfig} to add custom properties to modules like APIs.
-       * @see {@link RequiredModules} to remove `undefined` from the return type for a given module
+       * @see {@link ModuleConfig | `ModuleConfig`} to add custom properties to modules like APIs.
+       * @see {@link RequiredModules | `RequiredModules`} to remove `undefined` from the return type for a given module
        * @param id - The module ID to look up
        */
       get<T extends string>(id: T): Module & ConfiguredModule<T>;
@@ -665,28 +641,18 @@ declare global {
        *
        * @typeParam DocumentName - the type of the Document this data is for
        */
-      type TypeNames<DocumentName extends Document.Type> =
-        | (string & keyof Model[DocumentName])
-        | (Document.Internal.SimpleMetadata<DocumentName> extends { readonly hasTypeData: true }
-            ? `${string}.${string}` & {}
-            : never);
+      type TypeNames<DocumentType extends Document.Type> = Document.SubTypesOf<DocumentType>;
     }
 
-    type Model = {
+    type _Model = {
       [DocumentType in Document.Type]: {
         // The `& string` is helpful even though there should never be any numeric/symbol keys.
         // This is because when `keyof Config<...>` is deferred then TypeScript does a bunch of proofs under the assumption that `SystemTypeNames` could be a `string | number` until proven otherwise.
         // This causes issues where there shouldn't be, for example it has been observed to obstruct the resolution of the `Actor` class.
-        [SubType in
-          | Document.CoreTypesForName<DocumentType>
-          | keyof GetKey<DataModelConfig, DocumentType, unknown>
-          | keyof GetKey<SourceConfig, DocumentType, unknown> as SubType & string]: GetKey<
-          GetKey<SourceConfig, DocumentType>,
-          SubType,
-          EmptyObject
-        >;
+        [SubType in Model.TypeNames<DocumentType>]: GetKey<GetKey<SourceConfig, DocumentType>, SubType, EmptyObject>;
       };
     };
+    interface Model extends _Model {}
 
     type Data = {
       activeUsers: string[];
@@ -755,8 +721,8 @@ declare global {
     } & {
       [DocumentType in  // eslint-disable-next-line @typescript-eslint/no-deprecated
         | foundry.CONST.DOCUMENT_TYPES
-        | "Setting" as Document.ConfiguredClassForName<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
-        Document.ConfiguredClassForName<DocumentType>
+        | "Setting" as Document.ImplementationClassFor<DocumentType>["metadata"]["collection"]]?: FixedInstanceType<
+        Document.ImplementationClassFor<DocumentType>
       >["_source"][];
     };
 
@@ -771,13 +737,13 @@ declare global {
    * @defaultValue `undefined`
    * Initialized just before the `"init"` hook event.
    */
-  let canvas: MaybeInitialized<Canvas, "init">;
+  let canvas: InitializedOn<Canvas, "init">;
 
   /**
    * @defaultValue `undefined`
    * Initialized just before the `"ready"` hook event.
    */
-  let keyboard: MaybeInitialized<KeyboardManager, "ready">;
+  let keyboard: InitializedOn<KeyboardManager, "ready">;
 }
 
 type ConfiguredCollectionClassForName<Name extends foundry.CONST.WORLD_DOCUMENT_TYPES> = FixedInstanceType<

package/src/foundry/client/head.d.mts

@@ -1,7 +1,6 @@
-import type { FixedInstanceType } from "fvtt-types/utils";
-import type { EarlierEvents, InitializationEvent } from "./game.d.mts";
+import type { EarlierHook, FixedInstanceType, InitializationHook } from "fvtt-types/utils";
 
-type ValidRanHooks = Extract<keyof AssumeHookRan, InitializationEvent>;
+type ValidRanHooks = Extract<keyof AssumeHookRan, InitializationHook>;
 
 type _UninitializedGame = { [K in keyof Game]?: never };
 
@@ -17,7 +16,7 @@ interface Games {
 }
 
 // Needs to include the current hook as well as all hooks that can run after it.
-type GameHooks = Exclude<InitializationEvent, EarlierEvents[ValidRanHooks]>;
+type GameHooks = Exclude<InitializationHook, EarlierHook[ValidRanHooks]>;
 
 type MaybeUI = Extract<ValidRanHooks, "ready"> extends never ? Partial<UiApplications> : UiApplications;
 
@@ -59,8 +58,8 @@ declare global {
   /**
    * A collection of application instances
    * @remarks
-   * - All of the elements of {@link ui} except for `context` and `window` are initialized between the `"setup"` and `"ready"` hook events.
-   * - In the `/stream` view, only `chat` is initialized but none of the other {@link Application}s.
+   * - All of the elements of {@link ui | `ui`} except for `context` and `window` are initialized between the `"setup"` and `"ready"` hook events.
+   * - In the `/stream` view, only `chat` is initialized but none of the other {@link Application | `Application`}s.
    */
   let ui: {
     /**