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

package/src/foundry/client/apps/forms/journal-sheet.d.mts

@@ -0,0 +1,312 @@
+import type { MaybePromise, InexactPartial } from "../../../../types/utils.d.mts";
+
+declare global {
+  interface JournalSheetOptions extends DocumentSheetOptions<JournalEntry> {
+    /** The current display mode of the journal. Either "text" or "image". */
+    sheetMode?: JournalSheet.SheetMode | null;
+  }
+
+  /**
+   * The Application responsible for displaying and editing a single JournalEntry document.
+   * @typeParam Options - the type of the options object
+   */
+  class JournalSheet<Options extends JournalSheetOptions = JournalSheetOptions> extends DocumentSheet<
+    Options,
+    JournalEntry.ConfiguredInstance
+  > {
+    /**
+     * @defaultValue
+     * ```ts
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "journal-sheet", "journal-entry"],
+     *   template: "templates/journal/sheet.html",
+     *   width: 960,
+     *   height: 800,
+     *   resizable: true,
+     *   submitOnChange: true,
+     *   submitOnClose: true,
+     *   closeOnSubmit: false,
+     *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.NONE,
+     *   scrollY: [".scrollable"],
+     *   filters: [{inputSelector: 'input[name="search"]', contentSelector: ".directory-list"}],
+     *   dragDrop: [{dragSelector: ".directory-item, .heading-link", dropSelector: ".directory-list"}],
+     *   pageIndex: undefined,
+     *   pageId: undefined
+     * })
+     * ```
+     */
+    static override get defaultOptions(): JournalSheetOptions;
+
+    /**
+     * The cached list of processed page entries.
+     * This array is populated in the getData method.
+     */
+    _pages: JournalEntryPage.ConfiguredInstance[];
+
+    /**
+     * Get the journal entry's current view mode.
+     */
+    get mode(): (typeof JournalSheet)["VIEW_MODES"] | null;
+
+    /**
+     * The current search mode for this journal
+     */
+    get searchMode(): foundry.CONST.DIRECTORY_SEARCH_MODES;
+
+    /**
+     * Toggle the search mode for this journal between "name" and "full" text search
+     */
+    toggleSearchMode(): void;
+
+    /**
+     * The pages that are currently scrolled into view and marked as 'active' in the sidebar.
+     */
+    get pagesInView(): HTMLElement[];
+
+    /**
+     * The index of the currently viewed page.
+     */
+    get pageIndex(): number;
+
+    /**
+     * The currently active IntersectionObserver.
+     */
+    get observer(): IntersectionObserver;
+
+    /**
+     * Is the table-of-contents sidebar currently collapsed?
+     */
+    get sidebarCollapsed(): boolean;
+
+    /**
+     * Available view modes for journal entries.
+     */
+    static VIEW_MODES: { SINGLE: 1; MULTIPLE: 2 };
+
+    /**
+     * The minimum amount of content that must be visible before the next page is marked as in view. Cannot be less than
+     * 25% without also modifying the IntersectionObserver threshold.
+     * @defaultValue `0.25`
+     */
+    static INTERSECTION_RATIO: number;
+
+    /**
+     * Icons for page ownership.
+     */
+    static OWNERSHIP_ICONS: Record<foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS, string>;
+
+    override get title(): string;
+
+    protected override _getHeaderButtons(): Application.HeaderButton[];
+
+    override getData(options?: Partial<Options>): MaybePromise<object>; // TODO: implement GetDataReturnType
+
+    /**
+     * Prepare pages for display.
+     * @returns The sorted list of pages.
+     */
+    protected _getPageData(): JournalEntryPage.ConfiguredInstance[];
+
+    /**
+     * Identify which page of the journal sheet should be currently rendered.
+     * This can be controlled by options passed into the render method or by a subclass override.
+     * @param options - Sheet rendering options
+     */
+    protected _getCurrentPage(
+      options?: InexactPartial<{
+        /** A numbered index of page to render */
+        pageIndex: number;
+
+        /** The ID of a page to render */
+        pageId: string;
+      }>,
+    ): number;
+
+    override activateListeners(html: JQuery<HTMLElement>): void;
+
+    /**
+     * Activate listeners after page content has been injected.
+     */
+    protected _activatePageListeners(): void;
+
+    protected override _render(force?: boolean, options?: JournalSheet.RenderOptions<Options>): Promise<void>;
+
+    /**
+     * Update child views inside the main sheet.
+     */
+    protected _renderPageViews(): Promise<void>;
+
+    /**
+     * Add headings to the table of contents for the given page node.
+     * @param pageNode - The HTML node of the page's rendered contents.
+     * @param toc      - The page's table of contents.
+     */
+    protected _renderHeadings(
+      pageNode: HTMLElement,
+      toc: Record<string, JournalEntryPage.JournalEntryPageHeading>,
+    ): void;
+
+    /**
+     * Create an intersection observer to maintain a list of headings that are in view. This is much more performant than
+     * calling getBoundingClientRect on all headings whenever we want to determine this list.
+     */
+    protected _observeHeadings(): void;
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    /**
+     * Handle clicking the previous and next page buttons.
+     * @param event - The button click event.
+     */
+    protected _onAction(event: JQuery.TriggeredEvent): void;
+
+    /**
+     * Prompt the user with a Dialog for creation of a new JournalEntryPage
+     */
+    createPage(): Promise<JournalEntryPage.ConfiguredInstance>;
+
+    /**
+     * Turn to the previous page.
+     */
+    previousPage(): void;
+
+    /**
+     * Turn to the next page.
+     */
+    nextPage(): void;
+
+    /**
+     * Turn to a specific page.
+     * @param pageId - The ID of the page to turn to.
+     * @param anchor - Optionally an anchor slug to focus within that page.
+     */
+    goToPage(pageId: string, anchor?: string): void;
+
+    /**
+     * Retrieve the sheet instance for rendering this page inline.
+     * @param pageId - The ID of the page.
+     */
+    getPageSheet(pageId: string): JournalPageSheet; // Should probably be configured sheet class?
+
+    /**
+     * Determine whether a page is visible to the current user.
+     * @param page - The Page
+     */
+    isPageVisible(page: JournalEntryPage): boolean;
+
+    /**
+     * Toggle the collapsed or expanded state of the Journal Entry table-of-contents sidebar.
+     */
+    toggleSidebar(): void;
+
+    /**
+     * Update the disabled state of the previous and next page buttons.
+     */
+    protected _updateButtonState(): void;
+
+    /**
+     *  Edit one of this JournalEntry's JournalEntryPages.
+     * @param event - The originating page edit event
+     */
+    protected _onEditPage(event: JQuery.TriggeredEvent): void;
+
+    /**
+     * Handle clicking an entry in the sidebar to scroll that heading into view.
+     * @param event - The originating click event
+     */
+    protected _onClickPageLink(event: JQuery.TriggeredEvent): void;
+
+    /**
+     * Handle clicking an image to pop it out for fullscreen view.
+     * @param event - The click event
+     */
+    protected _onClickImage(event: MouseEvent): void;
+
+    /**
+     * Handle new pages scrolling into view.
+     * @param entries  - An Array of elements that have scrolled into or out of view.
+     * @param observer - The IntersectionObserver that invoked this callback.
+     */
+    protected _onPageScroll(entries: IntersectionObserverEntry[], observer: IntersectionObserver): void;
+
+    /**
+     * Highlights the currently viewed page in the sidebar.
+     */
+    protected _activatePagesInView(): void;
+
+    /**
+     * If the set of active pages has changed, various elements in the sidebar will expand and collapse. For particularly
+     * long ToCs, this can leave the scroll position of the sidebar in a seemingly random state. We try to do our best to
+     * sync the sidebar scroll position with the current journal viewport.
+     */
+    protected _synchronizeSidebar(): void;
+
+    protected _contextMenu(html: JQuery<HTMLElement>): void;
+
+    /**
+     * Handle opening the context menu.
+     * @param target - The element the context menu has been triggered for.
+     */
+    protected _onContextMenuOpen(target: HTMLElement): void;
+
+    /**
+     * Handle closing the context menu.
+     * @param target - The element the context menu has been triggered for.
+     */
+    protected _onContextMenuClose(target: HTMLElement): void;
+
+    /**
+     * Get the set of ContextMenu options which should be used for JournalEntryPages in the sidebar.
+     * @returns The Array of context options passed to the ContextMenu instance.
+     */
+    protected _getEntryContextOptions(): ContextMenuEntry[];
+
+    protected override _updateObject(event: Event, formData: JournalSheet.FormData): Promise<unknown>;
+
+    /**
+     * Handle requests to show the referenced Journal Entry to other Users
+     * Save the form before triggering the show request, in case content has changed
+     * @param event - The triggering click event
+     * @internal
+     */
+    protected _onShowPlayers(event: Event): Promise<void>;
+
+    protected _canDragStart(selector: string): boolean;
+
+    protected _canDragDrop(selector: string): boolean;
+
+    protected _onDragStart(event: DragEvent): void;
+
+    protected _onDrop(event: DragEvent): Promise<void>;
+
+    protected _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+  }
+
+  namespace JournalSheet {
+    type Any = JournalSheet<any>;
+
+    type SheetMode = "text" | "image";
+
+    type RenderOptions<Options extends JournalSheetOptions = JournalSheetOptions> = Application.RenderOptions<Options> &
+      InexactPartial<{
+        /** Render the sheet in a given view mode, see {@link JournalSheet.VIEW_MODES}. */
+        mode: number;
+        /** Render the sheet with the page with the given ID in view. */
+        pageId: string;
+        /** Render the sheet with the page at the given index in view. */
+        pageIndex: number;
+        /** Render the sheet with the given anchor for the given page in view. */
+        anchor: string;
+        /** Whether the journal entry or one of its pages is being shown to players who might otherwise not have permission to view it. */
+        tempOwnership: boolean;
+        /** Render the sheet with the TOC sidebar collapsed? */
+        collapsed?: boolean;
+      }>;
+
+    interface FormData {
+      content: string;
+      folder: string;
+      name: string;
+    }
+  }
+}

