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

package/src/foundry/client/ui/context.d.ts

@@ -1,136 +0,0 @@
-interface ContextMenuEntry {
-  /**
-   * The context menu label. Can be localized.
-   */
-  name: string;
-
-  /**
-   * A string containing an HTML icon element for the menu item
-   */
-  icon: string;
-
-  /**
-   * The function to call when the menu item is clicked. Receives the HTML element of the SidebarTab entry that this context menu is for.
-   */
-  callback: (target: JQuery) => void;
-
-  /**
-   * A function to call to determine if this item appears in the menu. Receives the HTML element of the SidebarTab entry that this context menu is for.
-   */
-  condition?: boolean | ((target: JQuery) => boolean);
-}
-
-/**
- * Display a right-click activated Context Menu which provides a dropdown menu of options
- * A ContextMenu is constructed by designating a parent HTML container and a target selector
- * An Array of menuItems defines the entries of the menu which is displayed
- */
-declare class ContextMenu {
-  /**
-   * @param element   - The containing HTML element within which the menu is positioned
-   * @param selector  - A CSS selector which activates the context menu.
-   * @param menuItems - An Array of entries to display in the menu
-   * @param eventName - Optionally override the triggering event which can spawn the menu
-   *                    (default: `'contextmenu'`)
-   */
-  constructor(
-    element: JQuery,
-    selector: string | null | undefined,
-    menuItems: ContextMenuEntry[],
-    { eventName }?: { eventName?: string }
-  );
-
-  /**
-   * The target HTMLElement being selected
-   */
-  element: JQuery;
-
-  /**
-   * The target CSS selector which activates the menu
-   * @defaultValue `element.attr("id")`
-   */
-  selector: string;
-
-  /**
-   * An interaction event name which activates the menu
-   */
-  eventName: string;
-
-  /**
-   * The array of menu items being rendered
-   */
-  menuItems: ContextMenuEntry[];
-
-  /**
-   * Track which direction the menu is expanded in
-   * @defaultValue `false`
-   */
-  protected _expandUp: boolean;
-
-  /**
-   * A convenience accessor to the context menu HTML object
-   */
-  get menu(): JQuery;
-
-  /**
-   * Create a ContextMenu for this Application and dispatch hooks.
-   * @param app       - The Application this ContextMenu belongs to.
-   * @param html      - The Application's rendered HTML.
-   * @param selector  - The target CSS selector which activates the menu.
-   * @param menuItems - The array of menu items being rendered.
-   * @param hookName  - The name of the hook to call.
-   *                    (default: `'EntryContext'`)
-   */
-  static create(
-    app: Application,
-    html: JQuery,
-    selector: string,
-    menuItems: ContextMenuEntry[],
-    hookName?: string
-  ): ContextMenu;
-
-  /**
-   * Attach a ContextMenu instance to an HTML selector
-   */
-  bind(): void;
-
-  /**
-   * Closes the menu and removes it from the DOM.
-   * @param options - Options to configure the closing behavior.
-   */
-  close(options?: ContextMenu.CloseOptions | undefined): Promise<void>;
-
-  /** @internal */
-  protected _close(): void;
-
-  /** @internal */
-  protected _animateOpen(menu: JQuery): Promise<void>;
-
-  /** @internal */
-  protected _animateClose(menu: JQuery): Promise<void>;
-
-  /**
-   * Render the Context Menu by iterating over the menuItems it contains
-   * Check the visibility of each menu item, and only render ones which are allowed by the item's logical condition
-   * Attach a click handler to each item which is rendered
-   * @param target - The target element to which the context menu is attached
-   */
-  render(target: JQuery): void | Promise<void>;
-
-  /**
-   * Set the position of the context menu, taking into consideration whether the menu should expand upward or downward
-   */
-  protected _setPosition(html: JQuery, target: JQuery): void;
-
-  static eventListeners(): void;
-}
-
-declare namespace ContextMenu {
-  interface CloseOptions {
-    /**
-     * Animate the context menu closing.
-     * @defaultValue `true`
-     */
-    animate?: boolean;
-  }
-}

