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

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

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

@@ -0,0 +1,105 @@
+export {};
+
+declare global {
+  /**
+   * A compendium of knowledge arcane and mystical!
+   * Renders the sidebar directory of compendium packs
+   * @typeParam Options - The type of the options object
+   */
+  class CompendiumDirectory<Options extends ApplicationOptions = ApplicationOptions> extends DirectoryApplicationMixin(
+    SidebarTab,
+  ) {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "compendium",
+     *   template: "templates/sidebar/compendium-directory.html",
+     *   title: "COMPENDIUM.SidebarTitle",
+     *   contextMenuSelector: ".directory-item.compendium",
+     *   entryClickSelector: ".compendium"
+     * });
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    get activeFilters(): string[];
+
+    // NOTE: It seems in source this is erroneously defined as a property, not a getter
+    override get entryType(): "Compendium";
+
+    static override entryPartial: "templates/sidebar/partials/pack-partial.html";
+
+    protected override _entryAlreadyExists(entry: DirectoryMixinEntry): boolean;
+
+    protected override _getEntryDragData(entryId: string): object;
+
+    protected override _entryIsSelf(entry: DirectoryMixinEntry, otherEntry: DirectoryMixinEntry): boolean;
+
+    protected override _sortRelative(
+      entry: DirectoryMixinEntry,
+      sortData: { sortKey: string; sortBefore: boolean; updateData: object },
+    ): Promise<object>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Display a menu of compendium types to filter by
+     * @param event - The originating pointer event
+     */
+    protected _displayFilterCompendiumMenu(event: PointerEvent): Promise<void>;
+
+    /**
+     * Handle toggling a compendium type filter
+     * @param event - The originating pointer event
+     * @param type  - The compendium type to filter by. If null, clear all filters.
+     */
+    protected _onToggleCompendiumFilterType(event: PointerEvent, type: string | null): void;
+
+    /**
+     * The collection of Compendium Packs which are displayed in this Directory
+     */
+    get collection(): CompendiumPacks;
+
+    /**
+     * Get the dropped Entry from the drop data
+     * @param data - The data being dropped
+     * @returns The dropped Entry
+     */
+    protected _getDroppedEntryFromData(data: object): Promise<DirectoryMixinEntry>;
+
+    protected override _createDroppedEntry(entry: DirectoryMixinEntry, folderId?: string): Promise<DirectoryMixinEntry>;
+
+    protected override _getEntryName(entry: object): string;
+
+    protected override _getEntryId(entry: object): string;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    override render(
+      force?: boolean,
+      options?: Application.RenderOptions<ApplicationOptions> | undefined,
+    ): Promise<unknown>;
+
+    /**
+     * Get the sidebar directory entry context options
+     * @returns The sidebar entry context options
+     * @internal
+     */
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+
+    protected override _onClickEntryName(event: PointerEvent): Promise<void>;
+
+    protected override _onCreateEntry(event: PointerEvent): Promise<void>;
+
+    /**
+     * Handle a Compendium Pack deletion request
+     * @param pack - The pack object requested for deletion
+     * @internal
+     */
+    protected _onDeleteCompendium(
+      pack: CompendiumCollection<CompendiumCollection.Metadata>,
+    ): Promise<CompendiumCollection<CompendiumCollection.Metadata> | void>;
+  }
+}

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

@@ -0,0 +1,12 @@
+import "./actors-directory.d.mts";
+import "./cards-directory.d.mts";
+import "./chat-log.d.mts";
+import "./combat-tracker.d.mts";
+import "./compendium-directory.d.mts";
+import "./items-directory.d.mts";
+import "./journal-directory.d.mts";
+import "./macros-directory.d.mts";
+import "./playlists-directory.d.mts";
+import "./roll-table-directory.d.mts";
+import "./scenes-directory.d.mts";
+import "./settings.d.mts";

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

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

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

@@ -0,0 +1,13 @@
+export {};
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level JournalEntry documents.
+   * @typeParam Options - The type of the options object
+   */
+  class JournalDirectory extends DocumentDirectory<"JournalEntry"> {
+    static override documentName: "JournalEntry";
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+  }
+}

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

@@ -0,0 +1,16 @@
+export {};
+
+declare global {
+  /**
+   * The directory, not displayed in the sidebar, which organizes and displays world-level Macro documents.
+   *
+   * @see {@link Macros}        The WorldCollection of Macro Documents
+   * @see {@link Macro}         The Macro Document
+   * @see {@link MacroConfig}   The Macro Configuration Sheet
+   */
+  class MacroDirectory extends DocumentDirectory<"Macro"> {
+    constructor(options?: Partial<DocumentDirectoryOptions>);
+
+    static override documentName: "Macro";
+  }
+}

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

