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

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

@@ -1,6 +1,10 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type {
+  ConfiguredDocumentClass,
+  ConfiguredDocumentClassForName,
+  ConfiguredObjectClassForName
+} from '../../../../../types/helperTypes';
 import type { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
-import type { WallData } from '../../../../common/data/data.mjs';
+import type { LineIntersection } from '../../../../common/utils/geometry.mjs';
 import type { HoverInOptions } from '../placeableObject';
 
 declare global {
@@ -20,36 +24,83 @@ declare global {
     controlIcon: null;
 
     /**
-     * @remarks Type is `MouseInteractionManager<this, this['endpoints']>`
+     * An reference the Door Control icon associated with this Wall, if any
+     * @internal
+     * @defaultValue `undefined`
      */
-    mouseInteractionManager: MouseInteractionManager<this> | null;
+    doorControl: DoorControl | undefined | null;
 
-    constructor(document: ConcreteWallDocument);
+    /**
+     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
+     * @defaultValue `undefined`
+     */
+    roof: InstanceType<ConfiguredObjectClassForName<'Tile'>> | undefined;
 
     /**
-     * An reference the Door Control icon associated with this Wall, if any
-     * @internal
+     * 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
      */
-    doorControl: DoorControl | null;
+    protected _vertices: { a: PolygonVertex; b: PolygonVertex } | null;
 
     /**
-     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
-     * @defaultValue `undefined`
+     * Cached representation of the set of this wall's vertices.
+     * @defaultValue `null`
+     * @internal
      */
-    roof: Tile | undefined;
+    protected _wallKeys: Set<string> | null;
 
     /** @override */
-    static get embeddedName(): 'Wall';
+    static 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
      */
@@ -73,6 +124,19 @@ declare global {
     /** @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;
+
     /** @override */
     protected _createInteractionManager(): NonNullable<this['mouseInteractionManager']>;
 
@@ -82,6 +146,7 @@ declare global {
     /**
      * 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;
 
@@ -113,7 +178,7 @@ declare global {
     protected _onRelease(options?: PlaceableObject.ReleaseOptions): void;
 
     /** @override */
-    destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
+    destroy(options?: Parameters<PlaceableObject['destroy']>[0]): void;
 
     /**
      * Test whether the Wall direction lies between two provided angles
@@ -137,15 +202,41 @@ declare global {
     getLinkedSegments(): {
       ids: string[];
       walls: WallsLayer['placeables'];
-      endpoints: Array<[number, number]>;
+      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;
+
     /** @override */
-    protected _onCreate(data: WallData['_source'], options: DocumentModificationOptions, userId: string): void;
+    protected _onCreate(
+      data: foundry.data.WallData['_source'],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
 
     /** @override */
     protected _onUpdate(
-      changed: DeepPartial<WallData['_source']>,
+      changed: DeepPartial<foundry.data.WallData['_source']>,
       options?: DocumentModificationOptions,
       userId?: string
     ): void;

package/src/foundry/foundry.js/pixi/filters/abstractFilter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * An abstract filter which provides a framework for reusable definition
+ */
+declare abstract class AbstractFilter extends PIXI.Filter {
+  /**
+   * The default uniforms used by the filter
+   * @defaultValue `{}`
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * The fragment shader which renders this filter.
+   * @defaultValue `undefined`
+   * @remarks This is a function in {@link GlowFilter}. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static fragmentShader: string | ((quality: number, distance: number) => string) | undefined;
+
+  /**
+   * The vertex shader which renders this filter.
+   * @defaultValue `undefined`
+   */
+  static vertexShader: string | undefined;
+
+  /**
+   * A factory method for creating the filter using its defined default values
+   * @param uniforms - (default: `{}`)
+   */
+  static create(uniforms: AbstractBaseShader.Uniforms): AbstractFilter;
+
+  /**
+   * Always target the resolution of the render texture or renderer
+   */
+  // @ts-expect-error this is a property on PIXI.Filter
+  get resolution(): number;
+  set resolution(value: number);
+
+  /**
+   * Always target the MSAA level of the render texture or renderer
+   */
+  get multisample(): PIXI.MSAA_QUALITY;
+  set multisample(value: PIXI.MSAA_QUALITY);
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/fogColorFilter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A filter which is rendering explored color according to FoW intensity.
+ */
+declare class FogColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   exploredColor: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/forceColorFilter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A filter which forces all non-transparent pixels to a specific color and transparency.
+ */
+declare class ForceColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   color: [1, 1, 1],
+   *   alpha: 1.0
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/glowFilter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A filter which implements an inner or outer glow around the source texture.
+ * Incorporated from https://github.com/pixijs/filters/tree/main/filters/glow
+ */
+declare class GlowFilter extends AbstractFilter {
+  /**
+   * @override
+   * @defaultValue
+   * ```typescript
+   * {
+   *   distance: 10,
+   *   innerStrength: 0,
+   *   glowColor: [1, 1, 1, 1],
+   *   quality: 0.1,
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms & { distance: number; quality: number };
+
+  /**
+   * @override
+   * @remarks This could change, see https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static fragmentShader(quality: number, distance: number): string;
+
+  /** @override */
+  static vertexShader: string;
+
+  /** @override */
+  static create(uniforms: AbstractBaseShader.Uniforms): GlowFilter;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/index.d.ts

@@ -0,0 +1,4 @@
+import './fogColorFilter';
+import './forceColorFilter';
+import './glowFilter';
+import './roofMaskFilter';

package/src/foundry/foundry.js/pixi/filters/abstractFilters/roofMaskFilter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This filter turns pixels with an alpha channel < alphaThreshold in transparent pixels
+ * Then, optionally, it can turn the result in the chosen color (default: pure white).
+ * The alpha [threshold,1] is re-mapped to [0,1] with an hermite interpolation slope to prevent pixelation.
+ */
+declare class RoofMaskFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   alphaThreshold: 0.75,
+   *   turnToColor: false,
+   *   color: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

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

@@ -1,2 +1,4 @@
 import './abstractBaseMaskFilter';
 import './abstractBaseMaskFilters';
+import './abstractFilter';
+import './abstractFilters';

package/src/foundry/foundry.js/roll.d.ts

@@ -16,7 +16,7 @@ declare global {
    * console.log(r.terms);    // [Die, OperatorTerm, NumericTerm, OperatorTerm, NumericTerm]
    *
    * // Execute the roll
-   * r.evaluate();
+   * await r.evaluate();
    *
    * // The resulting equation after it was rolled
    * console.log(r.result);   // 16 + 2 + 4
@@ -142,7 +142,7 @@ declare global {
      * @example
      * ```typescript
      * let r = new Roll("2d6 + 4 + 1d4");
-     * r.evaluate();
+     * await r.evaluate();
      * console.log(r.result); // 5 + 4 + 2
      * console.log(r.total);  // 11
      * ```

package/src/foundry/foundry.js/rollTerms/poolTerm.d.ts

@@ -59,6 +59,11 @@ declare global {
      */
     static CLOSE_REGEXP: RegExp;
 
+    /**
+     * A regular expression pattern used to match the entirety of a DicePool expression.
+     */
+    static REGEXP: RegExp;
+
     /**
      * @defaultValue `["terms", "modifiers", "rolls", "results"]`
      */