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

package/src/foundry/client/apps/sidebar/apps/support-details.d.mts

@@ -0,0 +1,121 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * Support Info and Report
+   * @typeParam Options - the type of the options object
+   */
+  class SupportDetails<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.title = "SUPPORT.Title";
+     * options.id = "support-details";
+     * options.template = "templates/sidebar/apps/support-details.html";
+     * options.width = 780;
+     * options.height = 680;
+     * options.resizable = true;
+     * options.classes = ["sheet"];
+     * options.tabs = [{navSelector: ".tabs", contentSelector: "article", initial: "support"}];
+     * return options;
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    /**
+     * Returns the support report data
+     */
+    // TODO: Implement GetDataReturnType
+    getData(options?: Partial<Options>): MaybePromise<object>;
+
+    /**
+     * Binds the Support Report copy button
+     */
+    override activateListeners(html: JQuery): void;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions): Promise<void>;
+
+    /**
+     * @internal
+     */
+    protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery>;
+
+    /**
+     * Handle a button click action.
+     * @param event - The click event
+     */
+    protected _onClickAction(event: MouseEvent): void;
+
+    /**
+     * Copy the support details report to clipboard.
+     */
+    protected _copyReport(): void;
+
+    /**
+     * Marshal information on Documents that failed validation and format it for display.
+     */
+    protected _getDocumentValidationErrors(): {
+      label: string;
+      documents: {
+        name: string;
+        validationError: string;
+      };
+    }[];
+
+    /**
+     * Marshal package-related warnings and errors and format it for display.
+     */
+    protected _getModuleIssues(): {
+      label: string;
+      issues: {
+        label: string;
+        issues: {
+          severity: "error" | "warning";
+          message: string;
+        }[];
+      }[];
+    }[];
+
+    /**
+     * Collects a number of metrics that is useful for Support
+     */
+    static generateSupportReport(): SupportReportData;
+
+    /**
+     * Get a WebGL renderer information string
+     * @param gl - The rendering context
+     * @returns The unmasked renderer string
+     */
+    static getWebGLRendererInfo(gl: WebGLRenderingContext): string;
+  }
+
+  namespace SupportDetails {
+    type Any = SupportDetails<any>;
+  }
+
+  interface SupportReportData {
+    coreVersion: number;
+    systemVersion: string;
+    activeModuleCount: number;
+    os: string;
+    client: string;
+    gpu: string;
+    maxTextureSize: number | string;
+    sceneDimensions: string;
+    grid: number;
+    padding: number; // note: float in actual code
+    walls: number;
+    lights: number;
+    sounds: number;
+    tiles: number;
+    tokens: number;
+    actors: number;
+    items: number;
+    journals: number;
+    tables: number;
+    playlists: number;
+    packs: number;
+    messages: number;
+  }
+}

package/src/foundry/client/apps/sidebar/apps/tours-management.d.mts

