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

package/src/foundry/client/pixi/layers/map.d.ts

@@ -0,0 +1,263 @@
+import {
+  ConfiguredDocumentClassForName,
+  ConfiguredObjectClassForName,
+  DataSourceForPlaceable
+} from '../../../../types/helperTypes';
+
+declare global {
+  /**
+   * A PlaceablesLayer designed for rendering the visual Scene for a specific vertical cross-section.
+   * Each MapLayer contains a single background image as well as an arbitrary number of Tile objects.
+   */
+  class MapLayer<Options extends MapLayer.LayerOptions = MapLayer.LayerOptions<'background'>> extends PlaceablesLayer<
+    'Tile',
+    Options
+  > {
+    /**
+     * @param data - (default: `{}`)
+     */
+    constructor(data?: MapLayerConstructorData);
+
+    /**
+     * The numeric Scene level to which this layer belongs
+     */
+    level: number;
+
+    /**
+     * The background source path
+     */
+    bgPath: string | undefined;
+
+    /**
+     * The layer background image
+     */
+    bg: PIXI.Sprite | undefined;
+
+    static documentName: 'Tile';
+
+    /**
+     * @remarks This is not overridden in foundry but reflects the real behavior.
+     * It returns the BackgroundLayer but ForegroundLayer has been added for subclasses.
+     */
+    static get instance(): Canvas['background'] | Canvas['foreground'];
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *   name: 'background',
+     *   zIndex: 0,
+     *   controllableObjects: true,
+     *   rotatableObjects: true
+     * })
+     * ```
+     */
+    static get layerOptions(): MapLayer.LayerOptions;
+
+    /**
+     * Return the base HTML image or video element which is used to generate the background Sprite.
+     */
+    get bgSource(): HTMLImageElement | HTMLVideoElement | null;
+
+    get hud(): TileHUD;
+
+    /**
+     * Is the background texture used in this layer a video?
+     */
+    get isVideo(): boolean;
+
+    /**
+     * An array of Tile objects which are rendered within the objects container
+     */
+    get tiles(): InstanceType<ConfiguredObjectClassForName<'Tile'>>[];
+
+    deactivate(): this;
+
+    tearDown(): Promise<this>;
+
+    /**
+     * @remarks It returns Promise<this> but is overridden by a subclass in this way.
+     */
+    override draw(): Promise<this | undefined>;
+
+    /**
+     * Draw the background Sprite for the layer, aligning its dimensions with those configured for the canvas.
+     * @returns The rendered Sprite, or undefined if no background is present
+     */
+    protected _drawBackground(): PIXI.Sprite | undefined;
+
+    protected _onDragLeftStart(event: PIXI.InteractionEvent): Promise<void>;
+
+    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+
+    protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
+
+    protected _onDragLeftCancel(event: PointerEvent): void;
+
+    /**
+     * Handle drop events for Tile data on the Tiles Layer
+     * @param event - The concluding drag event
+     * @param data - The extracted Tile data
+     */
+    protected _onDropData(
+      event: DragEvent,
+      data:
+        | { type: 'Tile'; img: string; tileSize?: number; x: number; y: number }
+        | ({ type: string } & Partial<Record<string, unknown>>)
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Tile'>> | undefined>;
+
+    /**
+     * Prepare the data object when a new Tile is dropped onto the canvas
+     * @param event - The concluding drag event
+     * @param data  - The extracted Tile data
+     * @returns The prepared data to create
+     */
+    protected _getDropData(
+      event: DragEvent,
+      data: MapLayer.DropData
+    ): Promise<ConstructorParameters<typeof foundry.documents.BaseTile>[0]>;
+  }
+
+  namespace MapLayer {
+    interface LayerOptions<Name extends 'background' | 'foreground' = 'background' | 'foreground'>
+      extends PlaceablesLayer.LayerOptions<'Tile'> {
+      name: Name;
+    }
+
+    type DropData =
+      | { type: 'Tile'; img: string; tileSize?: number; x: number; y: number }
+      | ({ type: string } & Partial<Record<string, unknown>>);
+  }
+
+  /**
+   * An extension of the MapLayer that displays underfoot in the background of the Scene.
+   */
+  class BackgroundLayer extends MapLayer {
+    /**
+     * @remarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas['background'];
+
+    /**
+     * @remarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get layerOptions(): MapLayer.LayerOptions<'background'>;
+
+    /**
+     * The outline of the scene.
+     * Not rendered within the BackgroundLayer, but rather beneath it so it does not impact the PrimaryMesh texture.
+     */
+    outline: PIXI.Graphics | undefined;
+
+    /**
+     * Draw a background outline which emphasizes what portion of the canvas is playable space and what is buffer.
+     * @param outline - The outline graphics to use
+     */
+    drawOutline(outline: PIXI.Graphics): void;
+
+    getDocuments(): Exclude<this['documentCollection'], null> | InstanceType<ConfiguredDocumentClassForName<'Tile'>>[];
+
+    getZIndex(): number;
+
+    storeHistory(
+      type: PlaceablesLayer.HistoryEventType,
+      data: DataSourceForPlaceable<InstanceType<ConfiguredObjectClassForName<'Tile'>>>
+    ): void;
+  }
+
+  /**
+   * An extension of the MapLayer that displays overhead in the foreground of the Scene.
+   */
+  class ForegroundLayer extends MapLayer<MapLayer.LayerOptions<'foreground'>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *   name: "foreground"
+     * })
+     * ```
+     */
+    static get layerOptions(): MapLayer.LayerOptions<'foreground'>;
+
+    /**
+     * @remarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas['foreground'];
+
+    /**
+     * Get an array of overhead Tile objects which are roofs
+     */
+    get roofs(): InstanceType<ConfiguredObjectClassForName<'Tile'>>[];
+
+    /**
+     * Determine whether to display roofs
+     */
+    get displayRoofs(): boolean;
+
+    draw(): Promise<undefined>;
+
+    /**
+     * Draw the container used to cache the position of Token occlusion shapes to a RenderTexture
+     */
+    protected _drawOcclusionMask(): CachedContainer;
+
+    /**
+     * Perform one-time initialization actions which affect the foreground layer.
+     * These actions presume and require that the layer has already been drawn.
+     */
+    initialize(): void;
+
+    override activate(): this;
+
+    deactivate(): this;
+
+    tearDown(): Promise<this>;
+
+    getZIndex(): number;
+
+    getDocuments(): Exclude<this['documentCollection'], null> | InstanceType<ConfiguredDocumentClassForName<'Tile'>>[];
+
+    /**
+     * Refresh the display of tiles on the Foreground Layer depending on Token occlusion.
+     */
+    refresh(): void;
+
+    /**
+     * Add a roof sprite to the occlusion roof mask container
+     * @param tile - The roof tile being added
+     */
+    addRoofSprite(tile: InstanceType<ConfiguredObjectClassForName<'Tile'>>): void;
+
+    /**
+     * Remove a roof sprite from occlusion roof mask container
+     * @param tile - The roof tile being removed
+     */
+    removeRoofSprite(tile: InstanceType<ConfiguredObjectClassForName<'Tile'>>): void;
+
+    /**
+     * Update occlusion for all tiles on the foreground layer
+     */
+    updateOcclusion(): void;
+
+    /**
+     * Draw the container which caches token-based occlusion shapes
+     * @param tokens - The set of currently observed tokens
+     */
+    protected _drawOcclusionShapes(tokens: ConfiguredObjectClassForName<'Token'>[]): void;
+
+    protected _getDropData(
+      event: DragEvent,
+      data:
+        | { type: 'Tile'; img: string; tileSize?: number; x: number; y: number }
+        | ({ type: string } & Partial<Record<string, unknown>>)
+    ): Promise<ConstructorParameters<typeof foundry.documents.BaseTile>[0]>;
+  }
+}
+
+interface MapLayerConstructorData {
+  bgPath?: string;
+  /**
+   * @defaultValue `1`
+   */
+  level?: number;
+}

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/notesLayer.d.ts → client/pixi/layers/notes.d.ts}

