@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1

package/src/foundry/client/appv1/sheets/item-sheet.d.mts

@@ -0,0 +1,68 @@
+import type { GetDataReturnType, MaybePromise } from "#utils";
+import type { DocumentSheet } from "../api/_module.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationConfig {
+      ItemSheet: ItemSheet.Any;
+    }
+  }
+}
+
+/**
+ * The Application responsible for displaying and editing a single Item document.
+ *
+ * @param item    - The Item instance being displayed within the sheet.
+ * @param options - Additional application configuration options.
+ *
+ * @template Options - the type of the options object
+ */
+declare class ItemSheet<Options extends ItemSheet.Options = ItemSheet.Options> extends DocumentSheet<
+  Item.Implementation,
+  Options
+> {
+  /**
+   * @defaultValue
+   * ```typescript
+   * foundry.utils.mergeObject(super.defaultOptions, {
+   *   template: "templates/sheets/item-sheet.html",
+   *   width: 500,
+   *   closeOnSubmit: false,
+   *   submitOnClose: true,
+   *   submitOnChange: true,
+   *   resizable: true,
+   *   baseApplication: "ItemSheet",
+   *   id: "item",
+   *   secrets: [{parentSelector: ".editor"}]
+   * })
+   * ```
+   */
+  static get defaultOptions(): ItemSheet.Options;
+
+  override get title(): string;
+
+  /**
+   * A convenience reference to the Item document
+   */
+  get item(): this["object"];
+
+  /**
+   * The Actor instance which owns this item. This may be null if the item is
+   * unowned.
+   */
+  get actor(): this["item"]["actor"];
+
+  override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<ItemSheet.ItemSheetData>>;
+}
+
+declare namespace ItemSheet {
+  interface Any extends ItemSheet<any> {}
+
+  interface Options extends DocumentSheet.Options<Item.Implementation> {}
+
+  interface ItemSheetData<Options extends ItemSheet.Options = ItemSheet.Options>
+    extends DocumentSheet.DocumentSheetData<Options, Item.Implementation> {
+    item: this["document"];
+  }
+}
+export default ItemSheet;

package/src/foundry/client/appv1/sheets/journal-page-sheet.d.mts

