@league-of-foundry-developers/foundry-vtt-types 9.255.2 → 9.255.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "9.255.2",
+  "version": "9.255.3",
   "description": "TypeScript type definitions for Foundry VTT",
   "exports": {
     ".": {

package/src/foundry/common/types.mjs.d.ts

@@ -55,7 +55,7 @@ interface SettingConfig<T = unknown> {
     : ConstructorOf<T>;
 
   /** For string Types, defines the allowable values */
-  choices?: (T extends string ? Record<string, string> : never) | undefined;
+  choices?: (T extends number | string ? Record<T, string> : never) | undefined;
 
   /** For numeric Types, defines the allowable range */
   range?:
@@ -95,10 +95,7 @@ interface SettingSubmenuConfig {
   icon?: string | undefined;
 
   /** The FormApplication to render */
-  // TODO: Find a better way to type this. Ideally, we would find a way to conditionally make the first parameter of FormApplication optional...
-  type:
-    | (new () => FormApplication<any, any, any>)
-    | ConstructorOf<FormApplication<FormApplicationOptions, object, undefined>>;
+  type: new () => FormApplication<any, any, any>;
 
   /** If true, only a GM can edit this Setting */
   restricted?: boolean | undefined;

package/src/foundry/foundry.js/applications/basePlaceableHUDs/tokenHUD.d.ts

@@ -98,7 +98,7 @@ declare global {
      * Handle attribute bar update
      * @internal
      */
-    protected _onAttributeUpdate(event: JQuery.ChangeEvent): void;
+    protected _onAttributeUpdate(event: JQuery.FocusOutEvent): void;
 
     /**
      * Toggle Token combat state
@@ -126,12 +126,16 @@ declare global {
 
     /**
      * Handle toggling a token status effect icon
-     * @param overlay - (default: `false`)
      * @internal
      */
     protected _onToggleEffect(
       event: JQuery.ClickEvent | JQuery.ContextMenuEvent,
-      { overlay }?: { overlay?: boolean }
+      {
+        overlay
+      }?: {
+        /** @defaultValue `@false` */
+        overlay?: boolean;
+      }
     ): Promise<boolean>;
 
     /**

package/src/foundry/foundry.js/applications/cameraViews.d.ts

@@ -14,7 +14,7 @@ declare class CameraViews<
    * return foundry.utils.mergeObject(super.defaultOptions, {
    *   id: "camera-views",
    *   template: "templates/hud/camera-views.html",
-   *   popOut: false,
+   *   popOut: false
    * })
    * ```
    */
@@ -27,14 +27,14 @@ declare class CameraViews<
 
   /**
    * Obtain a reference to the div.camera-view which is used to portray a given Foundry User.
-   * @param userId - The ID of the User entity
+   * @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 entity
+   * @param userId - The ID of the User document
    */
   getUserVideoElement(userId: string): HTMLVideoElement | null;
 

package/src/foundry/foundry.js/applications/formApplication.d.ts

@@ -59,6 +59,11 @@ declare abstract class FormApplication<
    * @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

package/src/foundry/foundry.js/applications/hotbar.d.ts

@@ -94,11 +94,15 @@ declare global {
     /** @override */
     activateListeners(html: JQuery): void;
 
+    /** @override */
+    protected _contextMenu(html: JQuery): void;
+
     /**
-     * Create a Context Menu attached to each Macro button
-     * @param html - The HTML being rendered for the hotbar
+     * Get the Macro entry context options
+     * @returns The Macro entry context options
+     * @internal
      */
-    protected _contextMenu(html: JQuery): void;
+    protected _getEntryContextOptions(): ContextMenuEntry[];
 
     /**
      * Handle left-click events to

package/src/foundry/foundry.js/pixi/containers/index.d.ts

@@ -9,6 +9,7 @@ import './cursor';
 import './doorControl';
 import './effectsCanvasGroup';
 import './interfaceCanvasGroup';
+import './objectHUD';
 import './placeableObject';
 import './placeableObjects';
 import './ruler';

package/src/foundry/foundry.js/pixi/containers/objectHUD.d.ts

@@ -0,0 +1,82 @@
+/**
+ * An extension of PIXI.Container used as the interface frame for a PlaceableObject on the ControlsLayer
+ *
+ * @see {@link PlaceableObject}
+ * @see {@link ControlsLayer}
+ */
+declare class ObjectHUD extends PIXI.Container {
+  constructor(object: PIXI.DisplayObject);
+
+  /**
+   * The object that this HUD container is linked to
+   */
+  object: PIXI.DisplayObject;
+
+  /**
+   * Use the linked object's transform matrix to easily synchronize position
+   */
+  transform: PIXI.Transform;
+
+  /** @override */
+  // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
+  get visible(): boolean;
+  set visible(value: boolean);
+
+  /** @override */
+  // @ts-expect-error this is a property in `PIXI.Container` but foundry overrides it as an accessor.
+  get renderable(): boolean;
+  set renderable(value: boolean);
+
+  /**
+   * Display scrolling status text originating from this ObjectHUD container.
+   * @param content - The text content to display
+   * @param options - (default: `{}`)
+   * @returns The created PreciseText object which is scrolling
+   */
+  createScrollingText(
+    content: string,
+    options?: ObjectHUD.CreateScrollingTextOptions | undefined
+  ): Promise<PreciseText | null>;
+
+  /**
+   * Orchestrate the animation of the scrolling text in this HUD
+   * @param text     - The PrecisText instance to animate
+   * @param duration - A desired duration of animation
+   * @param dx       - A horizontal distance to animate the text
+   *                   (default: `0`)
+   * @param dy       - A vertical distance to animate the text
+   *                   (default: `0`)
+   * @internal
+   */
+  protected _animateScrollText(text: PreciseText, duration: number, dx?: number, dy?: number): Promise<void>;
+}
+
+type TextStyleProperties = Exclude<ConstructorParameters<typeof PIXI.TextStyle>[0], undefined>;
+
+declare namespace ObjectHUD {
+  interface CreateScrollingTextOptions extends TextStyleProperties {
+    /**
+     * The original anchor point where the text first appears
+     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.CENTER`
+     */
+    anchor?: foundry.CONST.TEXT_ANCHOR_POINTS | undefined;
+
+    /**
+     * The direction in which the text scrolls
+     * @defaultValue `CONST.TEXT_ANCHOR_POINTS.TOP`
+     */
+    direction?: foundry.CONST.TEXT_ANCHOR_POINTS | undefined;
+
+    /**
+     * The duration of the scrolling effect in milliseconds
+     * @defaultValue `2000`
+     */
+    duration?: number | undefined;
+
+    /**
+     * An amount of randomization between 0 and 1 to apply to the initial Position
+     * @defaultValue `0`
+     */
+    jitter?: number | undefined;
+  }
+}

package/src/foundry/foundry.js/pixi/containers/placeableObjects/measuredTemplate.d.ts

@@ -3,30 +3,40 @@ import { DocumentModificationOptions } from '../../../../common/abstract/documen
 
 declare global {
   /**
-   * A MeasuredTemplate is an implementation of PlaceableObject which represents an area of the canvas grid which is
-   * covered by some effect.
+   * A type of Placeable Object which highlights an area of the grid as covered by some area of effect.
+   * @see {@link MeasuredTemplateDocument}
+   * @see {@link TemplateLayer}
    */
   class MeasuredTemplate extends PlaceableObject<
     InstanceType<ConfiguredDocumentClass<typeof MeasuredTemplateDocument>>
   > {
-    constructor(document: InstanceType<ConfiguredDocumentClass<typeof MeasuredTemplateDocument>>);
-
-    controlIcon: ControlIcon | null;
-    template: PIXI.Graphics | null;
-    ruler: PreciseText | null;
+    /**
+     * The geometry shape used for testing point intersection
+     * @defaultValue `undefined`
+     */
+    shape: PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.Rectangle | PIXI.RoundedRectangle | undefined;
 
     /**
      * The tiling texture used for this template, if any
      */
-    texture: PIXI.Texture | null;
+    texture: PIXI.Texture | undefined;
 
     /**
-     * The template shape used for testing point intersection
+     * The template graphics
+     * @defaultValue `undefined`
      */
-    shape: PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.Rectangle | PIXI.RoundedRectangle;
+    template: PIXI.Graphics | undefined;
+
+    /**
+     * The UI frame container which depicts Token metadata and status, displayed in the ControlsLayer.
+     * @defaultValue `new ObjectHUD(this)`
+     */
+    hud: MeasuredTemplate.ObjectHUD;
 
     /**
      * Internal property used to configure the control border thickness
+     * @defaultValue `3`
+     * @internal
      */
     protected _borderThickness: number;
 
@@ -54,13 +64,24 @@ declare global {
     /** @override */
     draw(): Promise<this>;
 
+    /** @override */
+    destroy(options?: Parameters<PlaceableObject['destroy']>[0]): void;
+
+    /**
+     * Draw the HUD container which provides an interface for managing this template
+     * @internal
+     */
+    protected _drawHUD(): MeasuredTemplate.InitializedObjectHUD;
+
     /**
      * Draw the ControlIcon for the MeasuredTemplate
+     * @internal
      */
     protected _drawControlIcon(): ControlIcon;
 
     /**
      * Draw the Text label used for the MeasuredTemplate
+     * @internal
      */
     protected _drawRulerText(): PreciseText;
 
@@ -69,31 +90,31 @@ declare global {
 
     /**
      * Get a Circular area of effect given a radius of effect
+     * @internal
      */
     protected _getCircleShape(distance: number): PIXI.Circle;
 
     /**
      * Get a Conical area of effect given a direction, angle, and distance
+     * @internal
      */
     protected _getConeShape(direction: number, angle: number, distance: number): PIXI.Polygon;
 
     /**
      * Get a Rectangular area of effect given a width and height
+     * @internal
      */
     protected _getRectShape(direction: number, distance: number): NormalizedRectangle;
 
     /**
      * Get a rotated Rectangular area of effect given a width, height, and direction
+     * @internal
      */
     protected _getRayShape(direction: number, distance: number, width: number): PIXI.Polygon;
 
-    /**
-     * Draw the rotation control handle and assign event listeners
-     */
-    protected _drawRotationHandle(radius: number): void;
-
     /**
      * Update the displayed ruler tooltip text
+     * @internal
      */
     protected _refreshRulerText(): void;
 
@@ -124,4 +145,20 @@ declare global {
     /** @override */
     protected _onDelete(options: DocumentModificationOptions, userId: string): void;
   }
+
+  namespace MeasuredTemplate {
+    interface ObjectHUD extends globalThis.ObjectHUD {
+      /**
+       * Template control icon
+       */
+      icon?: ControlIcon;
+
+      /**
+       * Ruler text tooltip
+       */
+      ruler?: PreciseText;
+    }
+
+    type InitializedObjectHUD = RequiredProps<ObjectHUD, 'icon' | 'ruler'>;
+  }
 }