package/src/foundry/client/ui/dialog.d.ts

@@ -1,286 +0,0 @@
-interface DialogOptions extends ApplicationOptions {
-  /**
-   * Whether to provide jQuery objects to callback functions (if true) or plain
-   * HTMLElement instances (if false). This is currently true by default but in the
-   * future will become false by default.
-   * @defaultValue `true`
-   */
-  jQuery: boolean;
-}
-
-/**
- * Create a modal dialog window displaying a title, a message, and a set of buttons which trigger callback functions.
- *
- * @example <caption>Constructing a custom dialog instance</caption>
- * ```typescript
- * let d = new Dialog({
- *  title: "Test Dialog",
- *  content: "<p>You must choose either Option 1, or Option 2</p>",
- *  buttons: {
- *   one: {
- *    icon: '<i class="fas fa-check"></i>',
- *    label: "Option One",
- *    callback: () => console.log("Chose One")
- *   },
- *   two: {
- *    icon: '<i class="fas fa-times"></i>',
- *    label: "Option Two",
- *    callback: () => console.log("Chose Two")
- *   }
- *  },
- *  default: "two",
- *  render: html => console.log("Register interactivity in the rendered dialog"),
- *  close: html => console.log("This always is logged no matter which option is chosen")
- * });
- * d.render(true);
- * ```
- * @typeParam Options - the type of the options object
- */
-declare class Dialog<Options extends DialogOptions = DialogOptions> extends Application<Options> {
-  /**
-   * @param data    - An object of dialog data which configures how the modal window is rendered
-   * @param options - Dialog rendering options, see {@link Application}
-   */
-  constructor(data: Dialog.Data, options?: Partial<Options>);
-
-  data: Dialog.Data;
-
-  /**
-   * @defaultValue
-   * ```typescript
-   * foundry.utils.mergeObject(super.defaultOptions, {
-   *   template: "templates/hud/dialog.html",
-   *   classes: ["dialog"],
-   *   width: 400,
-   *   jQuery: true
-   * })
-   * ```
-   */
-  static override get defaultOptions(): DialogOptions;
-
-  static get title(): string;
-
-  override getData(options?: Partial<Options>): { content: string; buttons: Record<string, Dialog.Button> };
-
-  override activateListeners(html: JQuery): void;
-
-  /**
-   * Handle a left-mouse click on one of the dialog choice buttons
-   * @param event - The left-mouse click event
-   */
-  protected _onClickButton(event: MouseEvent): void;
-
-  /**
-   * Handle a keydown event while the dialog is active
-   * @param event - The keydown event
-   */
-  protected _onKeyDown(event: KeyboardEvent & { key: 'Escape' }): Promise<void>;
-  protected _onKeyDown(event: KeyboardEvent): void;
-
-  /**
-   * Submit the Dialog by selecting one of its buttons
-   * @param button - The configuration of the chosen button
-   */
-  protected submit(button: Dialog.Button): void;
-
-  override close(options?: Application.CloseOptions): Promise<void>;
-
-  /**
-   * A helper factory method to create simple confirmation dialog windows which consist of simple yes/no prompts.
-   * If you require more flexibility, a custom Dialog instance is preferred.
-   *
-   * @param config - Confirmation dialog configuration
-   *                 (defaultValue: `{}`)
-   * @returns A promise which resolves once the user makes a choice or closes the window
-   *
-   * @example
-   * ```typescript
-   * let d = Dialog.confirm({
-   *  title: "A Yes or No Question",
-   *  content: "<p>Choose wisely.</p>",
-   *  yes: () => console.log("You chose ... wisely"),
-   *  no: () => console.log("You chose ... poorly"),
-   *  defaultYes: false
-   * });
-   * ```
-   */
-  static confirm<Yes = true, No = false>(
-    config: ConfirmConfig<Yes, No, JQuery> & { options?: { jQuery?: true }; rejectClose: true }
-  ): Promise<Yes | No>;
-  static confirm<Yes = true, No = false>(
-    config: ConfirmConfig<Yes, No, JQuery> & { options?: { jQuery?: true } }
-  ): Promise<Yes | No | null>;
-  static confirm<Yes = true, No = false>(
-    config: ConfirmConfig<Yes, No, HTMLElement> & { options: { jQuery: false }; rejectClose: true }
-  ): Promise<Yes | No>;
-  static confirm<Yes = true, No = false>(
-    config: ConfirmConfig<Yes, No, HTMLElement> & { options: { jQuery: false } }
-  ): Promise<Yes | No | null>;
-  static confirm<Yes = true, No = false>(
-    config: ConfirmConfig<Yes, No, JQuery | HTMLElement> & { rejectClose: true }
-  ): Promise<Yes | No>;
-  static confirm<Yes = true, No = false>(
-    config?: ConfirmConfig<Yes, No, JQuery | HTMLElement>
-  ): Promise<Yes | No | null>;
-
-  /**
-   * A helper factory method to display a basic "prompt" style Dialog with a single button
-   * @param config - Dialog configuration options
-   * @returns A promise which resolves when clicked, or rejects if closed
-   */
-  static prompt<T>(
-    config: PromptConfig<T, JQuery> & { options?: { jQuery?: true }; rejectClose: false }
-  ): Promise<T | null>;
-  static prompt<T>(config: PromptConfig<T, JQuery> & { options?: { jQuery?: true } }): Promise<T>;
-  static prompt<T>(
-    config: PromptConfig<T, HTMLElement> & { options: { jQuery: false }; rejectClose: false }
-  ): Promise<T | null>;
-  static prompt<T>(config: PromptConfig<T, HTMLElement> & { options: { jQuery: false } }): Promise<T>;
-  static prompt<T>(config: PromptConfig<T, JQuery | HTMLElement> & { rejectClose: false }): Promise<T | null>;
-  static prompt<T>(config: PromptConfig<T, JQuery | HTMLElement>): Promise<T>;
-}
-
-declare namespace Dialog {
-  interface Button<T = unknown> {
-    /**
-     * A Font Awesome icon for the button
-     */
-    icon?: string;
-
-    /**
-     * The label for the button
-     */
-    label?: string;
-
-    /**
-     * A callback function that fires when the button is clicked
-     */
-    callback?: (html: JQuery | HTMLElement) => T;
-  }
-
-  interface Data {
-    /**
-     * The window title
-     */
-    title: string;
-
-    /**
-     * HTML content
-     */
-    content: string;
-
-    /**
-     * A callback function invoked when the dialog is rendered
-     */
-    render?: (element: JQuery | HTMLElement) => void;
-
-    /**
-     * Common callback operations to perform when the dialog is closed
-     */
-    close?: (element: JQuery | HTMLElement) => void;
-
-    /**
-     * The buttons which are displayed as action choices for the dialog
-     */
-    buttons: Record<string, Button>;
-
-    /**
-     * The name of the default button which should be triggered on Enter
-     */
-    default?: string | undefined;
-  }
-}
-
-/**
- * @typeParam Yes          - The value returned by the yes callback
- * @typeParam No           - The value returned by the no callback
- * @typeParam JQueryOrHtml - The parameter passed to the callbacks, either JQuery or HTMLElement
- */
-interface ConfirmConfig<Yes, No, JQueryOrHtml> {
-  /**
-   * The confirmation window title
-   */
-  title?: string;
-
-  /**
-   * The confirmation message
-   */
-  content?: string;
-
-  /**
-   * Callback function upon yes
-   */
-  yes?: (html: JQueryOrHtml) => Yes;
-
-  /**
-   * Callback function upon no
-   */
-  no?: (html: JQueryOrHtml) => No;
-
-  /**
-   * A function to call when the dialog is rendered
-   */
-  render?: (html: JQueryOrHtml) => void;
-
-  /**
-   * Make "yes" the default choice?
-   * @defaultValue `true`
-   */
-  defaultYes?: boolean;
-
-  /**
-   * Reject the Promise if the Dialog is closed without making a choice.
-   * @defaultValue `false`
-   */
-  rejectClose?: boolean;
-
-  /**
-   * Additional rendering options passed to the Dialog
-   * @defaultValue `{}`
-   */
-  options?: Partial<DialogOptions>;
-}
-
-/**
- * @typeParam Value        - The value returned by the callback function
- * @typeParam JQueryOrHtml - The parameter passed to the callbacks, either JQuery or HTMLElement
- */
-interface PromptConfig<Value, JQueryOrHtml> {
-  /**
-   * The confirmation window title
-   */
-  title?: string;
-
-  /**
-   * The confirmation message
-   */
-  content?: string;
-
-  /**
-   * The confirmation button text
-   */
-  label?: string;
-
-  /**
-   * A callback function to fire when the button is clicked
-   */
-  callback: (html: JQueryOrHtml) => Value;
-
-  /**
-   * A function that fires after the dialog is rendered
-   */
-  render?: (html: JQueryOrHtml) => void;
-
-  /**
-   * Reject the promise if the dialog is closed without confirming the
-   * choice, otherwise resolve as null
-   * @defaultValue `true`
-   */
-  rejectClose?: boolean;
-
-  /**
-   * Additional rendering options
-   * @defaultValue `{}`
-   */
-  options?: Partial<DialogOptions>;
-}