package/src/foundry/client/apps/forms/macro-config.d.mts

@@ -0,0 +1,59 @@
+import type { GetDataReturnType, MaybePromise, ValueOf } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A Macro configuration sheet
+   *
+   * @typeParam Options - the type of the options object
+   */
+  class MacroConfig<
+    Options extends DocumentSheetOptions<Macro.ConfiguredInstance> = DocumentSheetOptions<Macro.ConfiguredInstance>,
+  > extends DocumentSheet<Options, Macro.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "macro-sheet"],
+     *   template: "templates/sheets/macro-config.html",
+     *   width: 560,
+     *   height: 480,
+     *   resizable: true
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<Macro>;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<MacroConfig.MacroConfigData>>;
+
+    override activateListeners(html: JQuery): void;
+
+    protected override _disableFields(form: HTMLElement): void;
+
+    /**
+     * Save and execute the macro using the button on the configuration sheet
+     * @param event - The originating click event
+     * @internal
+     */
+    protected _onExecute(event: MouseEvent): Promise<void>;
+
+    protected override _updateObject(event: Event, formData: MacroConfig.FormData): Promise<unknown>;
+  }
+
+  namespace MacroConfig {
+    type Any = MacroConfig<any>;
+
+    interface FormData {
+      command: string;
+      img: string;
+      name: string;
+      type: ValueOf<typeof CONST.MACRO_TYPES>;
+    }
+
+    interface MacroConfigData<
+      Options extends DocumentSheetOptions<Macro.ConfiguredInstance> = DocumentSheetOptions<Macro.ConfiguredInstance>,
+    > extends DocumentSheet.DocumentSheetData<Options, Macro.ConfiguredInstance> {
+      macroTypes: Record<string, string>;
+      macroScopes: typeof CONST.MACRO_TYPES;
+    }
+  }
+}

