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

package/src/foundry/client/pixi/placeables/wall.d.ts

@@ -0,0 +1,268 @@
+import type {
+  ConfiguredDocumentClass,
+  ConfiguredDocumentClassForName,
+  ConfiguredObjectClassForName
+} from '../../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../../common/abstract/document.mjs';
+import type { LineIntersection } from '../../../common/utils/geometry.mjs';
+import type { HoverInOptions } from '../placeable';
+
+declare global {
+  /**
+   * A Wall is an implementation of PlaceableObject which represents a physical or visual barrier within the Scene.
+   * Walls are used to restrict Token movement or visibility as well as to define the areas of effect for ambient lights
+   * and sounds.
+   *
+   * @see {@link WallDocument}
+   * @see {@link WallsLayer}
+   * @see {@link WallConfig}
+   */
+  class Wall extends PlaceableObject<ConcreteWallDocument> {
+    /**
+     * @remarks Not used for `Wall`
+     */
+    controlIcon: null;
+
+    /**
+     * An reference the Door Control icon associated with this Wall, if any
+     * @internal
+     * @defaultValue `undefined`
+     */
+    doorControl: DoorControl | undefined | null;
+
+    /**
+     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
+     * @defaultValue `undefined`
+     */
+    roof: InstanceType<ConfiguredObjectClassForName<'Tile'>> | undefined;
+
+    /**
+     * A set which tracks other Wall instances that this Wall intersects with (excluding shared endpoints)
+     */
+    intersectsWith: Map<InstanceType<ConfiguredObjectClassForName<'Wall'>>, LineIntersection>;
+
+    /**
+     * Cached representation of this wall's endpoints as {@link PolygonVertex}es.
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _vertices: { a: PolygonVertex; b: PolygonVertex } | null;
+
+    /**
+     * Cached representation of the set of this wall's vertices.
+     * @defaultValue `null`
+     * @internal
+     */
+    protected _wallKeys: Set<string> | null;
+
+    static override embeddedName: 'Wall';
+
+    /**
+     * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
+     */
+    get coords(): Wall['data']['c'];
+
+    /**
+     * The initial endpoint of the Wall
+     */
+    get A(): Point;
+
+    /**
+     * The second endpoint of the Wall
+     */
+    get B(): Point;
+
+    /**
+     * The endpoints of the wall as {@link PolygonVertex}es.
+     */
+    get vertices(): { a: PolygonVertex; b: PolygonVertex };
+
+    /**
+     * The set of keys for this wall's endpoints.
+     */
+    get wallKeys(): Set<string>;
+
+    override get bounds(): NormalizedRectangle;
+
+    /**
+     * A boolean for whether this wall contains a door
+     */
+    get isDoor(): boolean;
+
+    /**
+     * A boolean for whether the wall contains an open door
+     */
+    get isOpen(): boolean;
+
+    /**
+     * Is this Wall interior to a non-occluded roof Tile?
+     */
+    get hasActiveRoof(): boolean;
+
+    /**
+     * Return the coordinates [x,y] at the midpoint of the wall segment
+     */
+    get midpoint(): PointArray;
+
+    override get center(): PIXI.Point;
+
+    /**
+     * Get the direction of effect for a directional Wall
+     * @returns The angle of wall effect
+     */
+    get direction(): number | null;
+
+    /**
+     * This helper converts the wall segment to a Ray
+     * @returns The wall in Ray representation
+     */
+    toRay(): Ray;
+
+    override draw(): Promise<this>;
+
+    /**
+     * Draw a control icon that is used to manipulate the door's open/closed state
+     */
+    createDoorControl(): DoorControl;
+
+    /**
+     * Determine the orientation of this wall with respect to a reference point
+     * @param point - Some reference point, relative to which orientation is determined
+     * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left,
+     *          right, or collinear (both) with the Wall
+     */
+    orientPoint(point: Point): number;
+
+    protected override _createInteractionManager(): NonNullable<this['mouseInteractionManager']>;
+
+    override activateListeners(): void;
+
+    /**
+     * Draw a directional prompt icon for one-way walls to illustrate their direction of effect.
+     * @returns The drawn icon
+     * @internal
+     */
+    protected _drawDirection(): PIXI.Sprite | null;
+
+    override refresh(): this;
+
+    /**
+     * Compute an approximate Polygon which encloses the line segment providing a specific hitArea for the line
+     * @param coords - The original wall coordinates
+     * @param pad    - The amount of padding to apply
+     * @returns A constructed Polygon for the line
+     * @internal
+     */
+    protected _getWallHitPolygon(coords: [number, number, number, number], pad: number): PIXI.Polygon;
+
+    /**
+     * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
+     * @internal
+     */
+    protected _getWallColor(): number;
+
+    /**
+     * @param chain - (default: `false`)
+     */
+    protected override _onControl({ chain }?: PlaceableObject.ControlOptions & { chain?: boolean }): void;
+
+    protected override _onRelease(options?: PlaceableObject.ReleaseOptions): void;
+
+    override destroy(options?: Parameters<PlaceableObject['destroy']>[0]): void;
+
+    /**
+     * Test whether the Wall direction lies between two provided angles
+     * This test is used for collision and vision checks against one-directional walls
+     * @param lower - The lower-bound limiting angle in radians
+     * @param upper - The upper-bound limiting angle in radians
+     */
+    isDirectionBetweenAngles(lower: number, upper: number): boolean;
+
+    /**
+     * A simple test for whether a Ray can intersect a directional wall
+     * @param ray - The ray to test
+     * @returns Can an intersection occur?
+     */
+    canRayIntersect(ray: Ray): boolean;
+
+    /**
+     * Get an Array of Wall objects which are linked by a common coordinate
+     * @returns An object reporting ids and endpoints of the linked segments
+     */
+    getLinkedSegments(): {
+      ids: string[];
+      walls: WallsLayer['placeables'];
+      endpoints: Array<[x: number, y: number]>;
+    };
+
+    /**
+     * Determine whether this wall is beneath a roof tile, and is considered "interior", or not.
+     */
+    identifyInteriorState(): void;
+
+    /**
+     * Update any intersections with this wall.
+     */
+    updateIntersections(): void;
+
+    /**
+     * Record the intersection points between this wall and another, if any.
+     * @param other - The other wall.
+     */
+    protected _identifyIntersectionsWith(other: InstanceType<ConfiguredDocumentClassForName<'Wall'>>): void;
+
+    /**
+     * Remove this wall's intersections.
+     * @internal
+     */
+    protected _removeIntersections(): void;
+
+    protected override _onCreate(
+      data: foundry.data.WallData['_source'],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    protected override _onUpdate(
+      changed: DeepPartial<foundry.data.WallData['_source']>,
+      options?: DocumentModificationOptions,
+      userId?: string
+    ): void;
+
+    protected override _onDelete(options: DocumentModificationOptions, userId: string): void;
+
+    /**
+     * Callback actions when a wall that contains a door is moved or its state is changed
+     * @param doorChange - Update vision and sound restrictions
+     *                     (default: `false`)
+     * @internal
+     */
+    protected _onModifyWall(doorChange?: boolean): Promise<void>;
+
+    protected override _canControl(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
+
+    protected override _onHoverIn(event: PIXI.InteractionEvent, options?: HoverInOptions): false | void;
+
+    protected override _onHoverOut(event: PIXI.InteractionEvent): false | void;
+
+    /**
+     * Handle mouse-hover events on the line segment itself, pulling the Wall to the front of the container stack
+     * @internal
+     */
+    protected _onMouseOverLine(event: PIXI.InteractionEvent): void;
+
+    protected override _onClickLeft(event: PIXI.InteractionEvent): boolean;
+
+    protected override _onClickLeft2(event: PIXI.InteractionEvent): void;
+
+    protected override _onClickRight2(event: PIXI.InteractionEvent): void;
+
+    protected override _onDragLeftStart(event: PIXI.InteractionEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.InteractionEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<any>;
+  }
+}
+
+type ConcreteWallDocument = InstanceType<ConfiguredDocumentClass<typeof WallDocument>>;

package/src/foundry/{foundry.js/pixi/containers/canvasLayers/placeablesLayer.d.ts → client/pixi/placeables.d.ts}

@@ -1,11 +1,11 @@
 import {
   DataSourceForPlaceable,
-  ConfiguredDocumentClass,
   ConfiguredObjectClassForName,
   ConfiguredDocumentClassForName,
-  PlaceableDocumentType
-} from '../../../../../types/helperTypes';
-import EmbeddedCollection from '../../../../common/abstract/embedded-collection.mjs';
+  PlaceableDocumentType,
+  ConstructorDataType
+} from '../../../types/helperTypes';
+import EmbeddedCollection from '../../common/abstract/embedded-collection.mjs';
 
 type ConcretePlaceableOrPlaceableObject<T> = T extends PlaceableObject ? T : PlaceableObject;
 
@@ -69,8 +69,7 @@ declare global {
       ConcretePlaceableOrPlaceableObject<InstanceType<ConfiguredObjectClassForName<DocumentName>>>
     > | null;
 
-    /** @override */
-    static get layerOptions(): PlaceablesLayer.LayerOptions<any>;
+    static override get layerOptions(): PlaceablesLayer.LayerOptions<any>;
 
     /**
      * A reference to the named Document type which is contained within this Canvas Layer.
@@ -78,6 +77,16 @@ declare global {
      */
     static documentName: PlaceableDocumentType;
 
+    /**
+     * Creation states affected to placeables during their construction.
+     */
+    static CREATION_STATES: Readonly<{
+      NONE: 0;
+      POTENTIAL: 1;
+      CONFIRMED: 2;
+      COMPLETED: 3;
+    }>;
+
     /**
      * Obtain a reference to the Collection of embedded Document instances within the currently viewed Scene
      */
@@ -120,26 +129,27 @@ declare global {
       | InstanceType<ConfiguredDocumentClassForName<DocumentName>>[];
 
     /**
-     * @override
      * @remarks It returns Promise<this> but is overridden by a subclass in this way.
      */
-    draw(): Promise<this | undefined>;
+    override draw(): Promise<this | undefined>;
 
     /**
      * Draw a single placeable object
      */
     createObject(
       data: InstanceType<ConfiguredDocumentClassForName<DocumentName>>
-    ): InstanceType<ConfiguredObjectClassForName<DocumentName>>;
+    ): InstanceType<ConfiguredObjectClassForName<DocumentName>> | null;
+
+    override tearDown(): Promise<this>;
 
-    /** @override */
-    tearDown(): Promise<this>;
+    override activate(): this;
 
-    /** @override */
-    activate(): this;
+    override deactivate(): this;
 
-    /** @override */
-    deactivate(): this;
+    /**
+     * Clear the contents of the preview container, restoring visibility of original (non-preview) objects.
+     */
+    clearPreviewContainer(): void;
 
     /**
      * Get a PlaceableObject contained in this layer by it's ID
@@ -246,7 +256,7 @@ declare global {
      * @param transformation - An object of data or function to apply to all matched objects
      * @param condition      - A function which tests whether to target each object
      *                         (default: `null`)
-     * @param options        - Additional options passed to Entity.update
+     * @param options        - Additional options passed to Document.update
      *                         (default: `{}`)
      * @returns An array of updated data once the operation is complete
      */
@@ -268,16 +278,43 @@ declare global {
       options?: DocumentModificationContext
     ): Promise<Array<InstanceType<ConfiguredDocumentClassForName<DocumentName>>>>;
 
+    /**
+     * Get the world-transformed drop position.
+     * @returns Returns the transformed x, y co-ordinates, or false if the drag event was outside the canvas.
+     */
+    protected _canvasCoordinatesFromDrop(
+      event: DragEvent,
+      {
+        center
+      }?:
+        | {
+            /**
+             * Return the co-ordinates of the center of the nearest grid element.
+             * @defaultValue `true`
+             */
+            center?: boolean | undefined;
+          }
+        | undefined
+    ): [tx: number, ty: number] | false;
+
+    /**
+     * Create a preview of this layer's object type from a world document and show its sheet so it can be finalized.
+     * @param createData - The data to create the object with.
+     * @param position   - The position to render the sheet at.
+     */
+    protected _createPreview(
+      createData: ConstructorDataType<InstanceType<ConfiguredDocumentClassForName<DocumentName>>['data']>,
+      { top, left }: { top: number; left: number }
+    ): Promise<void>;
+
     /**
      * Handle left mouse-click events which originate from the Canvas stage and are dispatched to this Layer.
-     * @param event - (unused)
      * @see {@link Canvas#_onClickLeft}
      */
     protected _onClickLeft(event: PIXI.InteractionEvent): void;
 
     /**
      * Handle double left-click events which originate from the Canvas stage and are dispatched to this Layer.
-     * @param event - (unused)
      * @see {@link Canvas#_onClickLeft2}
      */
     protected _onClickLeft2(event: PIXI.InteractionEvent): void;
@@ -302,14 +339,12 @@ declare global {
 
     /**
      * Cancel a left-click drag workflow originating from the Canvas stage.
-     * @param event - (unused)
      * @see {@link Canvas#_onDragLeftDrop}
      */
     protected _onDragLeftCancel(event: PointerEvent): void;
 
     /**
      * Handle right mouse-click events which originate from the Canvas stage and are dispatched to this Layer.
-     * @param event - (unused)
      * @see {@link Canvas#_onClickRight}
      */
     protected _onClickRight(event: PIXI.InteractionEvent): void;
@@ -324,38 +359,8 @@ declare global {
     /**
      * Handle a DELETE keypress while a placeable object is hovered
      * @param event - The delete key press event which triggered the request
-     *                (unused)
      */
     protected _onDeleteKey(event?: any): void;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    static get dataArray(): string;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    createMany(
-      data: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['createEmbeddedDocuments']>[1],
-      options: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['createEmbeddedDocuments']>[2]
-    ): ReturnType<InstanceType<ConfiguredDocumentClass<typeof Scene>>['createEmbeddedDocuments']>;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    updateMany(
-      data: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['updateEmbeddedDocuments']>[1],
-      options: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['updateEmbeddedDocuments']>[2]
-    ): ReturnType<InstanceType<ConfiguredDocumentClass<typeof Scene>>['updateEmbeddedDocuments']>;
-
-    /**
-     * @deprecated since 0.8.0
-     */
-    deleteMany(
-      data: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['deleteEmbeddedDocuments']>[1],
-      options: Parameters<InstanceType<ConfiguredDocumentClass<typeof Scene>>['deleteEmbeddedDocuments']>[2]
-    ): ReturnType<InstanceType<ConfiguredDocumentClass<typeof Scene>>['deleteEmbeddedDocuments']>;
   }
 
   interface CanvasHistory<Placeable extends PlaceableObject> {
@@ -373,6 +378,8 @@ declare global {
   namespace PlaceablesLayer {
     type HistoryEventType = 'create' | 'update' | 'delete';
 
+    type CreationState = ValueOf<typeof PlaceablesLayer['CREATION_STATES']>;
+
     /**
      * @typeParam DocumentName - The key of the configuration which defines the object and document class.
      */
@@ -409,15 +416,9 @@ declare global {
 
       /**
        * Does this layer use a quadtree to track object positions?
-       * @defaultValue `false`
+       * @defaultValue `true`
        */
       quadtree: boolean;
-
-      /**
-       * The FormApplication class used to configure objects on this layer.
-       * @defaultValue `CONFIG[this.documentName].sheetClass`
-       */
-      sheetClass: ConstructorOf<FormApplication>;
     }
   }
 }

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

@@ -0,0 +1,4 @@
+import './base-source';
+import './light-source';
+import './sound-source';
+import './vision-source';

package/src/foundry/{foundry.js/pointSources/lightSource.d.ts → client/pixi/sources/light-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   /** @see {@link foundry.data.LightData} */
@@ -160,8 +160,7 @@ declare global {
      */
     coloration: PIXI.Mesh;
 
-    /** @override */
-    static sourceType: 'light';
+    static override sourceType: 'light';
 
     /**
      * Strength of the blur for light source edges
@@ -347,7 +346,6 @@ declare global {
     /**
      * A torch animation where the luminosity and coloration decays each frame and is revitalized by flashes
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10
@@ -358,7 +356,6 @@ declare global {
     /**
      * A basic "pulse" animation which expands and contracts.
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10
@@ -374,7 +371,6 @@ declare global {
     /**
      * Emanate waves of light from the source origin point
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10

package/src/foundry/{foundry.js/pointSources/soundSource.d.ts → client/pixi/sources/sound-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   interface SoundSourceData extends PointSource.Data {
@@ -19,8 +19,7 @@ declare global {
     /** @param object - The AmbientSound object that generates this sound source */
     constructor(object: InstanceType<ConfiguredObjectClassForName<'AmbientSound'>>);
 
-    /** @override */
-    static sourceType: 'sound';
+    static override sourceType: 'sound';
 
     /**
      * The object of data which configures how the source is rendered

package/src/foundry/{foundry.js/pointSources/visionSource.d.ts → client/pixi/sources/vision-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   interface VisionSourceData extends Exclude<PointSource.Data, 'walls'> {
@@ -35,8 +35,7 @@ declare global {
      */
     illumination: PIXI.Mesh;
 
-    /** @override */
-    static sourceType: 'vision';
+    static override sourceType: 'vision';
 
     /**
      * Keys in the VisionSourceData structure which, when modified, change the appearance of the source
@@ -119,7 +118,6 @@ declare global {
      */
     protected _updateIlluminationUniforms(shader: AdaptiveIlluminationShader): void;
 
-    /** @override */
-    protected _drawRenderTextureContainer(): PIXI.Container;
+    protected override _drawRenderTextureContainer(): PIXI.Container;
   }
 }