package/src/foundry/client/ui/drag.d.ts

@@ -1,105 +0,0 @@
-/**
- * A UI utility to make an element draggable.
- */
-declare class Draggable<R extends boolean | undefined = undefined> {
-  constructor(app: Draggable['app'], element: JQuery, handle: Draggable['handle'], resizable?: R);
-
-  app: Application;
-
-  element: HTMLElement;
-
-  handle: HTMLElement;
-
-  /**
-   * @defaultValue `false`
-   */
-  resizable: R extends boolean ? R : false;
-
-  /**
-   * Duplicate the application's starting position to track differences
-   * @defaultValue `null`
-   */
-  position: foundry.utils.Duplicated<Application.Position> | null;
-
-  /**
-   * Remember event handlers associated with this Draggable class so they may be later unregistered
-   */
-  // prettier-ignore
-  handlers: this['resizable'] extends true
-    ? Draggable.ResizableHandlers
-    : this['resizable'] extends false
-      ? Draggable.Handlers
-      : Draggable.Handlers | Draggable.ResizableHandlers;
-
-  /**
-   * Throttle mousemove event handling to 60fps
-   * @defaultValue `0`
-   */
-  protected _moveTime: number;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Activate event handling for a Draggable application
-   * Attach handlers for floating, dragging, and resizing
-   */
-  activateListeners(): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Handle the initial mouse click which activates dragging behavior for the application
-   */
-  protected _onDragMouseDown(event: Event): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Move the window with the mouse, bounding the movement to ensure the window stays within bounds of the viewport
-   */
-  protected _onDragMouseMove(event: Event): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Conclude the dragging behavior when the mouse is release, setting the final position and removing listeners
-   */
-  protected _onDragMouseUp(event: Event): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Handle the initial mouse click which activates dragging behavior for the application
-   */
-  protected _onResizeMouseDown(event: Event): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Move the window with the mouse, bounding the movement to ensure the window stays within bounds of the viewport
-   */
-  protected _onResizeMouseMove(event: Event): void;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Conclude the dragging behavior when the mouse is release, setting the final position and removing listeners
-   */
-  protected _onResizeMouseUp(event: Event): void;
-}
-
-declare namespace Draggable {
-  interface Handlers {
-    click: ['click', (e: Event) => void, { capture: boolean; passive: boolean }];
-
-    dragDown: ['mousedown', (e: Event) => void, false];
-    dragMove: ['mousemove', (e: Event) => void, false];
-    dragUp: ['mouseup', (e: Event) => void, false];
-  }
-
-  interface ResizableHandlers extends Handlers {
-    resizeDown: ['mousedown', (e: Event) => void, false];
-    resizeMove: ['mousemove', (e: Event) => void, false];
-    resizeUp: ['mouseup', (e: Event) => void, false];
-  }
-}