package/src/foundry/client/apps/forms/measure-template.d.mts

@@ -0,0 +1,59 @@
+import type { ConfiguredDocumentClassForName } from "../../../../types/helperTypes.d.mts";
+import type { GetDataReturnType, MaybePromise, ValueOf } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single MeasuredTemplate document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   */
+  class MeasuredTemplateConfig<
+    Options extends DocumentSheetOptions<MeasuredTemplateDocument> = DocumentSheetOptions<MeasuredTemplateDocument>,
+  > extends DocumentSheet<Options, InstanceType<ConfiguredDocumentClassForName<"MeasuredTemplate">>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "template-config",
+     *   classes: ["sheet", "template-sheet"],
+     *   title: "TEMPLATE.MeasuredConfig",
+     *   template: "templates/scene/template-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<MeasuredTemplateDocument>;
+
+    override getData(): MaybePromise<GetDataReturnType<MeasuredTemplateConfig.MeasuredTemplateConfigData>>;
+
+    protected override _updateObject(event: Event, formData: MeasuredTemplateConfig.FormData): Promise<unknown>;
+  }
+
+  namespace MeasuredTemplateConfig {
+    type Any = MeasuredTemplateConfig<any>;
+
+    interface FormData {
+      angle: number | null;
+      borderColor: string;
+      direction: number | null;
+      distance: number | null;
+      fillColor: string;
+      hidden: boolean;
+      t: ValueOf<foundry.CONST.MEASURED_TEMPLATE_TYPES>;
+      texture: string;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+    }
+
+    interface MeasuredTemplateConfigData<
+      Options extends DocumentSheetOptions<MeasuredTemplateDocument> = DocumentSheetOptions<MeasuredTemplateDocument>,
+    > extends DocumentSheet.DocumentSheetData<
+        Options,
+        InstanceType<ConfiguredDocumentClassForName<"MeasuredTemplate">>
+      > {
+      templateTypes: Record<foundry.CONST.MEASURED_TEMPLATE_TYPES, string>;
+      gridUnits: string;
+      submitText: string;
+    }
+  }
+}

