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

package/src/foundry/client/apps/av/cameras.d.mts

@@ -0,0 +1,189 @@
+import type { GetDataReturnType, MaybePromise } from "../../../../types/utils.d.mts";
+import type Document from "../../../common/abstract/document.d.mts";
+
+declare global {
+  /**
+   * The Camera UI View that displays all the camera feeds as individual video elements.
+   * @typeParam Options - the type of the options object
+   */
+  class CameraViews<Options extends ApplicationOptions = ApplicationOptions> extends Application<Options> {
+    constructor(options: Options);
+
+    /** @defaultValue `undefined` */
+    maxZ?: number;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * return foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "camera-views",
+     *   template: "templates/hud/camera-views.html",
+     *   popOut: false,
+     *   width: 240,
+     *   resizable: {selector: ".camera-view-width-control, resizeY: false}
+     * })
+     * ```
+     */
+    static override get defaultOptions(): ApplicationOptions;
+
+    /**
+     * A reference to the master AV orchestrator instance
+     */
+    get webrtc(): Game["webrtc"];
+
+    /**
+     * If all camera views are popped out, hide the dock.
+     */
+    get hidden(): boolean;
+
+    /**
+     * Obtain a reference to the div.camera-view which is used to portray a given Foundry User.
+     * @param userId - The ID of the User document
+     */
+    getUserCameraView(userId: string): HTMLElement | null;
+
+    /**
+     * Obtain a reference to the video.user-camera which displays the video channel for a requested Foundry User.
+     * If the user is not broadcasting video this will return null.
+     * @param userId - The ID of the User document
+     */
+    getUserVideoElement(userId: string): HTMLVideoElement | null;
+
+    /**
+     * Sets whether a user is currently speaking or not
+     *
+     * @param userId   - The ID of the user
+     * @param speaking - Whether the user is speaking
+     */
+    setUserIsSpeaking(userId: string, speaking: boolean): void;
+
+    /**
+     * Extend the render logic to first check whether a render is necessary based on the context
+     * If a specific context was provided, make sure an update to the navigation is necessary before rendering
+     */
+    render(force?: boolean, context?: Application.RenderOptions<Options>): this;
+
+    /**
+     * @param force   - Render and display the application even if it is not currently displayed.
+     *                  (default: `false`)
+     * @param options - Additional options which update the current values of the @see Application#options object
+     * @internal
+     */
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    override setPosition(
+      position?: Partial<Omit<Application.Position, "zIndex">>,
+    ): void | (Application.Position & { height: number });
+
+    override getData(options?: Partial<Options>): MaybePromise<GetDataReturnType<CameraViews.CameraViewsData>>;
+
+    /**
+     * Prepare rendering data for a single user
+     * @internal
+     */
+    protected _getDataForUser(userId: string, settings: AVSettings.UserSettings): CameraViews.User | null;
+
+    /**
+     * A custom sorting function that orders/arranges the user display frames
+     * @internal
+     */
+    protected static _sortUsers(a: CameraViews.User, b: CameraViews.User): number;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * On hover in a camera container, show/hide the controls.
+     * @param event - The original mouseover or mouseout hover event
+     * @internal
+     */
+    protected _onCameraViewHover(event: JQuery.MouseEnterEvent | JQuery.MouseLeaveEvent): void;
+
+    /**
+     * On clicking on a toggle, disable/enable the audio or video stream.
+     * @param event - The originating click event
+     * @internal
+     */
+    protected _onClickControl(event: JQuery.ClickEvent): Promise<void>;
+
+    /**
+     * Change volume control for a stream
+     * @param event - The originating change event from interaction with the range input
+     * @internal
+     */
+    protected _onVolumeChange(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Dynamically refresh the state of a single camera view
+     * @param userId - The ID of the user whose view we want to refresh.
+     */
+    protected _refreshView(userId: string): void;
+
+    /**
+     * Render changes needed to the PlayerList ui.
+     * Show/Hide players depending on option.
+     * @internal
+     */
+    protected _setPlayerListVisibility(): void;
+
+    /**
+     * Get the icon class that should be used for various action buttons with different toggled states.
+     * The returned icon should represent the visual status of the NEXT state (not the CURRENT state).
+     *
+     * @param action - The named av-control button action
+     * @param state  - The CURRENT action state.
+     * @returns The icon that represents the NEXT action state.
+     */
+    protected _getToggleIcon(action: string, state: boolean): string | null;
+
+    /**
+     * Get the text title that should be used for various action buttons with different toggled states.
+     * The returned title should represent the tooltip of the NEXT state (not the CURRENT state).
+     *
+     * @param action - The named av-control button action
+     * @param state - The CURRENT action state.
+     * @returns The icon that represents the NEXT action state.
+     */
+    protected _getToggleTooltip(action: string, state: boolean): string;
+
+    /**
+     * Show or hide UI control elements
+     * This replaces the use of jquery.show/hide as it simply adds a class which has display:none
+     * which allows us to have elements with display:flex which can be hidden then shown without
+     * breaking their display style.
+     * This will show/hide the toggle buttons, volume controls and overlay sidebars
+     * @param container - The container for which to show/hide control elements
+     * @param show      - Whether to show or hide the controls
+     * @param selector  - Override selector to specify which controls to show or hide
+     *                    (default: `".control-bar"`)
+     * @internal
+     */
+    protected _toggleControlVisibility(container: HTMLElement, show: boolean, selector?: string): void;
+  }
+
+  namespace CameraViews {
+    type Any = CameraViews<any>;
+
+    interface User {
+      user: Document.Stored<globalThis.User>;
+      settings: AVSettings.UserSettings;
+      local: Document.Stored<globalThis.User>["isSelf"];
+      charname: string;
+      volume: number;
+      cameraViewClass: string;
+    }
+
+    interface CameraViewsData {
+      self: Game["user"];
+      muteAll: boolean;
+      borderColors: boolean;
+      dockClass: string;
+      hidden: boolean;
+      users: CameraViews.User[];
+      nameplates: {
+        cssClass: string;
+        playerName: boolean;
+        charname: boolean;
+      };
+    }
+  }
+}

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

@@ -0,0 +1,3 @@
+import "./av-config.d.mts";
+import "./camera-popout.d.mts";
+import "./cameras.d.mts";

package/src/foundry/client/apps/dialogs/folder-export.d.mts

@@ -0,0 +1,16 @@
+export {};
+
+declare global {
+  /**
+   * A Dialog subclass which allows the user to configure export options for a Folder
+   */
+  class FolderExport extends Dialog {
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * Handle changing the selected pack by updating the dropdown of folders available.
+     * @param event   - The input change event
+     */
+    protected _onPackChange(event: Event): void;
+  }
+}

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

@@ -0,0 +1 @@
+import "./folder-export.d.mts";

package/src/foundry/client/apps/form.d.mts

@@ -0,0 +1,469 @@
+import type { EditorView } from "prosemirror-view";
+import type { Editor } from "tinymce";
+import type { AnyObject, GetDataReturnType, MaybePromise } from "../../../types/utils.d.mts";
+import type { ProseMirrorKeyMaps, ProseMirrorMenu } from "../../common/prosemirror/_module.d.mts";
+import type Document from "../../common/abstract/document.d.mts";
+
+declare global {
+  interface FormApplicationOptions extends ApplicationOptions {
+    /**
+     * Whether to automatically close the application when it's contained
+     * form is submitted.
+     * @defaultValue `true`
+     */
+    closeOnSubmit: boolean;
+
+    /**
+     * Whether to automatically submit the contained HTML form when an input
+     * or select element is changed.
+     * @defaultValue `false`
+     */
+    submitOnChange: boolean;
+
+    /**
+     * Whether to automatically submit the contained HTML form when the
+     * application window is manually closed.
+     * @defaultValue `false`
+     */
+    submitOnClose: boolean;
+
+    /**
+     * Whether the application form is editable - if true, it's fields will
+     * be unlocked and the form can be submitted. If false, all form fields
+     * will be disabled and the form cannot be submitted.
+     * @defaultValue `true`
+     */
+    editable: boolean;
+
+    /**
+     * Support configuration of the sheet type used for this application.
+     * @defaultValue `false`
+     */
+    sheetConfig: boolean;
+  }
+
+  /**
+   * An abstract pattern for defining an Application responsible for updating some object using an HTML form
+   *
+   * A few critical assumptions:
+   * 1) This application is used to only edit one object at a time
+   * 2) The template used contains one (and only one) HTML form as it's outer-most element
+   * 3) This abstract layer has no knowledge of what is being updated, so the implementation must define _updateObject
+   *
+   * @typeParam Options        - the type of the options object
+   * @typeParam ConcreteObject - the type of the object or {@link foundry.abstract.Document} which is modified by this form
+   */
+  abstract class FormApplication<
+    Options extends FormApplicationOptions = FormApplicationOptions,
+    ConcreteObject = unknown,
+  > extends Application<Options> {
+    /**
+     * @param object  - Some object or entity which is the target to be updated.
+     * @param options - Additional options which modify the rendering of the sheet.
+     *                  (default: `{}`)
+     * @remarks Foundry allows passing no value to the constructor at all.
+     */
+    constructor(object: ConcreteObject, options?: Partial<Options>);
+    constructor(
+      ...args: ConcreteObject extends undefined
+        ? [ConcreteObject?, Partial<Options>?]
+        : [ConcreteObject, Partial<Options>?]
+    );
+
+    /**
+     * The object target which we are using this form to modify
+     */
+    object: ConcreteObject;
+
+    /**
+     * A convenience reference to the form HTLMElement
+     * @defaultValue `null`
+     */
+    form: HTMLElement | null;
+
+    /**
+     * Keep track of any FilePicker instances which are associated with this form
+     * The values of this Array are inner-objects with references to the FilePicker instances and other metadata
+     * @defaultValue `[]`
+     */
+    filepickers: FilePicker[];
+
+    /**
+     * Keep track of any mce editors which may be active as part of this form
+     * The values of this Array are inner-objects with references to the MCE editor and other metadata
+     * @defaultValue `{}`
+     */
+    editors: Record<string, FormApplication.FormApplicationEditor>;
+
+    /**
+     * Assign the default options which are supported by the entity edit sheet.
+     * @returns The default options for this FormApplication class
+     * @see {@link Application.defaultOptions}
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["form"],
+     *   closeOnSubmit: true,
+     *   editable: true,
+     *   sheetConfig: false,
+     *   submitOnChange: false,
+     *   submitOnClose: false
+     * });
+     * ```
+     */
+    static override get defaultOptions(): FormApplicationOptions;
+
+    /**
+     * Is the Form Application currently editable?
+     */
+    get isEditable(): boolean;
+
+    /**
+     * @param options - (default: `{}`)
+     */
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<FormApplication.FormApplicationData<Options, ConcreteObject>>>;
+
+    protected override _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
+
+    protected override _renderInner(data: ReturnType<this["getData"]>): Promise<JQuery>;
+
+    protected override _activateCoreListeners(html: JQuery): void;
+
+    override activateListeners(html: JQuery): void;
+
+    /**
+     * If the form is not editable, disable its input fields
+     * @param form - The form HTML
+     */
+    protected _disableFields(form: HTMLElement): void;
+
+    /**
+     * Handle standard form submission steps
+     * @param event         - The submit event which triggered this handler
+     * @param updateData    - Additional specific data keys/values which override or extend the contents of
+     *                        the parsed form. This can be used to update other flags or data fields at the
+     *                        same time as processing a form submission to avoid multiple database operations.
+     *                        (default: `null`)
+     * @param preventClose  - Override the standard behavior of whether to close the form on submit
+     *                        (default: `false`)
+     * @param preventRender - Prevent the application from re-rendering as a result of form submission
+     *                        (default: `false`)
+     * @returns A promise which resolves to the validated update data
+     */
+    protected _onSubmit(
+      event: Event,
+      { updateData, preventClose, preventRender }?: FormApplication.OnSubmitOptions,
+    ): Promise<Partial<AnyObject>>;
+
+    /**
+     * Get an object of update data used to update the form's target object
+     * @param updateData - Additional data that should be merged with the form data
+     *                     (default: `{}`)
+     * @returns The prepared update data
+     */
+    // TODO: Maybe we can calculate how the flattened `updateData` looks like, then it would be Partial<Record<string, unknown>> & Flattened<T>
+    protected _getSubmitData(updateData?: AnyObject | null): AnyObject;
+
+    /**
+     * Handle changes to an input element, submitting the form if options.submitOnChange is true.
+     * Do not preventDefault in this handler as other interactions on the form may also be occurring.
+     * @param event - The initial change event
+     */
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void | object>;
+
+    /**
+     * Handle the change of a color picker input which enters it's chosen value into a related input field
+     * @param event - The color picker change event
+     */
+    protected _onChangeColorPicker(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle changes to a range type input by propagating those changes to the sibling range-value element
+     * @param event - The initial change event
+     */
+    protected _onChangeRange(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Additional handling which should trigger when a FilePicker contained within this FormApplication is submitted.
+     * @param selection  - The target path which was selected
+     * @param filePicker - The FilePicker instance which was submitted
+     */
+    protected _onSelectFile(selection: string, filePicker: FilePicker): void;
+
+    /**
+     * This method is called upon form submission after form data is validated
+     * @param event    - The initial triggering submission event
+     * @param formData - The object of validated form data with which to update the object
+     * @returns A Promise which resolves once the update operation has completed
+     */
+    protected abstract _updateObject(event: Event, formData?: object): Promise<unknown>;
+
+    /**
+     * Activate a named TinyMCE text editor
+     * @param name           - The named data field which the editor modifies.
+     * @param options        - Editor initialization options passed to {@link TextEditor.create}.
+     *                         (default: `{}`)
+     * @param initialContent - Initial text content for the editor area.
+     *                         (default: `""`)
+     */
+    activateEditor(
+      name: string,
+      options?: TextEditor.Options,
+      initialContent?: string,
+    ): Promise<tinyMCE.Editor | EditorView>;
+
+    /**
+     * Handle saving the content of a specific editor by name
+     * @param name   - The named editor to save
+     * @param remove - Remove the editor after saving its content
+     *                 (default: `true`)
+     */
+    saveEditor(name: string, { remove }?: { remove?: boolean }): Promise<void>;
+
+    /**
+     * Activate an editor instance present within the form
+     * @param div - The element which contains the editor
+     */
+    protected _activateEditor(div: HTMLElement): void;
+
+    /**
+     * Configure ProseMirror plugins for this sheet.
+     * @param name    - The name of the editor.
+     * @param options - Additional options to configure the plugins.
+     */
+    protected _configureProseMirrorPlugins(
+      name: string,
+      options: {
+        /** Whether the editor should destroy itself on save. */
+        remove: boolean;
+      },
+    ): {
+      menu: ReturnType<(typeof ProseMirrorMenu)["build"]>;
+      keyMaps: ReturnType<(typeof ProseMirrorKeyMaps)["build"]>;
+    };
+
+    /**
+     * Activate a FilePicker instance present within the form
+     * @param event - The mouse click event on a file picker activation button
+     */
+    protected _activateFilePicker(event: PointerEvent): void;
+
+    /**
+     * Determine the configuration options used to initialize a FilePicker instance within this FormApplication.
+     * Subclasses can extend this method to customize the behavior of pickers within their form.
+     * @param event - The initiating mouse click event which opens the picker
+     * @returns Options passed to the FilePicker constructor
+     */
+    protected _getFilePickerOptions(event: PointerEvent): FilePickerOptions;
+
+    /**
+     * @param options - (default: `{}`)
+     */
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    /**
+     * Submit the contents of a Form Application, processing its content as defined by the Application
+     * @param options - Options passed to the _onSubmit event handler
+     *                  (default: `{}`)
+     * @returns Return a self-reference for convenient method chaining
+     */
+    submit(options?: FormApplication.OnSubmitOptions): Promise<this> | void;
+  }
+
+  namespace FormApplication {
+    type Any = FormApplication<any, any>;
+
+    interface CloseOptions extends Application.CloseOptions {
+      submit?: boolean;
+    }
+
+    interface FormApplicationEditor {
+      target: string;
+      button: HTMLElement;
+      hasButton: boolean;
+      instance: Awaited<ReturnType<(typeof TextEditor)["create"]>> | null;
+      mce: Awaited<ReturnType<(typeof TextEditor)["create"]>> | null;
+      active: boolean;
+      changed: boolean;
+      options: TextEditor.Options;
+      initial: string;
+    }
+
+    interface OnSubmitOptions {
+      /**
+       * Additional specific data keys/values which override or extend the contents of
+       * the parsed form. This can be used to update other flags or data fields at the
+       * same time as processing a form submission to avoid multiple database operations.
+       * @defaultValue `null`
+       */
+      updateData?: AnyObject | null | undefined;
+
+      /**
+       * Override the standard behavior of whether to close the form on submit
+       * @defaultValue `false`
+       */
+      preventClose?: boolean | undefined;
+
+      /**
+       * Prevent the application from re-rendering as a result of form submission
+       * @defaultValue `false`
+       */
+      preventRender?: boolean | undefined;
+    }
+
+    interface FormApplicationData<
+      Options extends FormApplicationOptions = FormApplicationOptions,
+      ConcreteObject = unknown,
+    > {
+      object: ConcreteObject;
+      options: Options;
+      title: string;
+    }
+  }
+
+  interface DocumentSheetOptions<
+    ConcreteDocument extends Document.Internal.Instance.Any = Document.Internal.Instance.Any,
+  > extends FormApplicationOptions {
+    /**
+     * The default permissions required to view this Document sheet.
+     * @defaultValue {@link CONST.DOCUMENT_OWNERSHIP_LEVELS.LIMITED}
+     */
+    viewPermission: foundry.CONST.DOCUMENT_OWNERSHIP_LEVELS;
+
+    /** An array of {@link HTMLSecret} configuration objects. */
+    secrets: HTMLSecretConfiguration<ConcreteDocument>[];
+  }
+
+  /**
+   * Extend the FormApplication pattern to incorporate specific logic for viewing or editing Document instances.
+   * See the FormApplication documentation for more complete description of this interface.
+   *
+   * @typeParam Options          - the type of the options object
+   * @typeParam ConcreteDocument - the type of the Document which should be managed by this form sheet
+   */
+  abstract class DocumentSheet<
+    Options extends DocumentSheetOptions<ConcreteDocument>,
+    ConcreteDocument extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+  > extends FormApplication<Options, ConcreteDocument> {
+    /**
+     * @param object  - A Document instance which should be managed by this form.
+     *                  (default: `{}`)
+     * @param options - Optional configuration parameters for how the form behaves.
+     *                  (default: `{}`)
+     */
+    constructor(object?: ConcreteDocument, options?: Partial<Options>);
+
+    /** The list of handlers for secret block functionality. */
+    protected _secrets: HTMLSecret<ConcreteDocument>[];
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet"],
+     *   template: `templates/sheets/${this.name.toLowerCase()}.html`,
+     *   viewPermission: CONST.DOCUMENT_OWNERSHIP_LEVELS.LIMITED,
+     *   sheetConfig: true,
+     *   secrets: []
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheetOptions;
+
+    /**
+     * A semantic convenience reference to the Document instance which is the target object for this form.
+     */
+    get document(): ConcreteDocument;
+
+    override get id(): string;
+
+    override get isEditable(): boolean;
+
+    override get title(): string;
+
+    override close(options?: FormApplication.CloseOptions): Promise<void>;
+
+    override getData(
+      options?: Partial<Options>,
+    ): MaybePromise<GetDataReturnType<DocumentSheet.DocumentSheetData<Options, ConcreteDocument>>>;
+
+    protected override _activateCoreListeners(html: JQuery<HTMLElement>): void;
+
+    override activateEditor(
+      name: string,
+      options?: TextEditor.Options,
+      initialContent?: string,
+    ): Promise<Editor | EditorView>;
+
+    override render(force?: boolean, options?: Application.RenderOptions<Options>): this;
+
+    protected override _renderOuter(): Promise<JQuery<HTMLElement>>;
+
+    /**
+     * Create an ID link button in the document sheet header which displays the document ID and copies to clipboard
+     */
+    protected _createDocumentIdLink(html: JQuery<HTMLElement>): void;
+
+    /**
+     * Test whether a certain User has permission to view this Document Sheet.
+     * @param user - The user requesting to render the sheet
+     * @returns Does the User have permission to view this sheet?
+     */
+    protected _canUserView(user: User): boolean;
+
+    /**
+     * Create objects for managing the functionality of secret blocks within this Document's content.
+     */
+    protected _createSecretHandlers(): HTMLSecret[];
+
+    protected override _getHeaderButtons(): Application.HeaderButton[];
+
+    /**
+     * Get the HTML content that a given secret block is embedded in.
+     * @param secret - The secret block.
+     */
+    protected _getSecretContent(secret: HTMLElement): string;
+
+    /**
+     * Update the HTML content that a given secret block is embedded in.
+     * @param secret  - The secret block.
+     * @param content - The new content.
+     * @returns The updated Document.
+     */
+    protected _updateSecret(secret: HTMLElement, content: string): Promise<ConcreteDocument | void>;
+
+    /**
+     * Handle requests to configure the default sheet used by this Document
+     * @internal
+     */
+    protected _onConfigureSheet(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle changing a Document's image.
+     * @param event - The click event.
+     */
+    protected _onEditImage(event: MouseEvent): Promise<void>;
+
+    protected override _updateObject(event: Event, formData: object): Promise<unknown>;
+  }
+
+  namespace DocumentSheet {
+    type Any = DocumentSheet<any, any>;
+
+    interface DocumentSheetData<
+      Options extends DocumentSheetOptions<ConcreteDocument>,
+      ConcreteDocument extends foundry.abstract.Document.Any = foundry.abstract.Document.Any,
+    > extends FormApplication.FormApplicationData {
+      cssClass: string;
+      editable: boolean;
+      data: ReturnType<ConcreteDocument["toObject"]>;
+      limited: boolean;
+      options: DocumentSheet<Options, ConcreteDocument>["options"];
+      owner: boolean;
+      title: DocumentSheet<Options, ConcreteDocument>["title"];
+      document: DocumentSheet<Options, ConcreteDocument>["document"];
+    }
+  }
+}