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

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

@@ -0,0 +1,116 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The UI element which displays the Scene documents which are currently enabled for quick navigation.
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class SceneNavigation<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    constructor(options?: Partial<Options>);
+
+    /**
+     * Navigation collapsed state
+     * @internal
+     */
+    protected _collapsed: boolean;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "navigation",
+     *   template: "templates/hud/navigation.html",
+     *   popOut: false,
+     *   dragDrop: [{ dragSelector: ".scene" }],
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Return an Array of Scenes which are displayed in the Navigation bar
+     */
+    get scenes(): Scene.ConfiguredInstance[];
+
+    override render(force?: boolean, context?: Application.RenderOptions<Options>): this | void;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    override getData(
+      options?: Partial<ApplicationOptions>,
+    ): MaybePromise<GetDataReturnType<SceneNavigation.SceneNavigationData>>;
+
+    /**
+     * Expand the SceneNavigation menu, sliding it down if it is currently collapsed
+     */
+    expand(): Promise<boolean>;
+
+    /**
+     * Collapse the SceneNavigation menu, sliding it up if it is currently expanded
+     */
+    collapse(): Promise<boolean>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Get the set of ContextMenu options which should be applied for Scenes in the menu
+     * @returns The Array of context options passed to the ContextMenu instance
+     * @internal
+     */
+    protected _getContextMenuOptions(): ContextMenuEntry[];
+
+    /**
+     * Handle left-click events on the scenes in the navigation menu
+     * @internal
+     */
+    protected _onClickScene(event: JQuery.ClickEvent): void;
+
+    protected override _onDragStart(event: DragEvent): void;
+
+    protected override _onDrop(event: DragEvent): void;
+
+    /**
+     * Handle navigation menu toggle click events
+     * @internal
+     */
+    protected _onToggleNav(event: JQuery.ClickEvent): void;
+
+    /**
+     * Display progress of some major operation like loading Scene textures.
+     * @param options - Options for how the progress bar is displayed
+     */
+    static displayProgressBar(options: SceneNavigation.DisplayProgressBarOptions): void;
+  }
+
+  namespace SceneNavigation {
+    type Any = SceneNavigation<any>;
+
+    interface SceneData {
+      id: string;
+      active: boolean;
+      name: string;
+      tooltip: string | null;
+      users: { letter: string; color: User["color"] }[];
+      visible: boolean;
+      css: string;
+    }
+
+    interface SceneNavigationData {
+      collapsed: boolean;
+      scenes: SceneData[];
+    }
+
+    interface DisplayProgressBarOptions {
+      /**
+       * A text label to display
+       */
+      label?: string | undefined;
+
+      /**
+       * A percentage of progress between 0 and 100
+       */
+      pct: number;
+    }
+  }
+}

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,218 @@
+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>;
+
+    /**
+     * Perform one-time localization of the fields in a DataModel schema, translating their label and hint properties.
+     * @param model   - The DataModel class to localize
+     * @param options - Options which configure how localization is performed
+     *
+     * @example
+     * JavaScript class definition and localization call.
+     * ```js
+     * class MyDataModel extends foundry.abstract.DataModel {
+     *   static defineSchema() {
+     *     return {
+     *       foo: new foundry.data.fields.StringField(),
+     *       bar: new foundry.data.fields.NumberField()
+     *     };
+     *   }
+     *   static LOCALIZATION_PREFIXES = ["MYMODULE.MYDATAMODEL"];
+     * }
+     *
+     * Hooks.on("i18nInit", () => {
+     *   Localization.localizeDataModel(MyDataModel);
+     * });
+     * ```
+     *
+     * JSON localization file
+     * ```json
+     * {
+     *   "MYMODULE": {
+     *     "MYDATAMODEL": {
+     *       "FIELDS" : {
+     *         "foo": {
+     *           "label": "Foo",
+     *           "hint": "Instructions for foo"
+     *         },
+     *         "bar": {
+     *           "label": "Bar",
+     *           "hint": "Instructions for bar"
+     *         }
+     *       }
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    static localizeDataModel(model: foundry.abstract.DataModel.AnyConstructor, options?: InexactPartial<{
+      /**
+       * An array of localization key prefixes to use. If not specified, prefixes
+       * are learned from the DataModel.LOCALIZATION_PREFIXES static property.
+       */
+      prefixes: string[];
+
+      /**
+       * A localization path prefix used to prefix all field names within this model. This is generally not required.
+       */
+      prefixPath: string;
+    }>): 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"];
+    }
+  }
+}