@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/foundry/client/apps/hud/pause.d.mts

@@ -0,0 +1,32 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * Pause notification in the HUD
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class Pause<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    /**
+     * @defaultValue
+     * ```ts
+     * const options = super.defaultOptions;
+     * options.id = "pause";
+     * options.template = "templates/hud/pause.html";
+     * options.popOut = false;
+     * return options;
+     * ```
+     */
+    static get defaultOptions(): ApplicationOptions;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<Pause.PauseData>>;
+  }
+
+  namespace Pause {
+    type Any = Pause<any>;
+
+    interface PauseData {
+      paused: boolean;
+    }
+  }
+}

package/src/foundry/client/apps/hud/players.d.mts

@@ -0,0 +1,82 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The UI element which displays the list of Users who are currently playing within the active World.
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class PlayerList<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    constructor(options?: Partial<Options>);
+
+    /**
+     * An internal toggle for whether to show offline players or hide them
+     * @defaultValue `false`
+     */
+    protected _showOffline: boolean;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "players",
+     *   template: "templates/user/players.html",
+     *   popOut: false
+     * })
+     * ```
+     */
+    static get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Whether the players list is in a configuration where it is hidden
+     */
+    get isHidden(): boolean;
+
+    override render(force?: boolean, options?: Application.RenderOptions<Options>): this;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<PlayerList.Data>>;
+
+    /**
+     * Prepare a displayed name string for the User which includes their name, pronouns, character, or GM tag.
+     */
+    protected _getDisplayName(user: User): string;
+
+    /**
+     * Position this Application in the main DOM appropriately.
+     */
+    protected _positionInDOM(): void;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Return the default context options available for the Players application
+     */
+    protected _getUserContextOptions(): ContextMenuEntry[];
+
+    /**
+     * Toggle display of the Players hud setting for whether or not to display offline players
+     * @param event - The originating click event
+     */
+    protected _onToggleOfflinePlayers(event: JQuery.ClickEvent): void;
+  }
+
+  namespace PlayerList {
+    type Any = PlayerList<any>;
+
+    interface UserData {
+      active: User["active"];
+      isGM: User["isGM"];
+      isSelf: User["isSelf"];
+      charname: string;
+      color: string;
+      border: string;
+      displayName: string;
+    }
+
+    interface Data {
+      users: UserData[];
+      showOffline: boolean;
+      hide: boolean;
+    }
+  }
+}

package/src/foundry/client/apps/i18n.d.mts

@@ -0,0 +1,162 @@
+import type { InexactPartial } from "../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A helper class which assists with localization and string translation
+   */
+  class Localization {
+    /**
+     * @param serverLanguage - The default language configuration setting for the server
+     */
+    constructor(serverLanguage?: string);
+
+    /**
+     * The target language for localization
+     * @defaultValue `"en"`
+     */
+    lang: string;
+
+    /**
+     * The package authorized to provide default language configurations
+     * @defaultValue `"core"`
+     */
+    defaultModule: string;
+
+    /**
+     * The translation dictionary for the target language
+     * @defaultValue `{}`
+     */
+    translations: Localization.Translations;
+
+    /**
+     * Fallback translations if the target keys are not found
+     * @defaultValue `{}`
+     */
+    protected _fallback: Localization.Translations;
+
+    /**
+     * Initialize the Localization module
+     * Discover available language translations and apply the current language setting
+     * @returns A Promise which resolves once languages are initialized
+     */
+    initialize(): Promise<void>;
+
+    /**
+     * Set a language as the active translation source for the session
+     * @param lang - A language string in CONFIG.supportedLanguages
+     * @returns A Promise which resolves once the translations for the requested language are ready
+     */
+    setLanguage(lang: string): Promise<void>;
+
+    /**
+     * Discover the available supported languages from the set of packages which are provided
+     */
+    protected _discoverSupportedLanguages(): Record<string, string>;
+
+    /**
+     * Prepare the dictionary of translation strings for the requested language
+     * @param lang - The language for which to load translations
+     * @returns The retrieved translations object
+     */
+    protected _getTranslations(lang: string): Promise<Localization.Translations>;
+
+    /**
+     * Reduce the languages array provided by a package to an array of file paths of translations to load
+     * @param pkg  - The package data
+     * @param lang - The target language to filter on
+     * @returns An array of translation file paths
+     */
+    protected _filterLanguagePaths(pkg: World | Module | System, lang: string): string[];
+
+    /**
+     * Load a single translation file and return its contents as processed JSON
+     * @param src - The translation file path to load
+     * @returns The loaded translation dictionary
+     */
+    protected _loadTranslationFile(src: string): Promise<Localization.Translations>;
+
+    /**
+     * Return whether a certain string has a known translation defined.
+     * @param stringId - The string key being translated
+     * @param fallback - Allow fallback translations to count?
+     */
+    has(stringId: string, fallback?: boolean): boolean;
+
+    /**
+     * Localize a string by drawing a translation from the available translations dictionary, if available
+     * If a translation is not available, the original string is returned
+     * @param stringId - The string ID to translate
+     * @returns The translated string
+     *
+     * @example <caption>Localizing a simple string in JavaScript</caption>
+     * ```typescript
+     * {
+     *   "MYMODULE.MYSTRING": "Hello, this is my module!"
+     * }
+     * game.i18n.localize("MYMODULE.MYSTRING"); // Hello, this is my module!
+     * ```
+     *
+     * @example <caption>Localizing a simple string in Handlebars</caption>
+     * ```handlebars
+     * {{localize "MYMODULE.MYSTRING"}} <!-- Hello, this is my module! -->
+     * ```
+     */
+    localize(stringId: string): string;
+
+    /**
+     * Localize a string including variable formatting for input arguments.
+     * Provide a string ID which defines the localized template.
+     * Variables can be included in the template enclosed in braces and will be substituted using those named keys.
+     *
+     * @param stringId - The string ID to translate
+     * @param data     - Provided input data
+     *                   (defaultValue: `{}`)
+     * @returns The translated and formatted string
+     *
+
+     * @example <caption>Localizing a formatted string in JavaScript</caption>
+     * ```typescript
+     * {
+     *   "MYMODULE.GREETING": "Hello {name}, this is my module!"
+     * }
+     * game.i18n.format("MYMODULE.GREETING" {name: "Andrew"}); // Hello Andrew, this is my module!
+     * ```
+     *
+     * @example <caption>Localizing a formatted string in Handlebars</caption>
+     * ```handlebars
+     * {{localize "MYMODULE.GREETING" name="Andrew"}} <!-- Hello, this is my module! -->
+     * ```
+     */
+    format(stringId: string, data?: Record<string, unknown>): string;
+
+    /**
+     * Retreive list formatter configured to the world's language setting.
+     * @see [Intl.ListFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/ListFormat/ListFormat)
+     */
+    getListFormatter(
+      options?: InexactPartial<{
+        /**
+         * The list formatter style, either "long", "short", or "narrow".
+         */
+        style: Intl.ListFormatStyle;
+        /**
+         * The list formatter type, either "conjunction", "disjunction", or "unit".
+         */
+        type: Intl.ListFormatType;
+      }>,
+    ): Intl.ListFormat;
+
+    /**
+     * Sort an array of objects by a given key in a localization-aware manner.
+     * @param objects - The objects to sort, this array will be mutated
+     * @param key     - The key to sort the objects by. This can be provided in dot-notation.
+     */
+    sortObjects<T extends object>(objects: Array<T>, key: string): T[];
+  }
+
+  namespace Localization {
+    interface Translations {
+      [K: string]: string | Translations;
+    }
+  }
+}

package/src/foundry/client/apps/index.d.mts

@@ -0,0 +1,10 @@
+import "./app.d.mts";
+import "./av/index.d.mts";
+import "./dialogs/index.d.mts";
+import "./form.d.mts";
+import "./forms/index.d.mts";
+import "./hud/index.d.mts";
+import "./i18n.d.mts";
+import "./placeables/index.d.mts";
+import "./sidebar/index.d.mts";
+import "./templates.d.mts";

package/src/foundry/client/apps/placeables/drawing-config.d.mts

@@ -0,0 +1,80 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  interface DrawingConfigOptions extends FormApplicationOptions {
+    /**
+     * Configure the default drawing settings, instead of a specific Drawing
+     * @defaultValue `false`
+     */
+    configureDefault: boolean;
+  }
+
+  /**
+   * The Application responsible for configuring a single Drawing document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class DrawingConfig<Options extends DrawingConfigOptions = DrawingConfigOptions> extends FormApplication<
+    Options,
+    DrawingDocument.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "drawing-config",
+     *   template: "templates/scene/drawing-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   configureDefault: false,
+     *   tabs: [{ navSelector: ".tabs", contentSelector: "form", initial: "position" }],
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DrawingConfigOptions;
+
+    override get title(): string;
+
+    override get id(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    protected override _updateObject(event: Event, formData: DrawingConfig.FormData): Promise<unknown>;
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Reset the user Drawing configuration settings to their default values
+     * @param event - The originating mouse-click event
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): void;
+  }
+
+  namespace DrawingConfig {
+    type Any = DrawingConfig<any>;
+
+    interface FormData {
+      author: string;
+      bezierFactor: DrawingDocument["bezierFactor"];
+      fillAlpha: DrawingDocument["fillAlpha"];
+      fillColor: DrawingDocument["fillColor"];
+      fillType: DrawingDocument["fillType"];
+      fontFamily: DrawingDocument["fontFamily"];
+      fontSize: DrawingDocument["fontSize"];
+      "shape.height": DrawingDocument["shape"]["height"];
+      rotation: DrawingDocument["rotation"];
+      strokeAlpha: DrawingDocument["strokeAlpha"];
+      strokeColor: DrawingDocument["strokeColor"];
+      strokeWidth: DrawingDocument["strokeWidth"];
+      text: DrawingDocument["text"];
+      textAlpha: DrawingDocument["textAlpha"];
+      textColor: DrawingDocument["textColor"];
+      texture: DrawingDocument["texture"];
+      "shape.width": DrawingDocument["shape"]["width"];
+      x: DrawingDocument["x"];
+      y: DrawingDocument["y"];
+      z: DrawingDocument["z"];
+    }
+  }
+}

package/src/foundry/client/apps/placeables/drawing-hud.d.mts

@@ -0,0 +1,31 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An implementation of the PlaceableHUD base class which renders a heads-up-display interface for Drawing objects.
+   * @typeParam Options - the type of the options object
+   */
+  class DrawingHUD<Options extends ApplicationOptions = ApplicationOptions> extends BasePlaceableHUD<
+    Drawing.ConfiguredInstance,
+    Options
+  > {
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "drawing-hud",
+     *   template: "templates/hud/drawing-hud.html"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    override setPosition(options?: Partial<Application.Position>): void;
+  }
+
+  namespace DrawingHUD {
+    type Any = DrawingHUD<any>;
+  }
+}

package/src/foundry/client/apps/placeables/index.d.mts

@@ -0,0 +1,10 @@
+import "./drawing-config.d.mts";
+import "./drawing-hud.d.mts";
+import "./light-config.d.mts";
+import "./note-config.d.mts";
+import "./sound-config.d.mts";
+import "./tile-config.d.mts";
+import "./tile-hud.d.mts";
+import "./token-config.d.mts";
+import "./token-hud.d.mts";
+import "./wall-config.d.mts";

package/src/foundry/client/apps/placeables/light-config.d.mts

@@ -0,0 +1,100 @@
+import type { InterfaceToObject } from "../../../../types/helperTypes.d.mts";
+import type { AnyObject, DeepPartial, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientLight document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class AmbientLightConfig<
+    Options extends DocumentSheetOptions<AmbientLightDocument> = DocumentSheetOptions<AmbientLightDocument>,
+  > extends DocumentSheet<Options, AmbientLightDocument.ConfiguredInstance> {
+    /**
+     * Maintain a copy of the original to show a real-time preview of changes.
+     */
+    preview: AmbientLightDocument.ConfiguredInstance;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "ambient-light-config",
+     *   classes: ["sheet", "ambient-light-config"],
+     *   title: "LIGHT.ConfigTitle",
+     *   template: "templates/scene/ambient-light-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<AmbientLightDocument>;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Preview the change caused by a change on the form by refreshing the display of the light source
+     */
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    protected _onResetForm(event: PointerEvent): void;
+
+    /**
+     * Preview changes to the AmbientLight document as if they were true document updates.
+     * @param change - A change to preview
+     */
+    protected _previewChanges(change: DeepPartial<AmbientLightDocument["_source"]>): void;
+
+    /**
+     * Restore the true data for the AmbientLight document when the form is submitted or closed.
+     */
+    protected _resetPreview(): void;
+
+    protected override _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
+
+    protected override _getSubmitData(updateData?: AnyObject | null): InterfaceToObject<AmbientLightConfig.FormData>;
+
+    protected override _updateObject(event: Event, formData: AmbientLightConfig.FormData): Promise<unknown>;
+
+    /**
+     * Refresh the display of the AmbientLight object
+     * @internal
+     */
+    protected _refresh(): void;
+  }
+
+  namespace AmbientLightConfig {
+    type Any = AmbientLightConfig<any>;
+
+    interface FormData {
+      x: AmbientLightDocument["x"];
+      y: AmbientLightDocument["y"];
+      rotation: AmbientLightDocument["rotation"];
+      walls: AmbientLightDocument["walls"];
+      vision: AmbientLightDocument["vision"];
+      "config.dim": AmbientLightDocument["config"]["dim"];
+      "config.bright": AmbientLightDocument["config"]["bright"];
+      "config.angle": AmbientLightDocument["config"]["angle"];
+      "config.color": AmbientLightDocument["config"]["color"];
+      "config.alpha": AmbientLightDocument["config"]["alpha"];
+      "config.darkness.min": AmbientLightDocument["config"]["darkness"]["min"];
+      "config.darkness.max": AmbientLightDocument["config"]["darkness"]["max"];
+      "config.animation.type": AmbientLightDocument["config"]["animation"]["type"];
+      "config.animation.speed": AmbientLightDocument["config"]["animation"]["speed"];
+      "config.animation.reverse": AmbientLightDocument["config"]["animation"]["reverse"];
+      "config.animation.intensity": AmbientLightDocument["config"]["animation"]["intensity"];
+      "config.coloration": AmbientLightDocument["config"]["coloration"];
+      "config.luminosity": AmbientLightDocument["config"]["luminosity"];
+      "config.attenuation": AmbientLightDocument["config"]["attenuation"];
+      "config.saturation": AmbientLightDocument["config"]["saturation"];
+      "config.contrast": AmbientLightDocument["config"]["contrast"];
+      "config.shadows": AmbientLightDocument["config"]["shadows"];
+    }
+  }
+}

package/src/foundry/client/apps/placeables/note-config.d.mts

@@ -0,0 +1,65 @@
+import type { ConfiguredDocumentClassForName } from "../../../../types/helperTypes.d.mts";
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Note document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class NoteConfig<
+    Options extends DocumentSheetOptions<NoteDocument> = DocumentSheetOptions<NoteDocument>,
+  > extends DocumentSheet<Options, InstanceType<ConfiguredDocumentClassForName<"Note">>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("NOTE.ConfigTitle"),
+     *   template: "templates/scene/note-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<NoteDocument>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    /**
+     * Update disabled state of the custom icon field.
+     */
+    protected _updateCustomIcon(): void;
+
+    /**
+     * Update the list of pages.
+     */
+    protected _updatePageList(): void;
+
+    protected _getSubmitData(updateData?: object | null): Record<string, unknown>;
+
+    protected override _updateObject(event: Event, formData: NoteConfig.FormData): Promise<unknown>;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace NoteConfig {
+    type Any = NoteConfig<any>;
+
+    interface FormData {
+      entryId: NoteDocument["entryId"];
+      fontFamily: NoteDocument["fontFamily"];
+      fontSize: NoteDocument["fontSize"];
+      "icon.selected": NoteDocument["texture"]["src"];
+      "icon.custom": NoteDocument["texture"]["src"] | "";
+      iconSize: NoteDocument["iconSize"];
+      iconTint: NoteDocument["texture"]["tint"];
+      text: NoteDocument["text"];
+      textAnchor: NoteDocument["textAnchor"];
+      textColor: NoteDocument["textColor"];
+      x: NoteDocument["x"];
+      y: NoteDocument["y"];
+    }
+  }
+}

package/src/foundry/client/apps/placeables/sound-config.d.mts

@@ -0,0 +1,43 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientSound document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class AmbientSoundConfig<
+    Options extends DocumentSheetOptions<AmbientSoundDocument> = DocumentSheetOptions<AmbientSoundDocument>,
+  > extends DocumentSheet<Options, AmbientSoundDocument.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: "SOUND.ConfigTitle",
+     *   template: "templates/scene/sound-config.html",
+     *   width: 480
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheetOptions<AmbientSoundDocument>;
+
+    override get title(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    protected override _updateObject(event: Event, formData: AmbientSoundConfig.FormData): Promise<unknown>;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace AmbientSoundConfig {
+    type Any = AmbientSoundConfig<any>;
+
+    type FormData = Pick<
+      foundry.documents.BaseAmbientSound,
+      "easing" | "path" | "volume" | "x" | "y" | "radius" | "walls"
+    > & {
+      "darkness.min": AmbientSoundDocument["darkness"]["min"];
+      "darkness.max": AmbientSoundDocument["darkness"]["max"];
+    };
+  }
+}

package/src/foundry/client/apps/placeables/tile-config.d.mts

@@ -0,0 +1,54 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Tile document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class TileConfig<Options extends TileConfig.Options = TileConfig.Options> extends DocumentSheet<
+    Options,
+    TileDocument.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * mergeObject(super.defaultOptions, {
+     *   id: "tile-config",
+     *   title: game.i18n.localize("TILE.ConfigTitle"),
+     *   template: "templates/scene/tile-config.html",
+     *   width: 420,
+     *   height: "auto",
+     *   submitOnChange: true,
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): TileConfig.Options;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    protected override _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    protected override _updateObject(event: Event, formData: TileConfig.FormData): Promise<unknown>;
+  }
+
+  namespace TileConfig {
+    type Any = TileConfig<any>;
+
+    type FormData = Pick<TileDocument, "alpha" | "height" | "rotation" | "width" | "x" | "y" | "overhead" | "roof"> & {
+      "texture.src": string | null;
+      "texture.scaleX": number | null;
+      "texture.scaleY": number | null;
+      "texture.tint": string;
+    };
+
+    interface Options extends DocumentSheetOptions<TileDocument> {
+      /**
+       * Configure a preview version of a tile which is not yet saved
+       */
+      preview?: boolean;
+    }
+  }
+}