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

package/src/foundry/client/apps/forms/roll-table-config.d.mts

@@ -0,0 +1,160 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for displaying and editing a single RollTable document.
+   * @typeParam Options - the type of the options object
+   */
+  class RollTableConfig<
+    Options extends DocumentSheetOptions<RollTable> = DocumentSheetOptions<RollTable>,
+  > extends DocumentSheet<Options, RollTable.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "roll-table-config"],
+     *   template: "templates/sheets/roll-table-config.html",
+     *   width: 720,
+     *   height: "auto",
+     *   closeOnSubmit: false,
+     *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
+     *   scrollY: ["table.table-results"],
+     *   dragDrop: [{ dragSelector: null, dropSelector: null }],
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<RollTable>;
+
+    override get title(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: implement GetDataReturnType
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle creating a TableResult in the RollTable document
+     * @param event      - The originating mouse event
+     * @param resultData - An optional object of result data to use
+     * @internal
+     */
+    protected _onCreateResult(
+      event: JQuery.ClickEvent | DragEvent,
+      resultData?: foundry.documents.BaseTableResult.ConstructorData,
+    ): Promise<TableResult.ConfiguredInstance[]>;
+
+    /**
+     * Submit the entire form when a table result type is changed, in case there are other active changes
+     * @internal
+     */
+    protected _onChangeResultType(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle deleting a TableResult from the RollTable document
+     * @param event - The originating click event
+     * @returns The deleted TableResult document
+     * @internal
+     */
+    protected _onDeleteResult(event: JQuery.ClickEvent): Promise<TableResult.ConfiguredInstance>;
+
+    protected override _onDrop(event: DragEvent): Promise<TableResult.ConfiguredInstance[]> | void;
+
+    /**
+     * Handle changing the actor profile image by opening a FilePicker
+     * @internal
+     */
+    protected _onEditImage(event: MouseEvent): Promise<void>;
+
+    /**
+     * Handle a button click to re-normalize dice result ranges across all RollTable results
+     * @internal
+     */
+    protected _onNormalizeResults(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle toggling the drawn status of the result in the table
+     * @internal
+     */
+    protected _onLockResult(event: JQuery.ClickEvent): void;
+
+    /**
+     * Reset the Table to it's original composition with all options unlocked
+     * @internal
+     */
+    protected _onResetTable(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle drawing a result from the RollTable
+     * @internal
+     */
+    protected _onRollTable(event: JQuery.ClickEvent): void;
+
+    /**
+     * Configure the update object workflow for the Roll Table configuration sheet
+     * Additional logic is needed here to reconstruct the results array from the editable fields on the sheet
+     * @param event    - The form submission event
+     * @param formData - The validated FormData translated into an Object for submission
+     * @internal
+     */
+    protected _updateObject(event: Event, formData: RollTableConfig.FormData): Promise<unknown>;
+
+    /**
+     * Display a roulette style animation when a Roll Table result is drawn from the sheet
+     * @param results - An Array of drawn table results to highlight
+     * @returns A Promise which resolves once the animation is complete
+     */
+    protected _animateRoll(results: TableResult.ConfiguredInstance[]): Promise<void[]>;
+
+    /**
+     * Animate a "roulette" through the table until arriving at the final loop and a drawn result
+     */
+    protected _animateRoulette(
+      ol: HTMLOListElement,
+      drawnIds: Set<string>,
+      nLoops: number,
+      animTime: number,
+      animOffset: number,
+    ): Promise<void>;
+
+    /**
+     * Display a flashing animation on the selected result to emphasize the draw
+     * @param item - The HTML \<li\> item of the winning result
+     * @returns A Promise that resolves once the animation is complete
+     */
+    protected _flashResult(item: HTMLElement): Promise<void>;
+  }
+
+  namespace RollTableConfig {
+    type Any = RollTableConfig<any>;
+
+    type FormData = {
+      description: string;
+      displayRoll: boolean;
+      formula: string;
+      img: string;
+      name: string;
+      replacement: boolean;
+    } & FormDataResults;
+
+    type FormDataResults = {
+      [Key in number as `results.${number}._id`]: string;
+    } & {
+      [Key in number as `results.${number}.documentCollection`]: string;
+    } & {
+      [Key in number as `results.${number}.documentId`]: string;
+    } & {
+      [Key in number as `results.${number}.drawn`]: boolean;
+    } & {
+      [Key in number as `results.${number}.img`]: string;
+    } & {
+      [Key in number as `results.${number}.rangeH`]: number;
+    } & {
+      [Key in number as `results.${number}.rangeL`]: number;
+    } & {
+      [Key in number as `results.${number}.text`]: string;
+    } & {
+      [Key in number as `results.${number}.type`]: foundry.CONST.TABLE_RESULT_TYPES;
+    } & {
+      [Key in number as `results.${number}.weight`]: string;
+    };
+  }
+}

package/src/foundry/client/apps/forms/scene-config.d.mts

@@ -0,0 +1,157 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Scene document.   *
+   * @typeParam Options - the type of the options object
+   */
+  class SceneConfig<Options extends DocumentSheetOptions<Scene> = DocumentSheetOptions<Scene>> extends DocumentSheet<
+    Options,
+    Scene.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "scene-config",
+     *   classes: ["sheet", "scene-sheet"],
+     *   template: "templates/scene/config.html",
+     *   width: 560,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<Scene>;
+
+    /**
+     * Indicates if width / height should change together to maintain aspect ratio
+     */
+    linkedDimensions: boolean;
+
+    override get title(): string;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    override render(force?: boolean, options?: Application.RenderOptions<Options>): this;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: implement GetDataReturnType
+
+    /**
+     * Get an enumeration of the available grid types which can be applied to this Scene
+     * @internal
+     */
+    protected static _getGridTypes(): Record<foundry.CONST.GRID_TYPES, string>;
+
+    /**
+     * Get the available weather effect types which can be applied to this Scene
+     * @internal
+     */
+    protected _getWeatherTypes(): Record<string, string>;
+
+    /**
+     * Get the alphabetized Documents which can be chosen as a configuration for the Scene
+     * @internal
+     */
+    protected _getDocuments(
+      collection: WorldCollection<Document.AnyConstructor, string>,
+    ): { _id: string; name: string }[];
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Capture the current Scene position and zoom level as the initial view in the Scene config
+     * @param event - The originating click event
+     * @internal
+     */
+    protected _onCapturePosition(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle click events to open the grid configuration application
+     * @param event - The originating click event
+     */
+    protected _onGridConfig(event: Event): Promise<void>;
+
+    /**
+     * Handle click events to link or unlink the scene dimensions
+     */
+    protected _onLinkDimensions(event: Event): Promise<void>;
+
+    protected override _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    protected override _onChangeColorPicker(event: JQuery.ChangeEvent): void;
+
+    protected override _onChangeRange(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Live update the scene as certain properties are changed.
+     * @param changed - The changed property.
+     * @internal
+     */
+    protected _previewScene(changed: string): void;
+
+    /**
+     * Reset the previewed darkness level, background color, grid alpha, and grid color back to their true values.
+     * @internal
+     */
+    protected _resetScenePreview(): void;
+
+    /**
+     * Handle updating the select menu of PlaylistSound options when the Playlist is changed
+     * @param event - The initiating select change event
+     * @internal
+     */
+    _onChangePlaylist(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle updating the select menu of JournalEntryPage options when the JournalEntry is changed.
+     * @param event - The initiating select change event.
+     */
+    protected _onChangeJournal(event: JQuery.ChangeEvent): void;
+
+    protected override _updateObject(event: Event, formData: SceneConfig.FormData): Promise<unknown>;
+  }
+
+  namespace SceneConfig {
+    type Any = SceneConfig<any>;
+
+    interface FormData {
+      backgroundColor: Scene["backgroundColor"];
+      "background.src": Scene["background"]["src"];
+      "background.offsetX": Scene["background"]["offsetX"];
+      "background.offsetY": Scene["background"]["offsetY"];
+      darkness: Scene["darkness"];
+      fogExploration: Scene["fogExploration"];
+      fogOverlay: Scene["fogOverlay"];
+      fogUnexploredColor: Scene["fogUnexploredColor"];
+      foreground: Scene["foreground"];
+      foregroundElevation: Scene["foregroundElevation"];
+      globalLight: Scene["globalLight"];
+      globalLightThreshold: Scene["globalLightThreshold"];
+      grid: Scene["grid"];
+      "grid.alpha": Scene["grid"]["alpha"];
+      "grid.color": Scene["grid"]["color"];
+      "grid.distance": Scene["grid"]["distance"];
+      "grid.type": Scene["grid"]["type"];
+      "grid.units": Scene["grid"]["units"];
+      hasGlobalThreshold: boolean;
+      height: Scene["height"];
+      "initial.scale": Scene["initial"]["scale"];
+      "initial.x": Scene["initial"]["x"];
+      "initial.y": Scene["initial"]["y"];
+      journal: Scene["_source"]["journal"];
+      journalEntryPage: Scene["journalEntryPage"];
+      name: Scene["name"];
+      navName: Scene["navName"];
+      navigation: Scene["navigation"];
+      padding: Scene["padding"];
+      "ownership.default": Scene["ownership"]["default"];
+      playlist: Scene["playlist"];
+      playlistSound: Scene["playlistSound"];
+      tokenVision: Scene["tokenVision"];
+      weather: Scene["weather"];
+      width: Scene["width"];
+    }
+  }
+}

package/src/foundry/client/apps/forms/sheet-config.d.mts

@@ -0,0 +1,202 @@
+import type { ConstructorOf, GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+import type { Document } from "../../../common/abstract/module.d.mts";
+
+declare global {
+  /**
+   * Document Sheet Configuration Application
+   * @typeParam Options          - The type of the options object
+   * @typeParam ConcreteDocument - The type of the Document which is being managed
+   */
+  class DocumentSheetConfig<
+    Options extends FormApplicationOptions = FormApplicationOptions,
+    ConcreteDocument extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+  > extends FormApplication<Options, ConcreteDocument> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["form", "sheet-config"],
+     *   template: "templates/sheets/sheet-config.html",
+     *   width: 400
+     * })
+     * ```
+     */
+    static get defaultOptions(): FormApplicationOptions;
+
+    /**
+     * An array of pending sheet assignments which are submitted before other elements of the framework are ready.
+     * @internal
+     */
+    static #pending: Array<DocumentSheetConfig.SheetAssignment>;
+
+    override get title(): string;
+
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<DocumentSheetConfig.DocumentSheetConfigData>>;
+
+    protected override _updateObject(event: Event, formData: DocumentSheetConfig.FormData): Promise<unknown>;
+
+    /**
+     * Marshal information on the available sheet classes for a given document type and sub-type, and format it for
+     * @param documentName - The Document type.
+     * @param subType      - The Document sub-type. // TODO: Generic to specify string options?
+     */
+    static getSheetClassesForSubType(
+      documentName: Document.Type,
+      subType: string,
+    ): DocumentSheetConfig.SheetClassesForSubType;
+
+    /**
+     * Initialize the configured Sheet preferences for Documents which support dynamic Sheet assignment
+     * Create the configuration structure for supported documents
+     * Process any pending sheet registrations
+     * Update the default values from settings data
+     */
+    static initializeSheets(): void;
+
+    /**
+     * @internal
+     */
+    protected static _getDocumentTypes(cls: Document.AnyConstructor, types?: string[]): string[];
+
+    /**
+     * Register a sheet class as a candidate which can be used to display documents of a given type
+     * @param documentClass - The Document class for which to register a new Sheet option
+     * @param scope         - Provide a unique namespace scope for this sheet
+     * @param sheetClass    - A defined Application class used to render the sheet
+     * @param config        - Additional options used for sheet registration
+     */
+    static registerSheet(
+      documentClass: Document.AnyConstructor,
+      scope: string,
+      sheetClass: typeof FormApplication,
+      config?: DocumentSheetConfig.RegisterSheetOptions,
+    ): void;
+
+    /**
+     * Perform the sheet registration.
+     * @param config - Configuration for how the sheet should be un-registered
+     * @internal
+     */
+    static #registerSheet(config: Omit<DocumentSheetConfig.SheetRegistration, "action">): void;
+
+    /**
+     * Unregister a sheet class, removing it from the list of available Applications to use for a Document type
+     * @param documentClass - The Document class for which to register a new Sheet option
+     * @param scope         - Provide a unique namespace scope for this sheet
+     * @param sheetClass    - A defined DocumentSheet subclass used to render the sheet
+     * @param types         - An Array of types for which this sheet should be removed
+     */
+    static unregisterSheet(
+      documentClass: Document.AnyConstructor,
+      scope: string,
+      sheetClass: ConstructorOf<FormApplication<FormApplicationOptions, any>>,
+      { types }?: { types?: string[] },
+    ): void;
+
+    /**
+     * Perform the sheet de-registration
+     * @param config - Configuration for how the sheet should be un-registered
+     * @internal
+     */
+    static #unregisterSheet(config: Omit<DocumentSheetConfig.SheetUnregistration, "action">): void;
+
+    /**
+     * Update the current default Sheets using a new core world setting.
+     */
+    static updateDefaultSheets(setting?: Record<Document.Type, Record<string, string>>): void;
+
+    /**
+     * Initialize default sheet configurations for all document types.
+     * @internal
+     */
+    protected static _registerDefaultSheets(): void;
+  }
+
+  namespace DocumentSheetConfig {
+    type Any = DocumentSheetConfig<any>;
+
+    interface SheetRegistration {
+      action: "register";
+
+      /** The Document class being registered */
+      documentClass: Document.AnyConstructor;
+
+      /** The sheet ID being registered */
+      id: string;
+
+      /** The human-readable sheet label */
+      label: string;
+
+      /** The sheet class definition being registered */
+      sheetClass: ConstructorOf<Application>;
+
+      /** An array of types for which this sheet is added */
+      types: string[];
+
+      /** Make this sheet the default for provided types? */
+      makeDefault: boolean;
+    }
+
+    interface SheetUnregistration {
+      action: "unregister";
+
+      /** The Document class being unregistered */
+      documentClass: Document.AnyConstructor;
+
+      /** The sheet ID being unregistered */
+      id: string;
+
+      /** An array of types for which this sheet is removed */
+      types: string[];
+    }
+
+    type SheetAssignment = SheetRegistration | SheetUnregistration;
+
+    interface FormData {
+      defaultClass: string;
+      sheetClass: string;
+    }
+
+    interface RegisterSheetOptions {
+      /** A human-readable label for the sheet name, which will be localized */
+      label?: string;
+
+      /** An array of document types for which this sheet should be used */
+      types?: string[];
+
+      /**
+       * Whether to make this sheet the default for provided types
+       * @defaultValue `false`
+       */
+      makeDefault?: boolean;
+
+      /**
+       * Whether this sheet is available to be selected as a default sheet for all Documents of that type.
+       * @defaultValue `true`
+       */
+      canBeDefault?: boolean;
+
+      /**
+       * Whether this sheet appears in the sheet configuration UI for users.
+       * @defaultValue `true`
+       */
+      canConfigure?: boolean;
+    }
+
+    interface SheetClassesForSubType {
+      sheetClasses: Record<string, string>;
+      defaultClass: string;
+      defaultClasses: Record<string, string>;
+    }
+
+    interface DocumentSheetConfigData extends SheetClassesForSubType {
+      isGM: boolean;
+      object: foundry.abstract.Document.Any;
+      options: FormApplicationOptions;
+      sheetClass: string;
+      blankLabel: string;
+    }
+  }
+}

package/src/foundry/client/apps/forms/user-config.d.mts

@@ -0,0 +1,71 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single User document.
+   * @typeParam Options - the type of the options object
+   */
+  class UserConfig<Options extends UserConfig.Options = UserConfig.Options> extends DocumentSheet<
+    Options,
+    User.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "user-config"],
+     *   template: "templates/user/user-config.html",
+     *   width: 400,
+     *   height: "auto"
+     * })
+     * ```
+     */
+    static override get defaultOptions(): UserConfig.Options;
+
+    override get title(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<UserConfig.UserConfigData>>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle changing the user avatar image by opening a FilePicker
+     */
+    protected _onEditAvatar(event: JQuery.ClickEvent): ReturnType<FilePicker["browse"]>;
+  }
+
+  namespace UserConfig {
+    type Any = UserConfig<any>;
+
+    interface Options extends DocumentSheetOptions<User> {
+      /**
+       * @defaultValue `["sheet", "user-config"]`
+       */
+      classes: DocumentSheetOptions["classes"];
+
+      /**
+       * @defaultValue `"templates/user/user-config.html"`
+       */
+      template: DocumentSheetOptions["template"];
+
+      /**
+       * @defaultValue `400`
+       */
+      width: DocumentSheetOptions["width"];
+
+      /**
+       * @defaultValue `"auto"`
+       */
+      height: DocumentSheetOptions["height"];
+    }
+
+    interface UserConfigData<Options extends DocumentSheetOptions<User> = DocumentSheetOptions<User>> {
+      user: UserConfig<Options>["object"];
+      actors: Document.ToConfiguredClass<typeof Actor>[];
+      options: UserConfig<Options>["options"];
+    }
+  }
+}
+
+type FormData = Pick<User["_source"], "avatar" | "character" | "color">;

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

@@ -0,0 +1,113 @@
+import type { Socket } from "socket.io-client";
+
+declare global {
+  /**
+   * The Chat Bubble Class
+   * This application displays a temporary message sent from a particular Token in the active Scene.
+   * The message is displayed on the HUD layer just above the Token.
+   */
+  class ChatBubbles {
+    constructor();
+
+    /**
+     * @defaultValue `"templates/hud/chat-bubble.html"`
+     */
+    template: string;
+
+    /**
+     * Track active Chat Bubbles
+     * @defaultValue `{}`
+     * @remarks This is never used
+     */
+    bubbles: object;
+
+    /**
+     * Track which Token was most recently panned to highlight
+     * Use this to avoid repeat panning
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _panned: Token | null;
+
+    /**
+     * A reference to the chat bubbles HTML container in which rendered bubbles should live
+     */
+    get container(): JQuery;
+
+    /**
+     * Create a chat bubble message for a certain token which is synchronized for display across all connected clients.
+     * @param token   - The speaking Token Document
+     * @param message - The spoken message text
+     * @param options - Options which affect the bubble appearance
+     */
+    broadcast(token: TokenDocument, message: string, options: ChatBubbles.ChatBubbleOptions): Promise<JQuery | null>;
+
+    /**
+     * Speak a message as a particular Token, displaying it as a chat bubble
+     * @param token   - The speaking Token
+     * @param message - The spoken message text
+     * @param emote   - Whether to style the speech bubble as an emote
+     * @returns A Promise which resolves once the chat bubble has been created
+     */
+    say(token: Token, message: string, { emote }?: { emote?: boolean }): Promise<void>;
+
+    /**
+     * Activate Socket event listeners which apply to the ChatBubbles UI.
+     * @param socket - The active web socket connection
+     */
+    protected static _activateSocketListeners(socket: Socket): Promise<void>;
+
+    /**
+     * Clear any existing chat bubble for a certain Token
+     * @internal
+     */
+    protected _clearBubble(token: Token): Promise<void>;
+
+    /**
+     * Render the HTML template for the chat bubble
+     * @param data - Template data
+     * @returns The rendered HTML
+     * @internal
+     */
+    protected _renderHTML(data: { token: Token; message: string; emote: boolean }): Promise<string>;
+
+    /**
+     * Before displaying the chat message, determine it's constrained and unconstrained dimensions
+     * @param message - The message content
+     * @returns The rendered message dimensions
+     * @internal
+     */
+    protected _getMessageDimensions(message: string): ChatBubbles.Dimensions;
+
+    /**
+     * Assign styling parameters to the chat bubble, toggling either a left or right display (randomly)
+     * @internal
+     */
+    protected _setPosition(token: Token, html: JQuery, dimensions: ChatBubbles.Dimensions): void;
+
+    /**
+     * Determine the length of time for which to display a chat bubble.
+     * Research suggests that average reading speed is 200 words per minute.
+     * Since these are short-form messages, we multiply reading speed by 1.5.
+     * Clamp the result between 1 second (minimum) and 20 seconds (maximum)
+     *
+     * @param html - The HTML message
+     * @returns The number of milliseconds for which to display the message
+     */
+    protected _getDuration(html: JQuery): number;
+  }
+
+  namespace ChatBubbles {
+    interface Dimensions {
+      width: number;
+      height: number;
+      unconstrained: number;
+    }
+
+    interface ChatBubbleOptions {
+      cssClasses?: string;
+      pan: boolean;
+      requireVisible: false;
+    }
+  }
+}