@league-of-foundry-developers/foundry-vtt-types 9.255.1 → 9.268.0

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

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import { ConfiguredDocumentClass, ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
 
 declare global {
@@ -40,18 +40,25 @@ declare global {
     /**
      * Internal timestamp for the previous freehand draw time, to limit sampling
      * @defaultValue `0`
+     * @internal
      */
     protected _drawTime: number;
+
+    /**
+     * @defaultValue `0`
+     * @internal
+     */
     protected _sampleTime: number;
 
     /**
      * Internal flag for the permanent points of the polygon
      * @defaultValue `foundry.utils.deepClone(this.data.points || [])`
+     * @internal
      */
     protected _fixedPoints: Array<[x: number, y: number]>;
 
     /** @override */
-    static get embeddedName(): 'Drawing';
+    static embeddedName: 'Drawing';
 
     /**
      * The rate at which points are sampled (in milliseconds) during a freehand drawing workflow
@@ -77,6 +84,7 @@ declare global {
 
     /**
      * Clean the drawing data to constrain its allowed position
+     * @internal
      */
     protected _cleanData(): void;
 
@@ -87,11 +95,13 @@ declare global {
 
     /**
      * Create elements for the foreground text
+     * @internal
      */
     protected _createText(): PreciseText;
 
     /**
      * Create elements for the Drawing border and handles
+     * @internal
      */
     protected _createFrame(): void;
 
@@ -100,21 +110,25 @@ declare global {
 
     /**
      * Draw rectangular shapes
+     * @internal
      */
     protected _drawRectangle(): void;
 
     /**
      * Draw ellipsoid shapes
+     * @internal
      */
     protected _drawEllipse(): void;
 
     /**
      * Draw polygonal shapes
+     * @internal
      */
     protected _drawPolygon(): void;
 
     /**
      * Draw freehand shapes with bezier spline smoothing
+     * @internal
      */
     protected _drawFreehand(): void;
 
@@ -125,6 +139,7 @@ declare global {
      * @param previous - The prior point
      * @param point    - The current point
      * @param next     - The next point
+     * @internal
      */
     protected _getBezierControlPoints(
       factor: number,
@@ -144,17 +159,20 @@ declare global {
 
     /**
      * Refresh the boundary frame which outlines the Drawing shape
+     * @internal
      */
     protected _refreshFrame({ x, y, width, height }: Rectangle): void;
 
     /**
      * Add a new polygon point to the drawing, ensuring it differs from the last one
      * @param temporary - (default: `true`)
+     * @internal
      */
     protected _addPoint(position: Point, temporary?: boolean): void;
 
     /**
      * Remove the last fixed point from the polygon
+     * @internal
      */
     protected _removePoint(): void;
 
@@ -169,13 +187,9 @@ declare global {
 
     /**
      * Handle text entry in an active text tool
+     * @internal
      */
-    protected _onDrawingTextKeydown(
-      event: KeyboardEvent
-    ):
-      | ReturnType<InstanceType<ConfiguredDocumentClass<typeof DrawingDocument>>['update']>
-      | ReturnType<InstanceType<ConfiguredDocumentClass<typeof DrawingDocument>>['delete']>
-      | void;
+    protected _onDrawingTextKeydown(event: KeyboardEvent): void;
 
     /** @override */
     protected _onUpdate(data: DeepPartial<foundry.data.DrawingData['_source']>): void;
@@ -184,20 +198,21 @@ declare global {
      * @override
      * @param event - unused
      */
-    protected _canControl(user: User, event?: any): boolean;
+    protected _canControl(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /**
      * @override
      * @param user  - unused
      * @param event - unused
      */
-    protected _canConfigure(user: User, event?: any): boolean;
+    protected _canConfigure(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /** @override */
     activateListeners(): void;
 
     /**
      * Handle mouse movement which modifies the dimensions of the drawn shape
+     * @internal
      */
     protected _onMouseDraw(event: PIXI.InteractionEvent): void;
 
@@ -216,35 +231,41 @@ declare global {
     /**
      * Handle mouse-over event on a control handle
      * @param event - The mouseover event
+     * @internal
      */
     protected _onHandleHoverIn(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle mouse-out event on a control handle
      * @param event - The mouseout event
+     * @internal
      */
     protected _onHandleHoverOut(event: PIXI.InteractionEvent): void;
 
     /**
      * When we start a drag event - create a preview copy of the Tile for re-positioning
      * @param event - The mousedown event
+     * @internal
      */
     protected _onHandleMouseDown(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle the beginning of a drag event on a resize handle
+     * @internal
      */
     protected _onHandleDragStart(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle mousemove while dragging a tile scale handler
      * @param event - The mousemove event
+     * @internal
      */
     protected _onHandleDragMove(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle mouseup after dragging a tile scale handler
      * @param event - The mouseup event
+     * @internal
      */
     protected _onHandleDragDrop(
       event: PIXI.InteractionEvent
@@ -252,6 +273,7 @@ declare global {
 
     /**
      * Handle cancellation of a drag event for one of the resizing handles
+     * @internal
      */
     protected _onHandleDragCancel(event: PIXI.InteractionEvent): void;
 
@@ -260,6 +282,7 @@ declare global {
      * @param original - The original drawing data
      * @param dx       - The pixel distance dragged in the horizontal direction
      * @param dy       - The pixel distance dragged in the vertical direction
+     * @internal
      */
     protected _rescaleDimensions(
       original: Pick<foundry.data.DrawingData['_source'], 'x' | 'y' | 'points' | 'width' | 'height'>,
@@ -272,19 +295,10 @@ declare global {
      * @param data - The Drawing data pending update
      * @returns The adjusted data
      * @remarks This is intentionally public because it is called by the DrawingsLayer
+     * @internal
      */
     static normalizeShape(
       data: Pick<foundry.data.DrawingData['_source'], 'x' | 'y' | 'width' | 'height' | 'points'>
     ): Pick<foundry.data.DrawingData['_source'], 'x' | 'y' | 'width' | 'height' | 'points'>;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    get author(): InstanceType<ConfiguredDocumentClass<typeof User>>;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    get owner(): boolean;
   }
 }

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'>;
+  }
 }

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

@@ -4,11 +4,11 @@ import { HoverInOptions } from '../placeableObject';
 declare global {
   /**
    * A Note is an implementation of PlaceableObject which represents an annotated location within the Scene.
-   * Each Note links to a JournalEntry entity and represents it's location on the map.
+   * Each Note links to a JournalEntry document and represents its location on the map.
    */
   class Note extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof NoteDocument>>> {
     /** @override */
-    static get embeddedName(): 'Note';
+    static embeddedName: 'Note';
 
     /** @override */
     get bounds(): Rectangle;
@@ -28,6 +28,13 @@ declare global {
      */
     get size(): number;
 
+    /**
+     * Determine whether the Note is visible to the current user based on their perspective of the Scene.
+     * Visibility depends on permission to the underlying journal entry, as well as the perspective of controlled Tokens.
+     * If Token Vision is required, the user must have a token with vision over the note to see it.
+     */
+    get isVisible(): boolean;
+
     /** @override */
     draw(): Promise<this>;
 

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

@@ -36,6 +36,12 @@ declare global {
      */
     tile: PIXI.Sprite | undefined;
 
+    /**
+     * The occlusion image sprite
+     * @defaultValue `undefined`
+     */
+    occlusionTile: PIXI.Sprite | undefined;
+
     /**
      * A Tile background which is displayed if no valid image texture is present
      * @defaultValue `undefined`
@@ -64,6 +70,12 @@ declare global {
      */
     occluded: boolean;
 
+    /**
+     * A flag which tracks if the Tile is currently playing
+     * @defaultValue `false`
+     */
+    playing: boolean;
+
     /** @override */
     static embeddedName: 'Tile';
 
@@ -90,11 +102,21 @@ declare global {
      */
     get isRoof(): boolean;
 
+    /**
+     * The effective volume at which this Tile should be playing, including the global ambient volume modifier
+     */
+    get volume(): number;
+
     /** @override */
     draw(): Promise<this>;
 
     /** @override */
-    refresh(): this;
+    destroy(options?: Parameters<PlaceableObject['destroy']>[0]): void;
+
+    /**
+     * @param options - (default: `{}`)
+     * @override */
+    refresh(options?: Tile.RefreshOptions | undefined): this;
 
     /**
      * Refresh the display of the Tile border
@@ -114,7 +136,14 @@ declare global {
      * @param options - Additional options for modifying video playback
      *                  (default: `{}`)
      */
-    play(playing: boolean, options?: Partial<Tile.PlayOptions>): void;
+    play(playing: boolean, options?: Tile.PlayOptions | undefined): void;
+
+    /**
+     * Unlink the playback of this video tile from the playback of other tokens which are using the same base texture.
+     * @param source - The video element source
+     * @internal
+     */
+    protected _unlinkVideoPlayback(source: HTMLVideoElement): Promise<void>;
 
     /**
      * Update the occlusion rendering for this overhead Tile for a given controlled Token.
@@ -131,7 +160,7 @@ declare global {
      */
     testOcclusion(
       token: InstanceType<ConfiguredObjectClassForName<'Token'>>,
-      options?: Partial<Tile.OcclusionOptions>
+      options?: Tile.OcclusionOptions | undefined
     ): boolean;
 
     /**
@@ -157,7 +186,7 @@ declare global {
      * @param options - Options which customize the return value
      * @internal
      */
-    protected _createAlphaMap(options: Partial<Tile.AlphaMapOptions>): Exclude<Tile['_alphaMap'], undefined>;
+    protected _createAlphaMap(options: Tile.AlphaMapOptions): Exclude<Tile['_alphaMap'], undefined>;
 
     /**
      * Compute the alpha-based bounding box for the tile, including an angle of rotation.
@@ -242,7 +271,7 @@ declare global {
      * Get resized Tile dimensions
      * @internal
      */
-    protected _getResizedDimensions(event: MouseEvent, origin: Point, destination: Point): NormalizedRectangle;
+    protected _getResizedDimensions(event: MouseEvent, origin: Point, destination: Point): Rectangle;
 
     /**
      * Handle cancellation of a drag event for one of the resizing handles
@@ -251,18 +280,27 @@ declare global {
 
     /**
      * Create a preview tile with a background texture instead of an image
+     * @param data - Initial data with which to create the preview Tile
      */
-    static createPreview(data: TileDataConstructorData): Tile;
+    static createPreview(data: TileDataConstructorData): InstanceType<ConfiguredObjectClassForName<'Tile'>>;
   }
 
   namespace Tile {
+    interface RefreshOptions {
+      /**
+       * Also refresh the perception layer.
+       * @defaultValue `false`
+       */
+      refreshPerception?: boolean | undefined;
+    }
+
     interface PlayOptions {
       /** Should the video loop? */
-      loop: boolean;
+      loop?: boolean | undefined;
       /** A specific timestamp between 0 and the video duration to begin playback */
-      offset: number;
+      offset?: number | undefined;
       /** Desired volume level of the video's audio channel (if any) */
-      volume: number;
+      volume?: number | undefined;
     }
 
     interface OcclusionOptions {
@@ -270,7 +308,7 @@ declare global {
        * Test corners of the hit-box in addition to the token center?
        * @defaultValue `true`
        */
-      corners: boolean;
+      corners?: boolean | undefined;
     }
 
     interface AlphaMapOptions {
@@ -278,13 +316,13 @@ declare global {
        * Keep the Uint8Array of pixel alphas?
        * @defaultValue `false`
        */
-      keepPixels: boolean;
+      keepPixels?: boolean | undefined;
 
       /**
        * Keep the pure white RenderTexture?
        * @defaultValue `false`
        */
-      keepTexture: boolean;
+      keepTexture?: boolean | undefined;
     }
   }
 }