package/src/foundry/client/apps/forms/ownership.d.mts

@@ -0,0 +1,66 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A generic application for configuring permissions for various Document types
+   * @typeParam Options          - the type of the options object
+   * @typeParam ConcreteDocument - the type of the Document which should be managed by this form sheet
+   */
+  class DocumentOwnershipConfig<
+    Options extends DocumentSheetOptions<ConcreteDocument>,
+    ConcreteDocument extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+  > extends DocumentSheet<Options, ConcreteDocument> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "permission",
+     *   template: "templates/apps/ownership.html",
+     *   width: 400
+     * })
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions;
+
+    override get title(): string;
+
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<DocumentOwnershipConfig.DocumentOwnershipConfigData>>;
+
+    protected override _updateObject(event: Event, formData: DocumentOwnershipConfig.FormData): Promise<unknown>;
+  }
+
+  namespace DocumentOwnershipConfig {
+    type Any = DocumentOwnershipConfig<any, any>;
+  }
+
+  /**
+   * @deprecated since v10.
+   */
+  class PermissionControl extends DocumentOwnershipConfig<any, any> {}
+
+  namespace DocumentOwnershipConfig {
+    interface FormData {
+      [userId: string]: FormData.InputPermissionLevel;
+      default: FormData.InputPermissionLevel;
+    }
+
+    namespace FormData {
+      type InputPermissionLevel = foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS | -1 | -2;
+    }
+
+    interface DocumentOwnershipConfigData {
+      currentDefault: { level: number; label: string };
+      instructions: string;
+      defaultLevels: { level: number; label: string }[];
+      playerLevels: { level: number; label: string }[];
+      isFolder: boolean;
+      users: {
+        user: User;
+        level: number;
+        isAuthor: boolean;
+      }[];
+    }
+  }
+}