@@ -0,0 +1,54 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /** A management app for configuring which Tours are available or have been completed. */
+  class ToursManagement extends PackageConfiguration {
+    /** @remarks This is not implemented in {@link ToursManagement} and will throw. */
+    protected override _updateObject(event: Event, formData?: object): Promise<never>;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "tours-management",
+     *   title: game.i18n.localize("SETTINGS.Tours"),
+     *   categoryTemplate: "templates/sidebar/apps/tours-management-category.html"
+     * });
+     * ```
+     */
+    static override get defaultOptions(): PackageConfiguration.Options;
+
+    override _prepareCategoryData(): ToursManagement.TourCategoryData;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _onResetDefaults(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle Control clicks
+     * @internal
+     */
+    protected _onClickControl(event: JQuery.ClickEvent): MaybePromise<unknown>;
+  }
+
+  namespace ToursManagement {
+    interface TourData {
+      category: string;
+      id: string;
+      title: string;
+      description: string;
+      cssClass: string;
+      notes: string;
+      status: string;
+      canBePlayed?: boolean;
+      startOrResume?: string;
+    }
+
+    interface Category extends PackageConfiguration.Category {
+      tours: TourData[];
+      count: number;
+    }
+
+    interface TourCategoryData extends PackageConfiguration.CategoryData<Category> {}
+  }
+}

package/src/foundry/client/apps/sidebar/apps/world-config.d.mts

@@ -0,0 +1,57 @@
+import type { MaybePromise } from "../../../../../types/utils.d.mts";
+
+declare global {
+  interface WorldConfigOptions extends FormApplicationOptions {
+    /**
+     * Whether the world is being created or updated.
+     * @defaultValue `false`
+     */
+    create: boolean;
+  }
+
+  /**
+   * The World Management setup application
+   * @typeParam Options - The type of the options object
+   */
+  class WorldConfig<Options extends WorldConfigOptions = WorldConfigOptions> extends FormApplication<Options, World> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "world-config",
+     *   template: "templates/sidebar/apps/world-config.html",
+     *   width: 620,
+     *   height: "auto",
+     *   create: false,
+     * })
+     * ```
+     */
+    static override get defaultOptions(): WorldConfigOptions;
+
+    /**
+     * A semantic alias for the World object which is being configured by this form.
+     */
+    get world(): World;
+
+    override get title(): string;
+
+    override activateListeners(html: JQuery): void;
+
+    // TODO: Implement GetDataReturnType
+    override getData(options?: Partial<Options>): MaybePromise<object>;
+
+    protected override _getSubmitData(updateData?: object | null): WorldConfig.FormData;
+
+    protected override _updateObject(event: Event, formData: WorldConfig.FormData): Promise<number | void>;
+
+    override activateEditor(
+      name: string,
+      options?: TextEditor.Options,
+      initialContent?: string,
+    ): ReturnType<FormApplication["activateEditor"]>;
+  }
+
+  namespace WorldConfig {
+    type FormData = Partial<World["_source"]>;
+  }
+}

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