@@ -0,0 +1,179 @@
+import type { Editor } from "tinymce";
+import type { EditorView } from "prosemirror-view";
+import type { GetDataReturnType, Identity, MaybePromise } from "#utils";
+import type Showdown from "showdown";
+import type { Application, DocumentSheet, FormApplication } from "../api/_module.d.mts";
+import type TextEditor from "#client/applications/ux/text-editor.mjs";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationConfig {
+      JournalPageSheet: JournalPageSheet.Any;
+      JournalTextTinyMCESheet: JournalTextTinyMCESheet.Any;
+    }
+  }
+}
+
+/**
+ * The Application responsible for displaying and editing a single JournalEntryPage document.
+ */
+declare class JournalPageSheet<
+  Options extends JournalPageSheet.Options = JournalPageSheet.Options,
+> extends DocumentSheet<JournalEntryPage.Implementation, Options> {
+  /**
+   * @defaultValue
+   * ```typescript
+   * foundry.utils.mergeObject(super.defaultOptions, {
+   *   classes: ["sheet", "journal-sheet", "journal-entry-page"],
+   *   viewClasses: [],
+   *   width: 600,
+   *   height: 680,
+   *   resizable: true,
+   *   closeOnSubmit: false,
+   *   submitOnClose: true,
+   *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.OBSERVER,
+   *   includeTOC: true
+   * });
+   * ```
+   */
+  static override get defaultOptions(): JournalPageSheet.Options;
+
+  override get template(): string;
+
+  override get title(): string;
+
+  toc: Record<string, JournalEntryPage.JournalEntryPageHeading>;
+
+  override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<JournalPageSheet.JournalPageSheetData>>;
+
+  protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery<HTMLElement>>;
+
+  protected override _getSecretContent(secret: HTMLElement): string;
+
+  protected override _updateSecret(
+    secret: HTMLElement,
+    content: string,
+  ): Promise<void | JournalEntryPage.Implementation>;
+
+  override activateEditor(
+    name: string,
+    options?: TextEditor.Options,
+    initialContent?: string,
+  ): Promise<Editor | EditorView>;
+
+  /**
+   * Update the parent sheet if it is open when the server autosaves the contents of this editor.
+   * @param html - The updated editor contents.
+   */
+  onAutosave(html: string): void;
+
+  /**
+   * Update the UI appropriately when receiving new steps from another client.
+   */
+  onNewSteps(): void;
+}
+
+declare namespace JournalPageSheet {
+  interface Any extends AnyJournalPageSheet {}
+  interface AnyConstructor extends Identity<typeof AnyJournalPageSheet> {}
+
+  interface Options extends DocumentSheet.Options<JournalEntryPage.Implementation> {}
+
+  interface JournalPageSheetData extends DocumentSheet.DocumentSheetData<Options, JournalEntryPage.Implementation> {
+    headingLevels: Record<number, string>;
+  }
+}
+
+/**
+ * The Application responsible for displaying and editing a single JournalEntryPage text document.
+ */
+declare class JournalTextPageSheet extends JournalPageSheet {
+  /**
+   * Bi-directional HTML \<-\> Markdown converter.
+   */
+  protected static _converter: Showdown.Converter;
+
+  /**
+   * Declare the format that we edit text content in for this sheet so we can perform conversions as necessary.
+   * @defaultValue `CONST.JOURNAL_ENTRY_PAGE_FORMATS.HTML`
+   */
+  static get format(): foundry.CONST.JOURNAL_ENTRY_PAGE_FORMATS;
+
+  /**
+   * @defaultValue
+   * ```typescript
+   * const options = super.defaultOptions;
+   * options.classes.push("text");
+   * options.secrets.push({parentSelector: "section"});
+   * return options;
+   * ```
+   */
+  static override get defaultOptions(): JournalPageSheet.Options;
+
+  override getData(
+    options?: Partial<JournalPageSheet.Options>,
+  ): Promise<GetDataReturnType<JournalTextPageSheet.TextData>>;
+
+  override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+  protected override _render(
+    force?: boolean,
+    options?: Application.RenderOptions<JournalPageSheet.Options>,
+  ): Promise<void>;
+
+  /**
+   * Determine if any editors are dirty.
+   */
+  isEditorDirty(): boolean;
+
+  protected _updateObject(event: Event, formData: object): Promise<unknown>;
+
+  /**
+   * Lazily convert text formats if we detect the document being saved in a different format.
+   * @param renderData - Render data.
+   */
+  protected _convertFormats(renderData: object): void;
+}
+
+declare namespace JournalTextPageSheet {
+  interface TextData extends JournalPageSheet.JournalPageSheetData {
+    editor: {
+      engine: string;
+      collaborate: boolean;
+      content: string;
+    };
+  }
+}
+
+/**
+ * A subclass of {@linkcode JournalTextPageSheet} that implements a TinyMCE editor.
+ */
+declare class JournalTextTinyMCESheet extends JournalTextPageSheet {
+  override getData(
+    options?: Partial<JournalPageSheet.Options>,
+  ): Promise<GetDataReturnType<JournalTextTinyMCESheet.MCEData>>;
+
+  override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+  protected override _render(
+    force?: boolean,
+    options?: Application.RenderOptions<JournalPageSheet.Options>,
+  ): Promise<void>;
+}
+
+declare namespace JournalTextTinyMCESheet {
+  interface Any extends AnyJournalTextTinyMCESheet {}
+  interface AnyConstructor extends Identity<typeof AnyJournalTextTinyMCESheet> {}
+
+  interface MCEData extends JournalTextPageSheet.TextData {}
+}
+
+declare abstract class AnyJournalPageSheet extends JournalPageSheet<JournalPageSheet.Options> {
+  constructor(...args: never);
+}
+
+declare abstract class AnyJournalTextTinyMCESheet extends JournalTextTinyMCESheet {
+  constructor(...args: never);
+}
+
+export { JournalPageSheet, JournalTextPageSheet, JournalTextTinyMCESheet };

package/src/foundry/client/appv1/sheets/journal-sheet.d.mts

@@ -0,0 +1,325 @@
+import type { MaybePromise, InexactPartial } from "#utils";
+import type { Application, DocumentSheet, FormApplication } from "../api/_module.d.mts";
+import type { JournalPageSheet } from "./journal-page-sheet.d.mts";
+
+declare module "#configuration" {
+  namespace Hooks {
+    interface ApplicationConfig {
+      JournalSheet: JournalSheet.Any;
+    }
+  }
+}
+
+/**
+ * The Application responsible for displaying and editing a single JournalEntry document.
+ * @template Options - the type of the options object
+ */
+declare class JournalSheet<Options extends JournalSheet.Options = JournalSheet.Options> extends DocumentSheet<
+  JournalEntry.Implementation,
+  Options
+> {
+  /**
+   * @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(): JournalSheet.Options;
+
+  /**
+   * The cached list of processed page entries.
+   * This array is populated in the getData method.
+   */
+  _pages: JournalEntryPage.Implementation[];
+
+  /**
+   * 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.Implementation[];
+
+  /**
+   * 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?: JournalSheet.GetCurrentPageOptions): 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.Implementation>;
+
+  /**
+   * 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.Implementation): 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(): foundry.applications.ux.ContextMenu.Entry<JQuery>[];
+
+  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;
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  protected _onDrop(event: DragEvent): Promise<void>;
+
+  protected _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+}
+
+declare namespace JournalSheet {
+  interface Any extends JournalSheet<any> {}
+
+  type SheetMode = "text" | "image";
+
+  interface Options extends DocumentSheet.Options<JournalEntry.Implementation> {
+    /** The current display mode of the journal. Either "text" or "image". */
+    sheetMode?: JournalSheet.SheetMode | null;
+  }
+
+  type RenderOptions<Options extends JournalSheet.Options = JournalSheet.Options> = Application.RenderOptions<Options> &
+    InexactPartial<{
+      /** Render the sheet in a given view mode, see {@linkcode 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;
+  }
+
+  interface GetCurrentPageOptions {
+    /** A numbered index of page to render */
+    pageIndex?: number | undefined;
+
+    /** The ID of a page to render */
+    pageId?: string | undefined;
+  }
+}
+
+export default JournalSheet;

