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

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

@@ -0,0 +1,86 @@
+import type { MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /** An application for configuring data across all installed and active packages. */
+  abstract class PackageConfiguration<
+    Options extends PackageConfiguration.Options = PackageConfiguration.Options,
+  > extends FormApplication<Options, object> {
+    /** @returns `["all", "core", "system", "module", "unmapped"]` */
+    static get categoryOrder(): string[];
+
+    /** The name of the currently active tab. */
+    get activeCategory(): string;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["package-configuration"],
+     *   template: "templates/sidebar/apps/package-configuration.html",
+     *   categoryTemplate: undefined,
+     *   width: 780,
+     *   height: 680,
+     *   resizable: true,
+     *   scrollY: [".filters", ".categories"],
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form .scrollable", initial: "all"}],
+     *   filters: [{inputSelector: 'input[name="filter"]', contentSelector: ".categories"}],
+     *   submitButton: false
+     * });
+     * ```
+     */
+    static override get defaultOptions(): PackageConfiguration.Options;
+
+    override getData(): MaybePromise<object>; // TODO: Implement GetDataReturnType
+
+    /** Prepare the structure of category data which is rendered in this configuration form. */
+    protected abstract _prepareCategoryData(): PackageConfiguration.CategoryData;
+
+    /**
+     * Classify what Category an Action belongs to
+     * @param namespace - The entry to classify
+     * @returns The category the entry belongs to
+     */
+    protected _categorizeEntry(namespace: string): PackageConfiguration.Category;
+
+    /** Reusable logic for how categories are sorted in relation to each other. */
+    protected _sortCategories(a: PackageConfiguration.Category, b: PackageConfiguration.Category): number;
+
+    /** {@inheritdoc} */
+    protected override _render(
+      force?: boolean,
+      options?: Application.RenderOptions<Options> & { activeCategory: string },
+    ): Promise<void>;
+
+    /** {@inheritdoc} */
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
+
+    protected override _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+
+    /**
+     * Handle button click to reset default settings
+     * @param event - The initial button click event
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): void;
+  }
+
+  namespace PackageConfiguration {
+    type Any = PackageConfiguration<any>;
+
+    interface Options extends FormApplicationOptions {
+      categoryTemplate?: string;
+      submitButton?: boolean;
+    }
+
+    interface Category {
+      id: string;
+      title: string;
+    }
+
+    interface CategoryData<PackageCategory extends Category = Category> {
+      categories: PackageCategory[];
+      total: number;
+    }
+  }
+}

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

@@ -0,0 +1,80 @@
+export {};
+
+declare global {
+  /**
+   * An abstract pattern followed by the different tabs of the sidebar
+   * @typeParam Options - The type of the options object
+   */
+  abstract class SidebarTab<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    constructor(...args: ConstructorParameters<typeof Application>);
+
+    /**
+     * A reference to the pop-out variant of this SidebarTab, if one exists
+     * @defaultValue `null`
+     */
+    protected _popout: this | null;
+
+    /**
+     * Denote whether this is the original version of the sidebar tab, or a pop-out variant
+     * @defaultValue `null`
+     */
+    protected _original: this | null;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: null,
+     *   popOut: false,
+     *   width: 300,
+     *   height: "auto",
+     *   classes: ["tab", "sidebar-tab"],
+     *   baseApplication: "SidebarTab"
+     * });
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    override get id(): string;
+
+    /**
+     * The base name of this sidebar tab
+     */
+    get tabName(): string;
+
+    override getData(options?: Partial<Options>): Promise<object>; // TODO: implement GetDataReturnType
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    protected override _renderInner(data: object): Promise<JQuery>;
+
+    /**
+     * Activate this SidebarTab, switching focus to it
+     */
+    activate(): void;
+
+    override close(options?: Application.CloseOptions): Promise<void>;
+
+    /**
+     * Create a second instance of this SidebarTab class which represents a singleton popped-out container
+     * @returns The popped out sidebar tab instance
+     */
+    createPopout(): this;
+
+    /**
+     * Render the SidebarTab as a pop-out container
+     */
+    renderPopout(): void;
+
+    /**
+     * Handle lazy loading for sidebar images to only load them once they become observed
+     * @param entries  - The entries which are now observed
+     * @param observer - The intersection observer instance
+     */
+    protected _onLazyLoadImage(entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
+  }
+
+  namespace SidebarTab {
+    type Any = SidebarTab<any>;
+  }
+}

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;
+    }
+  }
+}