@@ -0,0 +1,276 @@
+import type { Mixin } from "../../../../types/utils.d.mts";
+
+declare class DirectoryApplication {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * The path to the template partial which renders a single Entry within this directory
+   */
+  static entryPartial: string;
+
+  /**
+   * The path to the template partial which renders a single Folder within this directory
+   */
+  static folderPartial: string;
+
+  static get defaultOptions(): DocumentDirectoryOptions;
+
+  /**
+   * The type of Entry that is contained in this DirectoryTab.
+   */
+  get entryType(): string;
+
+  /**
+   * The maximum depth of folder nesting which is allowed in this DirectoryTab
+   */
+  get maxFolderDepth(): number;
+
+  /**
+   * Can the current User create new Entries in this DirectoryTab?
+   */
+  get canCreateEntry(): boolean;
+
+  /**
+   * Can the current User create new Folders in this DirectoryTab?
+   */
+  get canCreateFolder(): boolean;
+
+  protected _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+
+  /**
+   * Identify folders in the collection which match a provided search query.
+   * This method is factored out to be extended by subclasses, for example to support compendium indices.
+   * @param query         - The search query
+   * @param includeFolder - A callback function to include the folder of any matched entry
+   */
+  protected _matchSearchFolders(
+    query: RegExp,
+    includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
+  ): void;
+
+  /**
+   * Identify entries in the collection which match a provided search query.
+   * This method is factored out to be extended by subclasses, for example to support compendium indices.
+   * @param query         - The search query
+   * @param entryIds      - The set of matched Entry IDs
+   * @param folderIds     - The set of matched Folder IDs
+   * @param includeFolder - A callback function to include the folder of any matched entry
+   */
+  protected _matchSearchEntries(
+    query: RegExp,
+    entryIds: Set<string>,
+    folderIds: Set<string>,
+    includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
+  ): void;
+
+  /**
+   * Get the name to search against for a given entry
+   * @param entry - The entry to get the name for
+   * @returns The name of the entry
+   */
+  protected _getEntryName(entry: object): string;
+
+  /**
+   * Get the ID for a given entry
+   * @param entry - The entry to get the id for
+   * @returns The id of the entry
+   */
+  protected _getEntryId(entry: object): string;
+
+  getData(options?: Partial<ApplicationOptions>): Promise<object>; // TODO: Implement GetDataReturnType
+
+  protected _render(force?: boolean, options?: Application.RenderOptions<ApplicationOptions>): Promise<void>;
+
+  activateListeners(html: JQuery): void;
+
+  /**
+   * Collapse all subfolders in this directory
+   */
+  collapseAll(): void;
+
+  /**
+   * Create a new Folder in this SidebarDirectory
+   * @param event - The originating button click event
+   */
+  protected _onCreateFolder(event: PointerEvent): void;
+
+  /**
+   * Handle toggling the collapsed or expanded state of a folder within the directory tab
+   * @param event - The originating click event
+   */
+  protected _toggleFolder(event: PointerEvent): void;
+
+  /**
+   * Handle clicking on a Document name in the Sidebar directory
+   * @param event - The originating click event
+   */
+  protected _onClickEntryName(event: PointerEvent): Promise<void>;
+
+  /**
+   * Handle new Entry creation request
+   * @param event - The originating button click event
+   */
+  protected _onCreateEntry(event: PointerEvent): Promise<void>;
+
+  protected _onDragStart(event: DragEvent): void;
+
+  /**
+   * Get the data transfer object for a Entry being dragged from this SidebarDirectory
+   * @param entryId - The Entry's _id being dragged
+   */
+  protected _getEntryDragData(entryId: string): object; // TODO: DragData improvements
+
+  /**
+   * Get the data transfer object for a Folder being dragged from this SidebarDirectory
+   * @param folderId - The Folder _id being dragged
+   */
+  protected _getFolderDragData(folderId: string): object;
+
+  protected _canDragStart(selector: string): boolean;
+
+  /**
+   * Highlight folders as drop targets when a drag event enters or exits their area
+   * @param event - The DragEvent which is in progress
+   */
+  protected _onDragHighlight(event: DragEvent): void;
+
+  protected _onDrop(event: DragEvent): void;
+
+  /**
+   * Handle Folder data being dropped into the directory.
+   * @param target - The target element
+   * @param data   - The data being dropped // TODO: DragData improvements
+   */
+  protected _handleDroppedFolder(target: HTMLElement, data: object): Promise<void>;
+
+  /**
+   * Handle a new Folder being dropped into the directory.
+   * This case is not handled by default, but subclasses may implement custom handling here.
+   * @param folder          - The Folder being dropped
+   * @param closestFolderId - The closest Folder _id to the drop target
+   * @param sortData        - The sort data for the Folder
+   */
+  protected _handleDroppedForeignFolder(
+    folder: Folder,
+    closestFolderId: string,
+    sortData: {
+      /**
+       * The sort key to use for sorting
+       */
+      sortKey: string;
+      /**
+       * Sort before the target?
+       */
+      sortBefore: boolean;
+    },
+  ): Promise<{ folder: Folder.ConfiguredInstance; sortNeeded: boolean } | null>;
+
+  /**
+   * Handle Entry data being dropped into the directory.
+   * @param target - The target element
+   * @param data   - The data being dropped // TODO: DragData improvements
+   */
+  protected _handleDroppedEntry(target: HTMLElement, data: object): Promise<void>;
+
+  /**
+   * Determine if an Entry is being compared to itself
+   * @param entry      - The Entry
+   * @param otherEntry - The other Entry
+   * @returns Is the Entry being compared to itself?
+   */
+  protected _entryIsSelf(entry: DirectoryMixinEntry, otherEntry: DirectoryMixinEntry): boolean;
+
+  /**
+   * Determine whether an Entry belongs to the target folder
+   * @param entry  - The Entry
+   * @param folder - The target Folder
+   * @returns Is the Entry a sibling?
+   */
+  protected _entryBelongsToFolder(entry: DirectoryMixinEntry, folder: Folder.ConfiguredInstance): boolean;
+
+  /**
+   * Check if an Entry is already present in the Collection
+   * @param entry - The entry being dropped
+   * @returns Is the Entry already present?
+   */
+  protected _entryAlreadyExists(entry: DirectoryMixinEntry): boolean;
+
+  /**
+   * Get the dropped Entry from the drop data
+   * @param data - The data being dropped
+   * @returns The dropped Entry
+   */
+  protected _getDroppedEntryFromData(data: object): Promise<DirectoryMixinEntry>;
+
+  /**
+   * Create a dropped Entry in this Collection
+   * @param entry    - The Entry being dropped
+   * @param folderId - The ID of the Folder to which the Entry should be added
+   * @returns THe created Entry
+   */
+  protected _createDroppedEntry(entry: DirectoryMixinEntry, folderId?: string): Promise<DirectoryMixinEntry>;
+
+  /**
+   * Sort a relative entry within a collection
+   * @param entry    - The entry to sort
+   * @param sortData - The sort data
+   * @returns The sorted entry
+   */
+  protected _sortRelative(
+    entry: DirectoryMixinEntry,
+    sortData: {
+      /**
+       * The sort key to use for sorting
+       */
+      sortKey: string;
+      /**
+       * Sort before the target?
+       */
+      sortBefore: boolean;
+      /**
+       * Additional data to update on the entry
+       */
+      updateData: object;
+    },
+  ): Promise<object>;
+
+  protected _contextMenu(html: JQuery): void;
+
+  /**
+   * Get the set of ContextMenu options which should be used for Folders in a SidebarDirectory
+   * @returns The Array of context options passed to the ContextMenu instance
+   */
+  protected _getFolderContextOptions(): ContextMenuEntry[];
+
+  /**
+   * Get the set of ContextMenu options which should be used for Entries in a SidebarDirectory
+   * @returns The array of context options passed to the ContextMenu instance
+   */
+  protected _getEntryContextOptions(): ContextMenuEntry[];
+}
+
+declare global {
+  interface DirectoryMixinEntry {
+    /**
+     * The unique id of the entry
+     */
+    id: string;
+    /**
+     * The folder id or folder object to which this entry belongs
+     */
+    folder: Folder.ConfiguredInstance | string;
+    /**
+     * An image path to display for the entry
+     */
+    img?: string;
+    /**
+     * A numeric sort value which orders this entry relative to others
+     */
+    sort?: string;
+  }
+
+  function DirectoryApplicationMixin<BaseApplication extends Application.AnyConstructor>(
+    Base: BaseApplication,
+  ): Mixin<typeof DirectoryApplication, BaseApplication>;
+}

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