@@ -0,0 +1,275 @@
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level Playlist documents.
+   * @typeParam Options - The type of the options object
+   */
+  class PlaylistDirectory<
+    Options extends DocumentDirectoryOptions = DocumentDirectoryOptions,
+  > extends DocumentDirectory<"Playlist", Options> {
+    constructor(options?: Partial<Options>);
+
+    /**
+     * Track the playlist IDs which are currently expanded in their display
+     * @internal
+     */
+    protected _expanded: Set<string>;
+
+    /**
+     * Are the global volume controls currently expanded?
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _volumeExpanded: boolean;
+
+    /**
+     * Cache the set of Playlist documents that are displayed as playing when the directory is rendered
+     * @defaultValue `[]`
+     */
+    protected _playingPlaylists: Playlist.ConfiguredInstance[];
+
+    /**
+     * Cache the set of PlaylistSound documents that are displayed as playing when the directory is rendered
+     * @defaultValue `[]`
+     */
+    protected _playingSounds: PlaylistSound.ConfiguredInstance[];
+
+    /**
+     * @internal
+     * @defaultValue `undefined`
+     * @remarks This is only initialized and set in `getData`.
+     */
+    protected _playingSoundsData?: PlaylistDirectory.SoundData[] | undefined;
+
+    static override documentName: "Playlist";
+
+    /**
+     * @defaultValue `"templates/sidebar/partials/playlist-partial.html"`
+     */
+    static override entryPartial: string;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.template = "templates/sidebar/playlists-directory.html";
+     * options.dragDrop[0].dragSelector = ".folder, .playlist-name, .sound-name";
+     * options.renderUpdateKeys = ["name", "playing", "mode", "sounds", "sort", "sorting", "folder"];
+     * options.contextMenuSelector = ".document .playlist-header";
+     * return options;
+     * ```
+     */
+    static override get defaultOptions(): DocumentDirectoryOptions;
+
+    /**
+     * Initialize the set of Playlists which should be displayed in an expanded form
+     * @internal
+     */
+    protected _createExpandedSet(): Set<string>;
+
+    /**
+     * Return an Array of the Playlist documents which are currently playing
+     */
+    get playing(): Playlist.ConfiguredInstance[];
+
+    /**
+     * Whether the "currently playing" element is pinned to the top or bottom of the display.
+     * @internal
+     */
+    protected get _playingLocation(): "top" | "bottom";
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    /**
+     * Converts a volume level to a human-friendly % value
+     * @param volume - Value between [0, 1] of the volume level
+     */
+    static volumeToTooltip(volume: number): string;
+
+    /**
+     * Augment the tree directory structure with playlist-level data objects for rendering
+     * @param node - The tree leaf node being prepared
+     * @internal
+     */
+    protected _prepareTreeData(node: DirectoryCollection.TreeNode<Playlist.ConfiguredInstance>): void;
+
+    /**
+     * Create an object of rendering data for each Playlist document being displayed
+     * @param playlist - The playlist to display
+     * @returns The data for rendering
+     * @internal
+     */
+    protected _preparePlaylistData(playlist: Playlist.ConfiguredInstance): PlaylistDirectory.PlaylistData;
+
+    /**
+     * Get the icon used to represent the "play/stop" icon for the PlaylistSound
+     * @param sound - The sound being rendered
+     * @returns The icon that should be used
+     * @internal
+     */
+    protected _getPlayIcon(sound: PlaylistSound.ConfiguredInstance): string;
+
+    /**
+     * Get the icon used to represent the pause/loading icon for the PlaylistSound
+     * @param sound - The sound being rendered
+     * @returns The icon that should be used
+     * @internal
+     */
+    protected _getPauseIcon(sound: PlaylistSound.ConfiguredInstance): string;
+
+    /**
+     * Given a constant playback mode, provide the FontAwesome icon used to display it
+     * @internal
+     */
+    protected _getModeIcon(mode: foundry.CONST.PLAYLIST_MODES): string;
+
+    /**
+     * Given a constant playback mode, provide the string tooltip used to describe it
+     * @internal
+     */
+    protected _getModeTooltip(mode: foundry.CONST.PLAYLIST_MODES): string;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle global volume change for the playlist sidebar
+     * @param event - The initial click event
+     * @internal
+     */
+    protected _onGlobalVolume(event: JQuery.ClickEvent): unknown;
+
+    override collapseAll(): void;
+
+    protected override _onClickEntryName(event: PointerEvent): Promise<void>;
+
+    /**
+     * Handle global volume control collapse toggle
+     * @param event - The initial click event
+     * @internal
+     */
+    protected _onVolumeCollapse(event: JQuery.ClickEvent): void;
+
+    /**
+     * Helper method to render the expansion or collapse of playlists
+     * @param speed - (default: `250`)
+     * @internal
+     */
+    protected _collapse(el: HTMLElement, collapse: boolean, speed?: number): void;
+
+    /**
+     * Handle Playlist playback state changes
+     * @param event   - The initial click event
+     * @param playing - Is the playlist now playing?
+     * @internal
+     */
+    protected _onPlaylistPlay(event: JQuery.ClickEvent, playing: boolean): Promise<Playlist.ConfiguredInstance>;
+
+    /**
+     * Handle advancing the playlist to the next (or previous) sound
+     * @param event  - The initial click event
+     * @param action - The control action requested
+     * @internal
+     */
+    protected _onPlaylistSkip(event: JQuery.ClickEvent, action: string): Promise<Playlist.ConfiguredInstance>;
+
+    /**
+     * Handle cycling the playback mode for a Playlist
+     * @param event - The initial click event
+     * @internal
+     */
+    protected _onPlaylistToggleMode(event: JQuery.ClickEvent): Promise<Playlist.ConfiguredInstance>;
+
+    /**
+     * Handle Playlist track addition request
+     * @param event - The initial click event
+     * @internal
+     */
+    protected _onSoundCreate(event: JQuery.ClickEvent): void;
+
+    /**
+     * Modify the playback state of a Sound within a Playlist
+     * @param event  - The initial click event
+     * @param action - The sound control action performed
+     * @internal
+     */
+    protected _onSoundPlay(event: JQuery.ClickEvent, action: string): Promise<Playlist.ConfiguredInstance | undefined>;
+
+    /**
+     * Handle volume adjustments to sounds within a Playlist
+     * @param event - The initial change event
+     * @internal
+     */
+    protected _onSoundVolume(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle changes to the sound playback mode
+     * @param event - The initial click event
+     * @internal
+     */
+    protected _onSoundToggleMode(event: JQuery.ClickEvent): Promise<void>;
+
+    /** @internal */
+    protected _onPlayingPin(): void;
+
+    protected override _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+
+    /**
+     * Update the displayed timestamps for all currently playing audio sources.
+     * Runs on an interval every 1000ms.
+     * @internal
+     */
+    protected _updateTimestamps(): void;
+
+    /**
+     * Format the displayed timestamp given a number of seconds as input
+     * @param seconds - The current playback time in seconds
+     * @returns The formatted timestamp
+     * @internal
+     */
+    protected _formatTimestamp(seconds: number): string;
+
+    protected override _contextMenu(html: JQuery): void;
+
+    protected override _getFolderContextOptions(): ContextMenuEntry[];
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+
+    /**
+     * Get context menu options for individual sound effects
+     * @returns The context options for each sound
+     * @internal
+     */
+    protected _getSoundContextOptions(): ContextMenuEntry[];
+
+    protected override _onDragStart(event: DragEvent): void;
+
+    protected override _onDrop(event: DragEvent): Promise<Playlist.ConfiguredInstance | boolean>;
+  }
+
+  namespace PlaylistDirectory {
+    type PlaylistData = Document.ToObjectFalseType<Playlist.ConfiguredInstance> & {
+      modeTooltip: string;
+      modeIcon: string;
+      disabled: boolean;
+      expanded: boolean;
+      css: string;
+      controlCSS: string;
+      sounds: SoundData[];
+    };
+
+    type SoundData = Document.ToObjectFalseType<PlaylistSound.ConfiguredInstance> & {
+      playlistId: string | null;
+      css: string;
+      controlCSS: string;
+      playIcon: string;
+      playTitle: string;
+      isPaused?: boolean;
+      pauseIcon?: string;
+      lvolume?: number;
+      currentTime?: string;
+      durationTime?: string;
+    };
+  }
+}

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

@@ -0,0 +1,13 @@
+export {};
+
+declare global {
+  /**
+   * The sidebar directory which organizes and displays world-level RollTable documents.
+   * @typeParam Options - The type of the options object
+   */
+  class RollTableDirectory extends DocumentDirectory<"RollTable"> {
+    static override documentName: "RollTable";
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+  }
+}

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

@@ -0,0 +1,34 @@
+export {};
+
+declare global {
+  /**
+   * A directory listing of active game scenes
+   */
+  class SceneDirectory extends DocumentDirectory<"Scene"> {
+    static override documentName: "Scene";
+
+    /**
+     * @defaultValue `"templates/sidebar/scene-partial.html"`
+     */
+    static override entryPartial: string;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.renderUpdateKeys.push("background");
+     * return options;
+     * ```
+     */
+    static override get defaultOptions(): DocumentDirectoryOptions;
+
+    protected override _render(
+      force?: boolean,
+      options?: Application.RenderOptions<DocumentDirectoryOptions>,
+    ): Promise<void>;
+
+    protected override _getEntryContextOptions(): ContextMenuEntry[];
+
+    protected override _getFolderContextOptions(): ContextMenuEntry[];
+  }
+}