package/src/foundry/client/apps/forms/playlist-config.d.mts

@@ -0,0 +1,46 @@
+import type { GetDataReturnType, MaybePromise, ValueOf } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Playlist document.
+   * @typeParam Options - the type of the options object
+   */
+  class PlaylistConfig<
+    Options extends
+      DocumentSheetOptions<Playlist.ConfiguredInstance> = DocumentSheetOptions<Playlist.ConfiguredInstance>,
+  > extends DocumentSheet<Options, Playlist.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.id = "playlist-config";
+     * options.template = "templates/playlist/edit-playlist.html";
+     * options.width = 360;
+     * ```
+     */
+    static get defaultOptions(): DocumentSheetOptions<Playlist.ConfiguredInstance>;
+
+    override get title(): string;
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<PlaylistConfig.PlaylistConfigData>>;
+
+    protected override _getFilePickerOptions(event: PointerEvent): FilePickerOptions;
+
+    /**
+     * @remarks The return type could be given more concretely but it is not supposed to be used.
+     */
+    protected override _onSelectFile(selection: string, filePicker: FilePicker): unknown;
+  }
+
+  namespace PlaylistConfig {
+    type Any = PlaylistConfig<any>;
+
+    interface PlaylistConfigData<
+      Options extends
+        DocumentSheetOptions<Playlist.ConfiguredInstance> = DocumentSheetOptions<Playlist.ConfiguredInstance>,
+    > extends DocumentSheet.DocumentSheetData<Options, Playlist.ConfiguredInstance> {
+      modes: Record<ValueOf<typeof foundry.CONST.PLAYLIST_MODES>, string>;
+      sorting: Record<ValueOf<typeof foundry.CONST.PLAYLIST_SORT_MODES>, string>;
+    }
+  }
+}

package/src/foundry/client/apps/forms/playlist-sound-config.d.mts

@@ -0,0 +1,63 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The Application responsible for configuring a single PlaylistSound document within a parent Playlist.
+   *
+   * @param sound   - The PlaylistSound document being configured
+   * @param options - Additional application rendering options
+   * @typeParam Options - the type of the options object
+   */
+  class PlaylistSoundConfig<
+    Options extends
+      DocumentSheetOptions<PlaylistSound.ConfiguredInstance> = DocumentSheetOptions<PlaylistSound.ConfiguredInstance>,
+  > extends DocumentSheet<Options, PlaylistSound.ConfiguredInstance> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "track-config",
+     *   template: "templates/playlist/edit-track.html",
+     *   width: 360
+     * });
+     * ```
+     */
+    static override get defaultOptions(): DocumentSheetOptions<PlaylistSound.ConfiguredInstance>;
+
+    override get title(): string;
+
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<PlaylistSoundConfig.PlaylistSoundConfigData>>;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Auto-populate the track name using the provided filename, if a name is not already set
+     * @internal
+     */
+    protected _onSourceChange(event: JQuery.ChangeEvent): void;
+
+    protected override _updateObject(event: Event, formData: PlaylistSoundConfig.FormData): Promise<unknown>;
+  }
+
+  namespace PlaylistSoundConfig {
+    type Any = PlaylistSoundConfig<any>;
+
+    interface FormData {
+      description: string;
+      fade: number | null;
+      lvolume: number;
+      name: string;
+      path: string;
+      repeat: boolean;
+    }
+
+    interface PlaylistSoundConfigData<
+      Options extends
+        DocumentSheetOptions<PlaylistSound.ConfiguredInstance> = DocumentSheetOptions<PlaylistSound.ConfiguredInstance>,
+    > extends DocumentSheet.DocumentSheetData<Options, PlaylistSound.ConfiguredInstance> {
+      lvolume: number;
+    }
+  }
+}