@@ -0,0 +1,163 @@
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  interface DocumentDirectoryOptions extends ApplicationOptions {
+    /**
+     * A list of data property keys that will trigger a rerender of the tab if
+     * they are updated on a Document that this tab is responsible for.
+     */
+    renderUpdateKeys?: string[];
+
+    /**
+     * The CSS selector that activates the context menu for displayed Documents.
+     */
+    contextMenuSelector?: string;
+
+    /**
+     * The CSS selector for the clickable area of an entry in the tab.
+     */
+    entryClickSelector?: string;
+  }
+
+  class DocumentDirectory<
+    FolderType extends foundry.CONST.FOLDER_DOCUMENT_TYPES,
+    Options extends DocumentDirectoryOptions = DocumentDirectoryOptions,
+  > extends DirectoryApplicationMixin(SidebarTab) {
+    constructor(options: Options);
+
+    /**
+     * References to the set of Documents which are displayed in the Sidebar
+     */
+    documents: FolderType extends Document.Type ? Document.ConfiguredInstanceForName<FolderType>[] : undefined;
+
+    /**
+     * Reference the set of Folders which exist in this Sidebar
+     */
+    folders: (Folder.ConfiguredInstance & { type: FolderType })[] | null;
+
+    /**
+     * A reference to the named Document type that this Sidebar Directory instance displays
+     * @defaultValue `"Document"`
+     */
+    static documentName: string;
+
+    static override entryPartial: string;
+
+    get entryType(): string;
+
+    /**
+     * @defaultValue
+     * ```ts
+     * return foundry.utils.mergeObject(super.defaultOptions, {
+     *   template: "templates/sidebar/document-directory.html",
+     *   renderUpdateKeys: ["name", "img", "thumb", "ownership", "sort", "sorting", "folder"]
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DocumentDirectoryOptions;
+
+    override get title(): string;
+
+    override get id(): string;
+
+    override get tabName(): string;
+
+    static get collection(): WorldCollection<Document.AnyConstructor, string>;
+
+    /**
+     * Initialize the content of the directory by categorizing folders and documents into a hierarchical tree structure.
+     */
+    initialize(): void;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    override get canCreateEntry(): boolean;
+
+    override get canCreateFolder(): boolean;
+
+    override getData(options?: Partial<Options>): Promise<object>;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    protected override _onClickEntryName(event: PointerEvent): Promise<void>;
+
+    protected override _onCreateEntry(event: PointerEvent): Promise<void>;
+
+    protected override _onDrop(event: DragEvent): void;
+
+    protected override _handleDroppedEntry(target: HTMLElement, data: object): Promise<void>;
+
+    protected override _getDroppedEntryFromData(data: object): Promise<DirectoryMixinEntry>;
+
+    protected override _sortRelative(
+      entry: DirectoryMixinEntry,
+      sortData: { sortKey: string; sortBefore: boolean; updateData: object },
+    ): Promise<object>;
+
+    protected override _createDroppedEntry(entry: DirectoryMixinEntry, folderId?: string): Promise<DirectoryMixinEntry>;
+
+    protected override _handleDroppedForeignFolder(
+      folder: Folder.ConfiguredInstance,
+      closestFolderId: string,
+      sortData: { sortKey: string; sortBefore: boolean },
+    ): Promise<{ folder: Folder; sortNeeded: boolean } | null>;
+
+    /**
+     * Create a dropped Folder and its children in this Collection, if they do not already exist
+     * @param folder       - The Folder being dropped
+     * @param targetFolder - The Folder to which the Folder should be added
+     * @returns The created Folders
+     */
+    protected _createDroppedFolderContent(
+      folder: Folder.ConfiguredInstance,
+      targetFolder: Folder.ConfiguredInstance,
+    ): Promise<Array<Folder.ConfiguredInstance>>;
+
+    /**
+     * Organize a dropped Folder and its children into a list of folders to create and documents to create
+     * @param folder       - The Folder being dropped
+     * @param targetFolder - The Folder to which the Folder should be added
+     */
+    protected _organizeDroppedFoldersAndDocuments(
+      folder: Folder.ConfiguredInstance,
+      targetFolder: Folder.ConfiguredInstance,
+    ): Promise<{
+      foldersToCreate: Array<Folder.ConfiguredInstance>;
+      documentsToCreate: Array<foundry.abstract.Document.Any>;
+    }>;
+
+    /**
+     * Create a list of documents in a dropped Folder
+     * @param folder            - The Folder being dropped
+     * @param documentsToCreate - The documents to create
+     */
+    protected _createDroppedFolderDocuments(
+      folder: Folder.ConfiguredInstance,
+      documentsToCreate: Array<foundry.abstract.Document.Any>,
+    ): Promise<void>;
+
+    protected override _getFolderContextOptions(): ContextMenuEntry[];
+
+    /**
+     * Get the set of ContextMenu options which should be used for Documents in a SidebarDirectory
+     * @returns The Array of context options passed to the ContextMenu instance
+     */
+    protected _getEntryContextOptions(): ContextMenuEntry[];
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"DocumentDirectory#_onCreateDocument is deprecated. Please use DocumentDirectory#_onCreateEntry instead."`
+     */
+    protected _onCreateDocument(event: PointerEvent): Promise<void>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"DocumentDirectory#_handleDroppedDocument is deprecated. Please use DocumentDirectory#_handleDroppedEntry instead."`
+     */
+    protected _handleDroppedDocument(target: HTMLElement, data: object): Promise<void>;
+  }
+
+  namespace DocumentDirectory {
+    type Any = DocumentDirectory<any, any>;
+  }
+}

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

@@ -0,0 +1,7 @@
+import "./apps/index.d.mts";
+import "./directory-tab-mixin.d.mts";
+import "./document-directory.d.mts";
+import "./package-configuration.d.mts";
+import "./sidebar-tab.d.mts";
+import "./sidebar.d.mts";
+import "./tabs/index.d.mts";