package/src/foundry/client/ui/dragdrop.d.ts

@@ -1,118 +0,0 @@
-interface DragDropConfiguration {
-  /**
-   * The CSS selector used to target draggable elements.
-   */
-  dragSelector?: DragDrop['dragSelector'];
-
-  /**
-   * The CSS selector used to target viable drop targets.
-   */
-  dropSelector?: DragDrop['dropSelector'];
-
-  /**
-   * An object of permission test functions for each action
-   * @defaultValue `{}`
-   */
-  permissions?: DragDrop['permissions'];
-
-  /**
-   * An object of callback functions for each action
-   * @defaultValue `{}`
-   */
-  callbacks?: DragDrop['callbacks'];
-}
-
-/**
- * A controller class for managing drag and drop workflows within an Application instance.
- * The controller manages the following actions: dragstart, dragover, drop
- * @see {@link Application}
- *
- * @example
- * ```typescript
- * const dragDrop = new DragDrop({
- *   dragSelector: ".item",
- *   dropSelector: ".items",
- *   permissions: { dragstart: this._canDragStart.bind(this), drop: this._canDragDrop.bind(this) },
- *   callbacks: { dragstart: this._onDragStart.bind(this), drop: this._onDragDrop.bind(this) }
- * });
- * dragDrop.bind(html);
- * ```
- */
-declare class DragDrop {
-  /**
-   * @param options - (default: `{}`)
-   */
-  constructor({ dragSelector, dropSelector, permissions, callbacks }?: DragDropConfiguration);
-
-  /**
-   * The HTML selector which identifies draggable elements
-   * @defaultValue `undefined`
-   */
-  dragSelector: string | null | undefined;
-
-  /**
-   * The HTML selector which identifies drop targets
-   * @defaultValue `undefined`
-   */
-  dropSelector: string | null | undefined;
-
-  /**
-   * A set of permission checking functions for each action of the Drag and Drop workflow
-   * @defaultValue `{}`
-   */
-  permissions: Partial<Record<DragDrop.Action, (selector: string | undefined) => boolean>>;
-
-  /**
-   * A set of callback functions for each action of the Drag and Drop workflow
-   * @defaultValue `{}`
-   */
-  callbacks: Partial<Record<DragDrop.Action, (event: DragEvent) => void>>;
-
-  /**
-   * Bind the DragDrop controller to an HTML application
-   * @param html - The HTML element to which the handler is bound
-   */
-  bind(html: HTMLElement): this;
-
-  /**
-   * Execute a callback function associated with a certain action in the workflow
-   * @param event  - The drag event being handled
-   * @param action - The action being attempted
-   */
-  callback(event: DragEvent, action: DragDrop.Action): void;
-
-  /**
-   * Execute a callback function associated with a certain action in the workflow
-   * @param action   - The action being attempted
-   * @param selector - The selector being targeted
-   * @returns Can the action be performed?
-   */
-  can(action: DragDrop.Action, selector: string | undefined): boolean;
-
-  /**
-   * Handle the start of a drag workflow
-   * @param event - The drag event being handled
-   * @internal
-   */
-  protected _handleDragStart(event: DragEvent): void;
-
-  /**
-   * Handle a dragged element over a droppable target
-   * @param event - The drag event being handled
-   * @internal
-   */
-  protected _handleDragOver(event: DragEvent): false;
-
-  /**
-   * Handle a dragged element dropped on a droppable target
-   * @param event - The drag event being handled
-   * @internal
-   */
-  protected _handleDrop(event: DragEvent): unknown;
-
-  static createDragImage(img: HTMLImageElement, width: number, height: number): HTMLDivElement;
-}
-
-declare namespace DragDrop {
-  type Action = 'dragstart' | 'dragover' | 'drop';
-}