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

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,164 @@
+import type { ConfiguredDocumentClassForName } from "../../../../types/helperTypes.d.mts";
+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 ? InstanceType<ConfiguredDocumentClassForName<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";

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