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

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

@@ -0,0 +1,95 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * Render the Sidebar container, and after rendering insert Sidebar tabs.
+   * @typeParam Options - the type of the options object
+   */
+  class Sidebar<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    /**
+     * Singleton application instances for each sidebar tab
+     * @defaultValue `{}`
+     */
+    tabs: Partial<Record<string, SidebarTab>>;
+
+    /**
+     * Track whether the sidebar container is currently collapsed
+     * @defaultValue `false`
+     */
+    protected _collapsed: boolean;
+
+    /**
+     * @defaultValue
+     * ```ts
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "sidebar",
+     *   template: "templates/sidebar/sidebar.html",
+     *   popOut: false,
+     *   width: 300,
+     *   tabs: [{navSelector: ".tabs", contentSelector: "#sidebar", initial: "chat"}]
+     * }
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Return the name of the active Sidebar tab
+     */
+    get activeTab(): string;
+
+    /**
+     * Singleton application instances for each popout tab
+     */
+    get popouts(): Partial<Record<string, SidebarTab>>;
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    /**
+     * @internal
+     */
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    /**
+     * Expand the Sidebar container from a collapsed state.
+     * Take no action if the sidebar is already expanded.
+     */
+    expand(): void;
+
+    /**
+     * Collapse the sidebar to a minimized state.
+     * Take no action if the sidebar is already collapsed.
+     */
+    collapse(): void;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * @internal
+     */
+    protected override _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
+
+    /**
+     * Handle the special case of left-clicking a tab when the sidebar is collapsed.
+     * @param event - The originating click event
+     * @internal
+     */
+    protected _onLeftClickTab(event: MouseEvent): void;
+
+    /**
+     * Handle right-click events on tab controls to trigger pop-out containers for each tab
+     * @param event - The originating contextmenu event
+     * @internal
+     */
+    protected _onRightClickTab(event: MouseEvent): void;
+
+    /**
+     * Handle toggling of the Sidebar container's collapsed or expanded state
+     * @internal
+     */
+    protected _onToggleCollapse(event: MouseEvent): void;
+  }
+
+  namespace Sidebar {
+    type Any = Sidebar<any>;
+  }
+}

package/src/foundry/client/apps/sidebar/tabs/actors-directory.d.mts

@@ -0,0 +1,20 @@
+export {};
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level Actor documents.
+   */
+  class ActorDirectory extends DocumentDirectory<"Actor"> {
+    constructor(...args: ConstructorParameters<typeof DocumentDirectory>);
+
+    static override documentName: "Actor";
+
+    protected override _canDragStart(selector: string): boolean;
+
+    protected override _onDragStart(event: DragEvent): void;
+
+    protected override _canDragDrop(selector: string): boolean;
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+  }
+}

package/src/foundry/client/apps/sidebar/tabs/cards-directory.d.mts

@@ -0,0 +1,12 @@
+export {};
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level Cards documents.
+   */
+  class CardsDirectory extends DocumentDirectory<"Cards"> {
+    static override documentName: "Cards";
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+  }
+}

package/src/foundry/client/apps/sidebar/tabs/chat-log.d.mts

