@league-of-foundry-developers/foundry-vtt-types 0.8.9-4 → 0.8.9-8

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

@@ -1,30 +1,24 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
 
 declare global {
   /**
    * An AmbientLight is an implementation of PlaceableObject which represents a dynamic light source within the Scene.
-   *
-   * @example
-   * ```typescript
-   * AmbientLight.create<AmbientLight>({
-   *   t: "l",
-   *   x: 1000,
-   *   y: 1000,
-   *   rotation: 0,
-   *   dim: 30,
-   *   bright: 15,
-   *   angle: 360,
-   *   tintColor: "#FF0000",
-   *   tintAlpha: 0.05
-   * });
-   * ```
    */
-  class AmbientLight extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof AmbientLightDocument>>> {
+  class AmbientLight extends PlaceableObject<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>> {
+    constructor(document: InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>);
+
     /**
      * A reference to the PointSource object which defines this light source area of effect
      */
     source: PointSource;
 
+    /**
+     * A reference to the ControlIcon used to configure this light
+     * @defaultValue `undefined`
+     */
+    controlIcon: ControlIcon | undefined;
+
     /** @override */
     static embeddedName: 'AmbientLight';
 
@@ -36,6 +30,11 @@ declare global {
      */
     get global(): boolean;
 
+    /**
+     * The maximum radius in pixels of the light field
+     */
+    get radius(): number;
+
     /**
      * Get the pixel radius of dim light emitted by this light source
      */
@@ -56,12 +55,18 @@ declare global {
 
     /**
      * Draw the ControlIcon for the AmbientLight
+     * @internal
      */
     protected _drawControlIcon(): ControlIcon;
 
     /** @override */
     refresh(): this;
 
+    /**
+     * Refresh the display of the ControlIcon for this AmbientLight source
+     */
+    refreshControl(): void;
+
     /**
      * The named identified for the source object associated with this light
      */
@@ -70,24 +75,34 @@ declare global {
     /**
      * Update the source object associated with this light
      * @param defer   - Defer refreshing the LightingLayer to manually call that refresh later.
+     *                  (default: `false`)
      * @param deleted - Indicate that this light source has been deleted.
+     *                  (default: `false`)
      */
-    updateSource({ defer, deleted }?: { defer: boolean; deleted: boolean }): boolean | null | void;
+    updateSource({ defer, deleted }?: { defer?: boolean; deleted?: boolean }): null | void;
 
     /** @override */
-    protected _onCreate(): void;
+    protected _onCreate(
+      data: foundry.data.AmbientLightData['_source'],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
 
     /** @override */
-    protected _onUpdate(data: AmbientLight.Data): void;
+    protected _onUpdate(
+      changed: DeepPartial<foundry.data.AmbientLightData['_source']>,
+      options?: DocumentModificationOptions,
+      userId?: string
+    ): void;
 
     /** @override */
-    protected _onDelete(): void;
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
     /** @override */
-    protected _canHUD(user: User, event?: any): boolean;
+    protected _canHUD(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /** @override */
-    protected _canConfigure(user: User, event?: any): boolean;
+    protected _canConfigure(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /** @override */
     protected _onClickRight(event: PIXI.InteractionEvent): Promise<this>;
@@ -101,21 +116,4 @@ declare global {
     /** @override */
     protected _onDragLeftCancel(event: MouseEvent): void;
   }
-
-  namespace AmbientLight {
-    interface Data {
-      angle: number;
-      bright: number;
-      darknessThreshold: number;
-      dim: number;
-      hidden: boolean;
-      lightAnimation: { speed: number; intensity: number; type?: keyof typeof CONFIG['Canvas']['lightAnimations'] };
-      locked: boolean;
-      rotation: number;
-      t: foundry.CONST.SourceType;
-      tintAlpha: number;
-      x: number;
-      y: number;
-    }
-  }
 }

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

@@ -1,47 +1,31 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
 
 declare global {
   /**
    * An AmbientSound is an implementation of PlaceableObject which represents a dynamic audio source within the Scene.
-   *
-   * @example
-   * ```typescript
-   * AmbientSound.create({
-   *   t: "l",
-   *   x: 1000,
-   *   y: 1000,
-   *   radius: 60,
-   *   easing: true,
-   *   path: "sounds/audio-file.mp3",
-   *   repeat: true,
-   *   volume: 0.4
-   * });
-   * ```
    */
-  class AmbientSound extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof AmbientSoundDocument>>> {
-    /**
-     * The Howl instance used to play this AmbientSound effect
-     */
-    howl: any;
+  class AmbientSound extends PlaceableObject<InstanceType<ConfiguredDocumentClassForName<'AmbientSound'>>> {
+    constructor(document: InstanceType<ConfiguredDocumentClassForName<'AmbientSound'>>);
 
     /**
-     * The Howl sound ID of the playing instance of this sound
+     * The Sound which manages playback for this AmbientSound effect
      */
-    howlId?: number;
+    sound: Sound | null;
+
+    /** @override */
+    static embeddedName: 'AmbientSound';
 
     /**
-     * Create an audio helper instance to use for the Ambient Sound
+     * Create a Sound used to play this AmbientSound object
+     * @internal
      */
-    protected _createHowl(): any;
-
-    /** @override */
-    static get embeddedName(): 'AmbientSound';
+    protected _createSound(): Sound | null;
 
     /**
-     * @remarks
-     * Not implemented for AmbientSound
+     * Is this ambient sound is currently audible based on its hidden state and the darkness level of the Scene?
      */
-    get bounds(): never;
+    get isAudible(): boolean;
 
     /**
      * A convenience accessor for the sound type
@@ -57,63 +41,79 @@ declare global {
      * Toggle playback of the sound depending on whether or not it is audible
      * @param isAudible - Is the sound audible?
      * @param volume    - The target playback volume
-     * @param fade      - Whether to fade the volume from its previous level
+     * @param options   - Additional options which affect sound synchronization
      */
-    play(isAudible: boolean, volume?: number, { fade }?: { fade?: boolean }): void | number;
+    sync(isAudible: boolean, volume: number, options?: Partial<AmbientSound.SyncOptions>): void;
 
-    /**
-     * @override
-     * @remarks
-     * Returns void
-     */
-    clear(): any;
+    /** @override */
+    clear(): this;
 
     /** @override */
     draw(): Promise<this>;
 
     /**
      * Draw the graphical preview of the audio source area of effect
+     * @internal
      */
-    protected drawField(): PIXI.Container;
+    drawField(): PIXI.Container;
 
     /**
      * Draw the ControlIcon for the AmbientLight
+     * @internal
      */
     protected _drawControlIcon(): ControlIcon;
 
     /** @override */
     refresh(): this;
 
+    /**
+     * Refresh the display of the ControlIcon for this AmbientSound source
+     */
+    refreshControl(): void;
+
     /**
      * Compute the field-of-vision for an object, determining its effective line-of-sight and field-of-vision polygons
      * @returns An object containing the rays, LOS polygon, and FOV polygon for the light
      */
-    computeFOV(): {
-      fov: PIXI.Polygon | null;
-      los: PIXI.Polygon | null;
-      rays: Array<Ray> | null;
-    };
+    updateSource(): { rays: null; los: null; fov: PIXI.Circle } | ReturnType<WallsLayer['computePolygon']>;
+
+    /** @override */
+    protected _onCreate(
+      data: foundry.data.AmbientSoundData['_source'],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    /** @override */
+    protected _onUpdate(
+      changed: DeepPartial<foundry.data.AmbientSoundData['_source']>,
+      options?: DocumentModificationOptions,
+      userId?: string
+    ): void;
+
+    /** @override */
+    protected _onDelete(...args: Parameters<PlaceableObject['_onDelete']>): void;
+
+    /** @override */
+    protected _canHUD(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /** @override */
-    protected _onCreate(): void;
+    protected _canConfigure(user: InstanceType<ConfiguredDocumentClassForName<'User'>>, event?: any): boolean;
 
     /** @override */
-    protected _onUpdate(data: AmbientSound.Data): void;
+    protected _onClickRight(event: PIXI.InteractionEvent): void;
 
     /** @override */
-    protected _onDelete(): void;
+    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
   }
 
   namespace AmbientSound {
-    interface Data {
-      easing: boolean;
-      path: string;
-      radius: number;
-      repeat: boolean;
-      type: 'l' | 'g';
-      volume: number;
-      x: number;
-      y: number;
+    interface SyncOptions {
+      /**
+       * A duration in milliseconds to fade volume transition
+       * @defaultValue `250`
+       */
+      fade: number;
     }
   }
 }

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

@@ -1,44 +1,22 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { ConfiguredDocumentClass, ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+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.
-   *
-   * @example
-   * ```typescript
-   * Note.create<Note>({
-   *   entryId: journalEntry.id,
-   *   x: 1000,
-   *   y: 1000,
-   *   icon: "icons/my-journal-icon.svg",
-   *   iconSize: 40,
-   *   iconTint: "#00FF000",
-   *   text: "A custom label",
-   *   fontSize: 48,
-   *   textAnchor: CONST.TEXT_ANCHOR_POINTS.CENTER,
-   *   textColor: "#00FFFF"
-   * });
-   * ```
    */
   class Note extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof NoteDocument>>> {
-    /**
-     * The associated JournalEntry which is described by this note
-     */
-    entry: JournalEntry;
-
     /** @override */
     static get embeddedName(): 'Note';
 
     /**
-     * @remarks
-     * Not implemented for Note
+     * The associated JournalEntry which is described by this note
      */
-    get bounds(): never;
+    get entry(): InstanceType<ConfiguredDocumentClassForName<'JournalEntry'>>;
 
     /**
-     * Return the text label which describes the Note
-     * Use a manually specified label with a fallback to the JournalEntry name
+     * The text label used to annotate this Note
      */
     get text(): string;
 
@@ -69,19 +47,16 @@ declare global {
     refresh(): this;
 
     /** @override */
-    protected _onUpdate(data: Note.Data): Promise<this>;
+    protected _onUpdate(changed: DeepPartial<foundry.data.NoteData['_source']>): void;
 
     /** @override */
-    protected _canHover(user: User): true;
+    protected _canHover(user: InstanceType<ConfiguredDocumentClassForName<'User'>>): true;
 
     /** @override */
-    protected _canView(user: User): boolean;
+    protected _canView(user: InstanceType<ConfiguredDocumentClassForName<'User'>>): boolean;
 
     /** @override */
-    protected _onHoverIn(
-      event: PIXI.InteractionEvent,
-      options?: Parameters<PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof NoteDocument>>>['_onHoverIn']>[1]
-    ): false | void;
+    protected _onHoverIn(event: PIXI.InteractionEvent, options?: HoverInOptions): false | void;
 
     /** @override */
     protected _onHoverOut(event: PIXI.InteractionEvent): false | void;
@@ -90,19 +65,3 @@ declare global {
     protected _onClickLeft2(event: PIXI.InteractionEvent): void;
   }
 }
-
-declare namespace Note {
-  interface Data {
-    entryId: string;
-    fontFamily: string;
-    fontSize: number;
-    icon: string;
-    iconSize: number;
-    iconTint: string;
-    text: string;
-    textAnchor: foundry.CONST.TextAnchorPoint;
-    textColor: string;
-    x: number;
-    y: number;
-  }
-}

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

@@ -1,27 +1,14 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
+import { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
+import type { TileDataConstructorData } from '../../../../common/data/data.mjs/tileData';
 
 declare global {
   /**
    * A Tile is an implementation of PlaceableObject which represents a static piece of artwork or prop within the Scene.
-   * Tiles are drawn above the {@link BackgroundLayer} but below the {@link TokenLayer}.
+   * Tiles are drawn inside a {@link BackgroundLayer} container.
    *
-   * @example
-   * ```typescript
-   * Tile.create<Tile>({
-   *   img: "path/to/tile-artwork.png",
-   *   width: 300,
-   *   height: 300,
-   *   scale: 1,
-   *   x: 1000,
-   *   y: 1000,
-   *   z: 370,
-   *   rotation: 45,
-   *   hidden: false,
-   *   locked: true
-   * });
-   * ```
-   *
-   * @see {@link TilesLayer}
+   * @see {@link TileDocument}
+   * @see {@link BackgroundLayer}
    * @see {@link TileSheet}
    * @see {@link TileHUD}
    */
@@ -33,38 +20,73 @@ declare global {
 
     /**
      * The Tile border frame
+     * @defaultValue `undefined`
      */
-    frame: PIXI.Container | null;
+    frame: PIXI.Container | undefined;
 
     /**
-     * The Tile image container
+     * The primary tile image texture
+     * @defaultValue `undefined`
      */
-    tile: PIXI.Container | null;
+    texture: PIXI.Texture | undefined;
 
     /**
-     * The primary tile image texture
+     * The Tile image sprite
+     * @defaultValue `undefined`
      */
-    texture: PIXI.Texture | null;
+    tile: PIXI.Sprite | undefined;
 
-    /** @override */
-    static get embeddedName(): 'Tile';
+    /**
+     * A Tile background which is displayed if no valid image texture is present
+     * @defaultValue `undefined`
+     */
+    bg: PIXI.Graphics | undefined;
 
     /**
-     * Apply initial sanitizations to the provided input data to ensure that a Tile has valid required attributes.
+     * A cached mapping of non-transparent pixels
+     * @defaultValue `undefined`
+     * @internal
      */
-    protected _cleanData(): void;
+    protected _alphaMap:
+      | {
+          minX: number;
+          minY: number;
+          maxX: number;
+          maxY: number;
+          pixels: Uint8Array | undefined;
+          texture: PIXI.RenderTexture | undefined;
+        }
+      | undefined;
 
     /**
-     * @remarks
-     * Not implemented by Tile
+     * A flag which tracks whether the overhead tile is currently in an occluded state
+     * @defaultValue `false`
      */
-    get bounds(): never;
+    occluded: boolean;
+
+    /** @override */
+    static embeddedName: 'Tile';
 
     /**
      * Get the native aspect ratio of the base texture for the Tile sprite
      */
     get aspectRatio(): number;
 
+    /**
+     * The HTML source element for the primary Tile texture
+     */
+    get sourceElement(): HTMLImageElement | HTMLVideoElement | undefined;
+
+    /**
+     * Does this Tile depict an animated video texture?
+     */
+    get isVideo(): boolean;
+
+    /**
+     * Is this tile a roof
+     */
+    get isRoof(): boolean;
+
     /** @override */
     draw(): Promise<this>;
 
@@ -73,26 +95,98 @@ declare global {
 
     /**
      * Refresh the display of the Tile border
+     * @internal
      */
     protected _refreshBorder(b: Rectangle): void;
 
     /**
      * Refresh the display of the Tile resizing handle
+     * @internal
      */
     protected _refreshHandle(b: Rectangle): void;
 
+    /**
+     * Play video for this Tile (if applicable).
+     * @param playing - Should the Tile video be playing?
+     * @param options - Additional options for modifying video playback
+     *                  (default: `{}`)
+     */
+    play(playing: boolean, options?: Partial<Tile.PlayOptions>): void;
+
+    /**
+     * Update the occlusion rendering for this overhead Tile for a given controlled Token.
+     * @param tokens - The set of currently controlled Token objects
+     */
+    updateOcclusion(tokens: Array<InstanceType<ConfiguredObjectClassForName<'Token'>>>): void;
+
+    /**
+     * Test whether a specific Token occludes this overhead tile.
+     * Occlusion is tested against 9 points, the center, the four corners-, and the four cardinal directions
+     * @param token   - The Token to test
+     * @param options - Additional options that affect testing
+     * @returns Is the Token occluded by the Tile?
+     */
+    testOcclusion(
+      token: InstanceType<ConfiguredObjectClassForName<'Token'>>,
+      options?: Partial<Tile.OcclusionOptions>
+    ): boolean;
+
+    /**
+     * Test whether the Tile pixel data contains a specific point in canvas space
+     */
+    containsPixel(x: number, y: number): boolean;
+
+    /**
+     * Draw a sprite for the Roof which can be deducted from the fog exploration container
+     */
+    getRoofSprite(): PIXI.Sprite | undefined;
+
+    /**
+     * Swap a Tile from the background to the foreground - or vice versa
+     * TODO: Refactor to private _onSwapLayer
+     */
+    swapLayer(): void;
+
+    /**
+     * Created a cached mapping of pixel alpha for this Tile.
+     * Cache the bounding box of non-transparent pixels for the un-rotated shape.
+     * Store an array of booleans for whether each pixel has a non-transparent value.
+     * @param options - Options which customize the return value
+     * @internal
+     */
+    protected _createAlphaMap(options: Partial<Tile.AlphaMapOptions>): Exclude<Tile['_alphaMap'], undefined>;
+
+    /**
+     * Compute the alpha-based bounding box for the tile, including an angle of rotation.
+     * @internal
+     */
+    protected _getAlphaBounds(): NormalizedRectangle;
+
+    /**
+     * Create the filter instance used to reverse-mask overhead tiles using radial or vision-based occlusion.
+     * @internal
+     */
+    protected _createOcclusionFilter(): AbstractBaseMaskFilter;
+
     /** @override */
-    activateListeners(): void;
+    protected _onUpdate(
+      changed: DeepPartial<foundry.data.TileData['_source']>,
+      options?: DocumentModificationOptions,
+      userId?: string
+    ): Promise<this> | void;
 
     /** @override */
-    protected _onUpdate(data: Tile.Data): void;
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
     /** @override */
-    protected _canHUD(user?: User, event?: any): boolean;
+    activateListeners(): void;
 
     /** @override */
     protected _canConfigure(user: User, event?: any): boolean;
 
+    /** @override */
+    protected _onClickLeft2(event: PIXI.InteractionEvent): void;
+
     /** @override */
     protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
@@ -125,6 +219,7 @@ declare global {
 
     /**
      * Handle the beginning of a drag event on a resize handle
+     * @param event - The mousedown event
      */
     protected _onHandleDragStart(event: PIXI.InteractionEvent): void;
 
@@ -140,29 +235,53 @@ declare global {
      */
     protected _onHandleDragDrop(event: PIXI.InteractionEvent): Promise<this>;
 
+    /**
+     * Get resized Tile dimensions
+     * @internal
+     */
+    protected _getResizedDimensions(event: MouseEvent, origin: Point, destination: Point): NormalizedRectangle;
+
     /**
      * Handle cancellation of a drag event for one of the resizing handles
      */
-    protected _onHandleDragCancel(event: PIXI.InteractionEvent): void;
+    protected _onHandleDragCancel(): void;
 
     /**
      * Create a preview tile with a background texture instead of an image
      */
-    static createPreview(data: Tile.Data): Tile;
+    static createPreview(data: TileDataConstructorData): Tile;
   }
 
   namespace Tile {
-    interface Data {
-      height: number;
-      hidden: boolean;
-      img: string;
-      locked: boolean;
-      rotation: number;
-      scale: number;
-      width: number;
-      x: number;
-      y: number;
-      z: number;
+    interface PlayOptions {
+      /** Should the video loop? */
+      loop: boolean;
+      /** A specific timestamp between 0 and the video duration to begin playback */
+      offset: number;
+      /** Desired volume level of the video's audio channel (if any) */
+      volume: number;
+    }
+
+    interface OcclusionOptions {
+      /**
+       * Test corners of the hit-box in addition to the token center?
+       * @defaultValue `true`
+       */
+      corners: boolean;
+    }
+
+    interface AlphaMapOptions {
+      /**
+       * Keep the Uint8Array of pixel alphas?
+       * @defaultValue `false`
+       */
+      keepPixels: boolean;
+
+      /**
+       * Keep the pure white RenderTexture?
+       * @defaultValue `false`
+       */
+      keepTexture: boolean;
     }
   }
 }