package/src/foundry/client/audio/_types.d.mts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+export {};
+
+type AudioBufferCacheEntry = foundry.audio.AudioBufferCache.Entry;
+
+type SoundCreationOptions = foundry.audio.AudioHelper.SoundCreationOptions;
+
+type SoundPlaybackOptions = foundry.audio.Sound.PlaybackOptions;
+
+type SoundScheduleCallback = foundry.audio.Sound.ScheduleCallback;

package/src/foundry/client/audio/biquad.d.mts

@@ -0,0 +1,102 @@
+import type { Identity, InexactPartial, NullishProps } from "#utils";
+
+/**
+ * A sound effect which applies a biquad filter.
+ */
+declare class BiquadFilterEffect extends BiquadFilterNode {
+  /**
+   * A ConvolverEffect is constructed by passing the following parameters.
+   * @param context - The audio context required by the BiquadFilterNode
+   * @param options - Additional options which modify the BiquadFilterEffect behavior
+   */
+  // options: not null (destructured)
+  constructor(context: AudioContext, options?: BiquadFilterEffect.ConstructorOptions);
+
+  /**
+   * Adjust the intensity of the effect on a scale of 0 to 10
+   */
+  get intensity(): number;
+
+  set intensity(value);
+
+  /**
+   * Update the state of the effect node given the active flag and numeric intensity.
+   * @param options - Options which are updated
+   * @throws If `type` is set to any value in {@link BiquadFilterEffect.AllowedFilterType} other than `"highpass"` or `"lowpass"`
+   */
+  // options: not null (destructured)
+  update(options?: BiquadFilterEffect.UpdateOptions): void;
+}
+
+declare namespace BiquadFilterEffect {
+  interface Any extends AnyBiquadFilterEffect {}
+  interface AnyConstructor extends Identity<typeof AnyBiquadFilterEffect> {}
+
+  /**
+   * Foundry keeps this specific list in a private static property of {@linkcode BiquadFilterEffect}.
+   * It is typed as it is to make obvious where it comes from.
+   *
+   * @privateRemarks An `Exclude` would have been shorter but for all we know the lib type might change, this is reliable
+   *
+   * @internal
+   */
+  type AspirationalAllowedFilterType = Extract<
+    "lowpass" | "highpass" | "bandpass" | "lowshelf" | "highshelf" | "peaking" | "notch",
+    BiquadFilterType
+  >;
+
+  /**
+   * @remarks Despite `BiquadFilterEffect.#ALLOWED_TYPES` containing everything in the Aspirational
+   * type, the runtime logic will throw on anything but these two values
+   */
+  type AllowedFilterType = Extract<"highpass" | "lowpass", AspirationalAllowedFilterType>;
+
+  /** @internal */
+  type _ConstructorOptions = InexactPartial<{
+    /**
+     * The initial intensity of the effect
+     * @defaultValue `5`
+     * @remarks Can't be `null` as it only has a parameter default
+     */
+    intensity: number;
+
+    /**
+     * The filter type to apply
+     * @defaultValue `"lowpass"`
+     * @remarks Can't be `null` as it only has a parameter default.
+     *
+     * Only allows a subset of {@linkcode BiquadFilterType}s
+     */
+    type: AllowedFilterType;
+  }>;
+
+  /**
+   * @privateRemarks The {@linkcode BiquadFilterEffect} constructor only adds the one
+   * new property (`intensity`) to the parent interface. `type` is omitted and reimplemented to allow
+   * explicit `undefined`, as there's a parameter default available, and limit to Foundry's allowed values
+   */
+  interface ConstructorOptions extends _ConstructorOptions, Omit<BiquadFilterOptions, "type"> {}
+
+  type _UpdateOptions = NullishProps<{
+    /**
+     * A new effect intensity
+     * @remarks This is ignored if it fails a `Number.isFinite` check
+     */
+    intensity: number;
+
+    /**
+     * A new filter type
+     * @see {@linkcode BiquadFilterEffect.AllowedFilterType}
+     * @see {@linkcode BiquadFilterEffect.AspirationalAllowedFilterType}
+     */
+    type: AllowedFilterType;
+  }>;
+
+  interface UpdateOptions extends _UpdateOptions {}
+}
+
+export default BiquadFilterEffect;
+
+declare abstract class AnyBiquadFilterEffect extends BiquadFilterEffect {
+  constructor(...args: never);
+}