@@ -0,0 +1,364 @@
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  interface ChatLogOptions extends ApplicationOptions {
+    /**
+     * Is this chat log being rendered as part of the stream view?
+     * @defaultValue `false`
+     */
+    stream: boolean;
+  }
+
+  /**
+   * The sidebar directory which organizes and displays world-level ChatMessage documents.
+   * @see {@link Sidebar}
+   */
+  class ChatLog extends SidebarTab<ChatLogOptions> {
+    constructor(options?: Partial<ChatLogOptions>);
+
+    /**
+     * Track any pending text which the user has submitted in the chat log textarea
+     * @internal
+     */
+    protected _pendingText: string;
+
+    /**
+     * Track the history of the past 5 sent messages which can be accessed using the arrow keys
+     * @defaultValue `[]`
+     * @internal
+     */
+    protected _sentMessages: string[];
+
+    /**
+     * Track which remembered message is being currently displayed to cycle properly
+     * @defaultValue `-1`
+     * @internal
+     */
+    protected _sentMessageIndex: number;
+
+    /**
+     * Track the time when the last message was sent to avoid flooding notifications
+     * @defaultValue `0`
+     * @internal
+     */
+    protected _lastMessageTime: number;
+
+    /**
+     * Track the id of the last message displayed in the log
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _lastId: string | null;
+
+    /**
+     * Track the last received message which included the user as a whisper recipient.
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _lastWhisper: ChatMessage.ConfiguredInstance | null;
+
+    /**
+     * A reference to the chat text entry bound key method
+     * @defaultValue `null`
+     * @internal
+     */
+    _onChatKeyDownBinding: ((event: JQuery.KeyDownEvent) => void) | null;
+
+    /**
+     * Returns if the chat log is currently scrolled to the bottom
+     */
+    get isAtBottom(): boolean;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "chat",
+     *   template: "templates/sidebar/chat-log.html",
+     *   title: game.i18n.localize("CHAT.Title"),
+     *   stream: false,
+     *   scrollY: ["#chat-log"]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): ChatLogOptions;
+
+    /**
+     * An enumeration of regular expression patterns used to match chat messages.
+     */
+    static MESSAGE_PATTERNS: Record<ChatLog.Command, RegExp>;
+
+    /**
+     * The set of commands that can be processed over multiple lines.
+     */
+    static MULTILINE_COMMANDS: Set<string>;
+
+    /**
+     * A reference to the Messages collection that the chat log displays
+     */
+    get collection(): Messages;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<ChatLogOptions>): Promise<object>;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<ChatLogOptions>): Promise<void>;
+
+    protected override _renderInner(data: object): Promise<JQuery>;
+
+    /**
+     * Render a batch of additional messages, prepending them to the top of the log
+     * @param html - The rendered jQuery HTML object
+     * @param size - The batch size to include
+     *
+     * @internal
+     */
+    protected _renderBatch(html: JQuery, size: number): Promise<void>;
+
+    /**
+     * Delete a single message from the chat log
+     * @param messageId - The ChatMessage entity to remove from the log
+     * @param deleteAll - Is this part of a flush operation to delete all messages?
+     *                    (default: `false`)
+     */
+    deleteMessage(messageId: string, { deleteAll }?: { deleteAll?: boolean }): void;
+
+    /**
+     * Trigger a notification that alerts the user visually and audibly that a new chat log message has been posted
+     */
+    notify(message: ChatMessage.ConfiguredInstance): void;
+
+    /**
+     * Parse a chat string to identify the chat command (if any) which was used
+     * @param message - The message to match
+     * @returns The identified command and regex match
+     * @remarks The returned RegExpMatchArray or string Array has the entire match as its first value, then the match for
+     *          the slash command (or an empty string) and as last element the flavor or message text. The whisper match
+     *          is an exception: Its third value is the target user name (optionally in brackets) and the fourth value is
+     *          the message text.
+     */
+    static parse<S extends string>(message: S): [ChatLog.Command, RegExpMatchArray] | ["none", [S, "", S]];
+
+    /**
+     * Post a single chat message to the log
+     * @param message         - A ChatMessage document instance to post to the log
+     * @param options         - Additional options for how the message is posted to the log
+     *                          (default: `{}`)
+     * @returns A Promise which resolves once the message is posted
+     */
+    postOne(message: ChatMessage.ConfiguredInstance, options?: ChatLog.PostOneOptions): Promise<void>;
+
+    /**
+     * Scroll the chat log to the bottom
+     * @param options - (default: `{}`)
+     */
+    protected scrollBottom(options?: ChatLog.ScrollBottomOptions): Promise<void>;
+
+    /**
+     * Update the content of a previously posted message after its data has been replaced
+     * @param message - The ChatMessage instance to update
+     * @param notify  - Trigger a notification which shows the log as having a new unread message
+     *                  (default: `false`)
+     */
+    updateMessage(message: ChatMessage.ConfiguredInstance, notify?: boolean): Promise<void>;
+
+    /**
+     * Update the displayed timestamps for every displayed message in the chat log.
+     * Timestamps are displayed in a humanized "timesince" format.
+     */
+    updateTimestamps(): void;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle dropping of transferred data onto the chat editor
+     * @param event - The originating drop event which triggered the data transfer
+     * @internal
+     */
+    protected static _onDropTextAreaData(event: DragEvent): Promise<void>;
+
+    /**
+     * Prepare the data object of chat message data depending on the type of message being posted
+     * @param message - The original string of the message content
+     * @returns A Promise resolving to the prepared chat data object, or void if we were executing
+     *          a macro instead.
+     */
+    protected processMessage(message: string): Promise<ChatMessage.ConfiguredInstance | undefined | void>;
+
+    /**
+     * Process messages which are posted using a dice-roll command
+     * @param command       - The chat command type
+     * @param matches       - Multi-line matched roll expressions
+     * @param chatData      - The initial chat data
+     * @param createOptions - Options used to create the message
+     * @internal
+     */
+    protected _processDiceCommand(
+      command: string,
+      match: RegExpMatchArray[],
+      chatData: foundry.documents.BaseChatMessage.ConstructorData,
+      createOptions: Document.OnCreateOptions<"ChatMessage">,
+    ): Promise<void>;
+
+    /**
+     * Process messages which are posted using a chat whisper command
+     * @param command       - The chat command type
+     * @param match         - The matched RegExp expressions
+     * @param chatData      - The initial chat data
+     * @param createOptions - Options used to create the message
+     * @throws If the user does not have the permission to whisper to other players
+     * @internal
+     */
+    protected _processWhisperCommand(
+      command: string,
+      match: RegExpMatchArray,
+      chatData: foundry.documents.BaseChatMessage.ConstructorData,
+      createOptions: Document.OnCreateOptions<"ChatMessage">,
+    ): void;
+
+    /**
+     * Process messages which are posted using a chat whisper command
+     * @param command       - The chat command type
+     * @param match         - The matched RegExp expressions
+     * @param chatData      - The initial chat data
+     * @param createOptions - Options used to create the message
+     * @internal
+     */
+    protected _processChatCommand(
+      command: string,
+      match: RegExpMatchArray,
+      chatData: foundry.documents.BaseChatMessage.ConstructorData,
+      createOptions: Document.OnCreateOptions<"ChatMessage">,
+    ): void;
+
+    /**
+     * Process messages which execute a macro.
+     * @param command - The chat command typed.
+     * @param match   - The RegExp matches.
+     * @internal
+     */
+    protected _processMacroCommand(command: string, match: RegExpMatchArray): void;
+
+    /**
+     * Add a sent message to an array of remembered messages to be re-sent if the user pages up with the up arrow key
+     * @param message - The message text being remembered
+     * @internal
+     */
+    protected _remember(message: string): void;
+
+    /**
+     * Recall a previously sent message by incrementing up (1) or down (-1) through the sent messages array
+     * @param direction - The direction to recall, positive for older, negative for more recent
+     * @returns The recalled message, or an empty string
+     * @internal
+     */
+    protected _recall(direction: number): string;
+
+    protected override _contextMenu(html: JQuery): void;
+
+    /**
+     * Get the ChatLog entry context options
+     * @returns The ChatLog entry context options
+     * @internal
+     */
+    protected _getEntryContextOptions(): ContextMenuEntry[];
+
+    /**
+     * Handle keydown events in the chat entry textarea
+     * @internal
+     */
+    protected _onChatKeyDown(event: JQuery.KeyDownEvent): Promise<void> | undefined;
+
+    /**
+     * Handle setting the preferred roll mode
+     * @internal
+     */
+    protected _onChangeRollMode(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle single message deletion workflow
+     * @internal
+     */
+    protected _onDeleteMessage(event: JQuery.ClickEvent): Promise<ChatMessage.ConfiguredInstance | undefined>;
+
+    /**
+     * Handle clicking of dice tooltip buttons
+     * @internal
+     */
+    protected _onDiceRollClick(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle click events to export the chat log
+     * @internal
+     */
+    protected _onExportLog(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle click events to flush the chat log
+     * @internal
+     */
+    protected _onFlushLog(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle scroll events within the chat log container
+     * @param event - The initial scroll event
+     * @internal
+     */
+    protected _onScrollLog(event: JQuery.ScrollEvent): Promise<void> | undefined;
+
+    /**
+     * Update roll mode select dropdowns when the setting is changed
+     * @param mode - The new roll mode setting
+     * @internal
+     */
+    protected static _setRollMode(mode: keyof CONFIG.Dice.RollModes): void;
+  }
+
+  namespace ChatLog {
+    type Command =
+      | "roll"
+      | "gmroll"
+      | "blindroll"
+      | "selfroll"
+      | "publicroll"
+      | "ic"
+      | "ooc"
+      | "emote"
+      | "whisper"
+      | "reply"
+      | "gm"
+      | "players"
+      | "macro"
+      | "invalid"
+      | "none";
+
+    interface ScrollBottomOptions {
+      /**
+       * If a popout exists, scroll it too
+       * @defaultValue `undefined`
+       */
+      popout?: boolean;
+
+      /**
+       * Wait for any images embedded in the chat log to load first before scrolling?
+       */
+      waitImages?: boolean;
+
+      /**
+       * Options to configure scrolling behaviour.
+       */
+      scrollOptions?: ScrollIntoViewOptions;
+    }
+
+    interface PostOneOptions {
+      /**
+       * An existing message ID to append the message before, by default the new message is
+       * appended to the end of the log.
+       */
+      before?: string | undefined;
+      /**
+       * Trigger a notification which shows the log as having a new unread message.
+       */
+      notify?: boolean | undefined;
+    }
+  }
+}

package/src/foundry/client/apps/sidebar/tabs/combat-tracker.d.mts

@@ -0,0 +1,156 @@
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level Combat documents.
+   */
+  class CombatTracker<Options extends ApplicationOptions = ApplicationOptions> extends SidebarTab<Options> {
+    constructor(options?: Partial<Options>);
+
+    /**
+     * Record a reference to the currently highlighted Token
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _highlighted: Token.ConfiguredInstance | null;
+
+    /**
+     * Record the currently tracked Combat encounter
+     * @defaultValue `null`
+     */
+    viewed: Document.Stored<Combat.ConfiguredInstance> | null;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "combat",
+     *   template: "templates/sidebar/combat-tracker.html",
+     *   title: "COMBAT.SidebarTitle",
+     *   scrollY: [".directory-list"]
+     * })
+     * ```
+     */
+    static get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Return an array of Combat encounters which occur within the current Scene.
+     */
+    get combats(): Document.Stored<Combat.ConfiguredInstance>[];
+
+    override createPopout(): this;
+
+    /**
+     * Initialize the combat tracker to display a specific combat encounter.
+     * If no encounter is provided, the tracker will be initialized with the first encounter in the viewed scene.
+     * @param combat - The combat encounter to initialize
+     *                 (default: `null`)
+     * @param render - Whether to re-render the sidebar after initialization
+     *                 (default: `true`)
+     */
+    initialize({ combat, render }?: { combat?: Combat | null; render?: boolean }): void;
+
+    /**
+     * Scroll the combat log container to ensure the current Combatant turn is centered vertically
+     */
+    scrollToTurn(): void;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    /**
+     * Retrieve a source image for a combatant.
+     * @param combatant - The combatant queried for image.
+     * @returns The source image attributed for this combatant.
+     */
+    protected _getCombatantThumbnail(combatant: Combatant.ConfiguredInstance): Promise<string>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle new Combat creation request
+     * @internal
+     */
+    protected _onCombatCreate(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle a Combat cycle request
+     * @internal
+     */
+    protected _onCombatCycle(event: Event): Promise<void>;
+
+    /**
+     * Handle click events on Combat control buttons
+     * @param event - The originating mousedown event
+     * @internal
+     */
+    protected _onCombatControl(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle a Combatant control toggle
+     * @param event - The originating mousedown event
+     * @internal
+     */
+    protected _onCombatantControl(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Handle toggling the defeated status effect on a combatant Token
+     * @param combatant - The combatant data being modified
+     * @returns A Promise that resolves after all operations are complete
+     * @internal
+     */
+    protected _onToggleDefeatedStatus(combatant: Combatant.ConfiguredInstance): Promise<void>;
+
+    /**
+     * Handle pinging a combatant Token
+     * @param combatant - The combatant data
+     */
+    protected _onPingCombatant(combatant: Combatant.ConfiguredInstance): Promise<number | undefined>;
+
+    /**
+     * Handle mouse-down event on a combatant name in the tracker
+     * @param event - The originating mousedown event
+     * @returns A Promise that resolves once the pan is complete
+     * @internal
+     */
+    protected _onCombatantMouseDown(event: JQuery.ClickEvent): Promise<boolean | void>;
+
+    /**
+     * Handle mouse-hover events on a combatant in the tracker
+     * @internal
+     */
+    protected _onCombatantHoverIn(event: JQuery.MouseEnterEvent): void;
+
+    /**
+     * Handle mouse-unhover events for a combatant in the tracker
+     * @internal
+     */
+    protected _onCombatantHoverOut(event: JQuery.MouseLeaveEvent): void;
+
+    /**
+     * Highlight a hovered combatant in the tracker.
+     * @param combatant - The Combatant
+     * @param hover     - Whether they are being hovered in or out.
+     */
+    hoverCombatant(combatant: Combatant.ConfiguredInstance, hover: boolean): void;
+    /**
+     * Attach context menu options to elements in the tracker
+     * @param html - The HTML element to which context options are attached
+     * @internal
+     */
+    protected _contextMenu(html: JQuery): void;
+
+    /**
+     * Get the Combatant entry context options
+     * @returns The Combatant entry context options
+     * @internal
+     */
+    protected _getEntryContextOptions(): ContextMenuEntry[];
+
+    /**
+     * Display a dialog which prompts the user to enter a new initiative value for a Combatant
+     * @internal
+     */
+    protected _onConfigureCombatant(li: JQuery): void;
+  }
+}