@@ -1,4 +1,4 @@
-import { DropData } from '../../../../clientDocumentMixin';
+import { DropData } from '../../data/abstract/client-document';
 
 declare global {
   /**
@@ -11,7 +11,6 @@ declare global {
     static get instance(): Canvas['notes'];
 
     /**
-     * @override
      * @defaultValue
      * ```
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -22,28 +21,25 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): NotesLayer.LayerOptions;
+    static override get layerOptions(): NotesLayer.LayerOptions;
 
-    /** @override */
-    static documentName: 'Note';
+    static override documentName: 'Note';
 
     /**
      * The named core setting which tracks the toggled visibility state of map notes
      */
     static TOGGLE_SETTING: 'notesDisplayToggle';
 
-    /** @override */
-    activate(): this;
+    override activate(): this;
 
-    /** @override */
-    deactivate(): this;
+    override deactivate(): this;
 
     /**
      * Register game settings used by the NotesLayer
      */
     static registerSettings(): void;
 
-    /** @override */
+    /** @remarks this method seems to be unused, see https://gitlab.com/foundrynet/foundryvtt/-/issues/7004 */
     protected _onMouseDown(event: PIXI.InteractionEvent): void;
 
     /**

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/sightLayer.d.ts → client/pixi/layers/sight.d.ts}

@@ -21,7 +21,7 @@
  * Hooks.on("sightRefresh", layer => {});
  * ```
  */
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import { ConfiguredDocumentClass } from '../../../../types/helperTypes';
 
 declare global {
   class SightLayer extends CanvasLayer<SightLayer.LayerOptions> {
@@ -151,7 +151,6 @@ declare global {
     static get instance(): Canvas['sight'];
 
     /**
-     * @override
      * @defaultValue
      * ```typescript
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -160,7 +159,7 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): SightLayer.LayerOptions;
+    static override get layerOptions(): SightLayer.LayerOptions;
 
     /**
      * Does the currently viewed Scene support Token field of vision?
@@ -172,8 +171,7 @@ declare global {
      */
     get fogExploration(): boolean;
 
-    /** @override */
-    tearDown(): Promise<this>;
+    override tearDown(): Promise<this>;
 
     /**
      * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
@@ -190,8 +188,7 @@ declare global {
      */
     updateFogExplorationColors(): void;
 
-    /** @override */
-    draw(): Promise<this>;
+    override draw(): Promise<this>;
 
     /**
      * Create the cached container and sprite used to provide a LOS mask

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/soundsLayer.d.ts → client/pixi/layers/sounds.d.ts}

@@ -21,7 +21,6 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
   static get instance(): Canvas['sounds'];
 
   /**
-   * @override
    * @defaultValue
    * ```
    * foundry.utils.mergeObject(super.layerOptions, {
@@ -30,13 +29,12 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
    * })
    * ```
    * */
-  static get layerOptions(): SoundsLayer.LayerOptions;
 
-  /** @override */
-  static documentName: 'AmbientSound';
+  static override get layerOptions(): SoundsLayer.LayerOptions;
 
-  /** @override */
-  tearDown(): Promise<this>;
+  static override documentName: 'AmbientSound';
+
+  override tearDown(): Promise<this>;
 
   /**
    * Initialize all AmbientSound sources which are present on this layer
@@ -90,17 +88,13 @@ declare class SoundsLayer extends PlaceablesLayer<'AmbientSound', SoundsLayer.La
    */
   protected _onMouseMove(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<AmbientSound['draw']>;
+  protected override _onDragLeftStart(event: PIXI.InteractionEvent): ReturnType<AmbientSound['draw']>;
 
-  /** @override */
-  protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftDrop(event: PIXI.InteractionEvent): void;
 
-  /** @override */
-  protected _onDragLeftCancel(event: PointerEvent): void;
+  protected override _onDragLeftCancel(event: PointerEvent): void;
 
   /**
    * Handle PlaylistSound document drop data.

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/templateLayer.d.ts → client/pixi/layers/templates.d.ts}

@@ -9,7 +9,6 @@ declare class TemplateLayer extends PlaceablesLayer<'MeasuredTemplate', Template
   static get instance(): Canvas['templates'];
 
   /**
-   * @override
    * @defaultValue
    * ```
    * mergeObject(super.layerOptions, {
@@ -21,32 +20,24 @@ declare class TemplateLayer extends PlaceablesLayer<'MeasuredTemplate', Template
    * })
    * ```
    */
-  static get layerOptions(): TemplateLayer.LayerOptions;
+  static override get layerOptions(): TemplateLayer.LayerOptions;
 
-  /** @override */
-  static documentName: 'MeasuredTemplate';
+  static override documentName: 'MeasuredTemplate';
 
-  /** @override */
-  activate(): this;
+  override activate(): this;
 
-  /** @override */
-  deactivate(): this;
+  override deactivate(): this;
 
   /**
    * Register game settings used by the TemplatesLayer
    */
   static registerSettings(): void;
 
-  /** @override */
-  protected _onDragLeftStart(event: PIXI.InteractionEvent): Promise<MeasuredTemplate>;
+  protected override _onDragLeftStart(event: PIXI.InteractionEvent): Promise<MeasuredTemplate>;
 
-  /** @override */
-  protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+  protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-  /**
-   * @override
-   */
-  protected _onMouseWheel(event: WheelEvent): void | ReturnType<MeasuredTemplate['rotate']>;
+  protected override _onMouseWheel(event: WheelEvent): void | ReturnType<MeasuredTemplate['rotate']>;
 }
 
 declare namespace TemplateLayer {

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/tokenLayer.d.ts → client/pixi/layers/tokens.d.ts}

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../../types/helperTypes';
-import { SelectOptions } from '../placeablesLayer';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import { SelectOptions } from '../placeables';
 
 declare global {
   /**
@@ -26,7 +26,6 @@ declare global {
     static get instance(): Canvas['tokens'];
 
     /**
-     * @override
      * @defaultValue
      * ```typescript
      * foundry.utils.mergeObject(super.layerOptions, {
@@ -38,15 +37,11 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): TokenLayer.LayerOptions;
+    static override get layerOptions(): TokenLayer.LayerOptions;
 
-    /**
-     * @override
-     */
-    static documentName: 'Token';
+    static override documentName: 'Token';
 
-    /** @override */
-    get gridPrecision(): 1;
+    override get gridPrecision(): 1;
 
     /**
      * Token objects on this layer utilize the TokenHUD
@@ -58,20 +53,16 @@ declare global {
      */
     get ownedTokens(): ReturnType<this['placeables']['filter']>;
 
-    /** @override */
-    tearDown(): Promise<this>;
+    override tearDown(): Promise<this>;
 
-    /** @override */
-    activate(): this;
+    override activate(): this;
 
-    /** @override */
-    deactivate(): this;
+    override deactivate(): this;
 
     /**
-     * @override
      * @param options - (default: `{}`)
      */
-    selectObjects(options?: SelectOptions): boolean;
+    override selectObjects(options?: SelectOptions): boolean;
 
     /**
      * Target all Token instances which fall within a coordinate rectangle.
@@ -157,8 +148,7 @@ declare global {
       data: TokenLayer.DropData
     ): Promise<void | false | InstanceType<ConfiguredObjectClassForName<'Token'>>>;
 
-    /** @override */
-    protected _onClickLeft(event: PIXI.InteractionEvent): void;
+    protected override _onClickLeft(event: PIXI.InteractionEvent): void;
   }
 
   namespace TokenLayer {

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayers/wallsLayer.d.ts → client/pixi/layers/walls.d.ts}

@@ -1,5 +1,5 @@
-import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../../../types/helperTypes';
-import { PasteOptions } from '../placeablesLayer';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName } from '../../../../types/helperTypes';
+import { PasteOptions } from '../placeables';
 
 declare global {
   /**
@@ -60,7 +60,6 @@ declare global {
     static get instance(): Canvas['walls'];
 
     /**
-     * @override
      * @defaultValue
      * ```
      * mergeObject(super.layerOptions, {
@@ -71,10 +70,9 @@ declare global {
      * })
      * ```
      */
-    static get layerOptions(): WallsLayer.LayerOptions;
+    static override get layerOptions(): WallsLayer.LayerOptions;
 
-    /** @override */
-    static documentName: 'Wall';
+    static override documentName: 'Wall';
 
     /**
      * An Array of Wall instances in the current Scene which act as Doors.
@@ -87,13 +85,9 @@ declare global {
      */
     get gridPrecision(): number;
 
-    /**
-     * @override
-     */
-    draw(): Promise<this>;
+    override draw(): Promise<this>;
 
-    /** @override */
-    deactivate(): this;
+    override deactivate(): this;
 
     /**
      * Perform initialization steps for the WallsLayer whenever the composition of walls in the Scene is changed.
@@ -142,14 +136,9 @@ declare global {
      */
     highlightControlledSegments(): void;
 
-    /** @override */
-    releaseAll(options?: PlaceableObject.ReleaseOptions): number;
+    override releaseAll(options?: PlaceableObject.ReleaseOptions): number;
 
-    /**
-     * @override
-     * @param options - (unused)
-     */
-    pasteObjects(
+    override pasteObjects(
       position: Point,
       options?: PasteOptions
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseWall>>[]>;
@@ -193,20 +182,15 @@ declare global {
         }
       | this['_cloneType'];
 
-    /** @override */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftStart(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftDrop(event: PIXI.InteractionEvent): void;
+    protected override _onDragLeftDrop(event: PIXI.InteractionEvent): void;
 
-    /** @override */
-    protected _onDragLeftCancel(event: PointerEvent): void;
+    protected override _onDragLeftCancel(event: PointerEvent): void;
 
-    /** @override */
-    protected _onClickRight(event: PIXI.InteractionEvent): void;
+    protected override _onClickRight(event: PIXI.InteractionEvent): void;
 
     /** @deprecated since v9 */
     computePolygon(

package/src/foundry/{foundry.js/pixi/polygons/pointSourcePolygons/clockwiseSweepPolygon.d.ts → client/pixi/perception/clockwise-sweep.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   type VertexMap = Map<number, PolygonVertex>;
@@ -114,14 +114,12 @@ declare global {
     ): ReturnType<ClockwiseSweepPolygon['compute']>;
 
     /**
-     * @override
      * @param origin - The provided polygon origin
      * @param config - The provided configuration object
      */
-    initialize(origin: Point, config: ClockwiseSweepPolygon.InitConfig): void;
+    override initialize(origin: Point, config: ClockwiseSweepPolygon.InitConfig): void;
 
-    /** @override */
-    protected _compute(): void;
+    protected override _compute(): void;
 
     /**
      * Round vertices of a ray segment
@@ -191,7 +189,6 @@ declare global {
     /**
      * Test whether a target vertex is behind some closer active edge
      * @param ray         - The ray being evaluated
-     *                      (unused)
      * @param vertex      - The target vertex
      * @param activeEdges - The set of active edges
      * @returns Is the target vertex behind some closer edge?
@@ -344,8 +341,7 @@ declare global {
      */
     static pointBetweenRays(vertex: PolygonVertex, rMin: PolygonRay, rMax: PolygonRay, angle: number): boolean;
 
-    /** @override */
-    visualize(): void;
+    override visualize(): void;
 
     /**
      * Check whether a given ray intersects with walls.

package/src/foundry/client/pixi/perception/index.d.ts

@@ -0,0 +1,2 @@
+import './clockwise-sweep';
+import './perception-manager';