@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/foundry/client/pixi/core/shapes/polygon-helpers.d.ts

@@ -1,263 +0,0 @@
-import type { ConfiguredObjectClassForName } from '../../../../../types/helperTypes';
-
-declare global {
-  /**
-   * An internal data structure for polygon vertices
-   * @internal
-   */
-  class PolygonVertex {
-    constructor(x: number, y: number, { distance, index }?: PolygonVertexOptions);
-
-    x: number;
-
-    y: number;
-
-    key: number;
-
-    protected _distance: number | undefined;
-
-    protected _d2: undefined;
-
-    protected _index: number | undefined;
-
-    /** @defaultValue `false` */
-    protected _inLimitedAngle: boolean;
-
-    /**
-     * The set of edges which connect to this vertex.
-     * This set is initially empty and populated later after vertices are de-duplicated.
-     * @defaultValue `new Set()`
-     */
-    edges: EdgeSet;
-
-    /**
-     * The subset of edges which continue clockwise from this vertex.
-     * @defaultValue `new Set()`
-     */
-    cwEdges: EdgeSet;
-
-    /**
-     * The subset of edges which continue counter-clockwise from this vertex.
-     * @defaultValue `new Set()`
-     */
-    ccwEdges: EdgeSet;
-
-    /**
-     * The maximum restriction type of this vertex
-     * @defaultValue `null`
-     */
-    type: number | null;
-
-    /**
-     * Associate an edge with this vertex.
-     * @param edge        - The edge being attached
-     * @param orientation - The orientation of the edge with respect to the origin
-     */
-    attachEdge(edge: PolygonEdge, orientation: number): void;
-
-    /**
-     * Is this vertex limited in type?
-     */
-    get isLimited(): boolean;
-
-    /**
-     * Is this vertex terminal (at the maximum radius)
-     */
-    get isTerminal(): boolean;
-
-    /**
-     * Does this vertex have a limited edge connected to it?
-     */
-    get hasLimitedEdge(): boolean;
-
-    /**declareme point?
-     */
-    equals(other: PolygonVertex): boolean;
-
-    /**
-     * Construct a PolygonVertex instance from some other Point structure.
-     * @param point   - The point
-     * @param options - Additional options that apply to this vertex
-     * @returns The constructed vertex
-     */
-    static fromPoint(point: Point, options?: PolygonVertexOptions): PolygonVertex;
-  }
-
-  interface PolygonVertexOptions {
-    distance: PolygonVertex['_distance'];
-    index: PolygonVertex['_index'];
-  }
-
-  /**
-   * An internal data structure for polygon edges
-   * @internal
-   */
-  class PolygonEdge {
-    constructor(a: Point, b: Point, type: foundry.CONST.WALL_SENSE_TYPES, wall: Wall);
-
-    /**
-     * Is this edge limited in type?
-     */
-    get isLimited(): boolean;
-
-    /**
-     * Construct a PolygonEdge instance from a Wall placeable object.
-     * @param wall - The Wall from which to construct an edge
-     * @param type - The type of polygon being constructed
-     */
-    static fromWall(
-      wall: ConfiguredObjectClassForName<'Wall'> | WallDocument,
-      type: foundry.CONST.WALL_RESTRICTION_TYPES
-    ): PolygonEdge;
-  }
-
-  /**
-   * An object containing the result of a collision test.
-   * @internal
-   */
-  class CollisionResult {
-    constructor(values?: {
-      target?: PolygonVertex | null;
-      collisions?: PolygonVertex[];
-      cwEdges?: EdgeSet;
-      ccwEdges?: EdgeSet;
-      isBehind?: boolean;
-      isLimited?: boolean;
-      isRequired?: boolean;
-      wasLimited?: boolean;
-    });
-
-    /**
-     * The vertex that was the target of this result
-     * @defaultValue `null`
-     */
-    target: PolygonVertex | null;
-
-    /**
-     * The array of collision points which apply to this result
-     * @defaultValue `[]`
-     */
-    collisions: PolygonVertex[];
-
-    /**
-     * The set of edges connected to the target vertex that continue clockwise
-     * @defaultValue `new Set()`
-     */
-    cwEdges: EdgeSet;
-
-    /**
-     * The set of edges connected to the target vertex that continue counter-clockwise
-     * @defaultValue `new Set()`
-     */
-    ccwEdges: EdgeSet;
-
-    /**
-     * Is the target vertex for this result behind some closer active edge?
-     */
-    isBehind: boolean | undefined;
-
-    /**
-     * Does the target vertex for this result impose a limited collision?
-     */
-    isLimited: boolean | undefined;
-
-    /**
-     * Is this result required due to a limited angle?
-     */
-    isRequired: boolean | undefined;
-
-    /**
-     * Has the set of collisions for this result encountered a limited edge?
-     */
-    wasLimited: boolean | undefined;
-  }
-
-  /**
-   * A special subclass of PIXI.Point which is used for modeling Wall endpoints.
-   * A wall endpoint must have integer coordinates.
-   *
-   * This was used for the RadialSweepPolygon but can now be deleted once that is
-   * @deprecated since v9d2
-   */
-  class WallEndpoint extends PIXI.Point {
-    /**
-     * @param x - The integer x-coordinate
-     * @param y - The integer y-coordinate
-     */
-    constructor(x: number, y: number);
-
-    /**
-     * Express the point as a 32-bit integer with 16 bits allocated to x and 16 bits allocated to y
-     */
-    key: number;
-
-    /**
-     * The angle between this point and the polygon origin
-     * @defaultValue `undefined`
-     */
-    angle: number | undefined;
-
-    /**
-     * Record the set of walls which connect to this Endpoint
-     */
-    walls: Set<ConfiguredObjectClassForName<'Wall'>>;
-
-    /**
-     * Record whether this point is the endpoint of any Wall
-     * @defaultValue `false`
-     */
-    isEndpoint: boolean;
-
-    /**
-     * Record whether this point is a midpoint of any wall?
-     * @defaultValue `false`
-     */
-    isMidpoint: boolean;
-
-    /**
-     * Record whether this point is the termination of the Ray
-     * @defaultValue `false`
-     */
-    isTerminal: boolean;
-
-    /**
-     * Aggregate the maximum of each wall restriction type
-     */
-    types: Record<foundry.CONST.WALL_RESTRICTION_TYPES, number>;
-
-    /**
-     * An intermediate variable used to store the proportional distance of this point from a SightRay origin
-     * @defaultValue `undefined`
-     */
-    protected _r: number | undefined;
-
-    /**
-     * An intermediate variable used to cache the continuation attributes for a certain point
-     * @defaultValue `undefined`
-     */
-    protected _c: { left: boolean; right: boolean } | undefined;
-
-    attachWall(wall: ConfiguredObjectClassForName<'Wall'>): this;
-
-    /**
-     * Does this endpoint equal some other endpoint?
-     * @param other - Some other point with x and y coordinates
-     * @returns Are the points equal?
-     */
-    equals(other: Point): boolean;
-
-    /**
-     * Is this point one that provides only limited perspective?
-     * @param type - The perspective type being tested
-     * @returns Is perspective limited?
-     */
-    isLimited(type: foundry.CONST.WALL_RESTRICTION_TYPES): boolean;
-
-    /**
-     * Encode a x/y coordinate as a 32-bit integer
-     * @param x - The x-coordinate
-     * @param y - The y-coordinate
-     */
-    static getKey(x: number, y: number): number;
-  }
-}

package/src/foundry/client/pixi/core/shapes/precise-text.d.ts

@@ -1,18 +0,0 @@
-/**
- * An extension of the default PIXI.Text object which forces double resolution.
- * At default resolution Text often looks blurry or fuzzy.
- */
-declare class PreciseText extends PIXI.Text {
-  constructor(...args: ConstructorParameters<typeof PIXI.Text>);
-
-  /**
-   * Prepare a TextStyle object which merges the canvas defaults with user-provided options
-   * @param anchor  - A text anchor point from CONST.TEXT_ANCHOR_POINTS
-   * @param options - Additional options merged with the default TextStyle
-   * @returns The prepared TextStyle
-   */
-  static getTextStyle({
-    anchor,
-    ...options
-  }?: { anchor?: foundry.CONST.TEXT_ANCHOR_POINTS } & ConstructorParameters<typeof PIXI.TextStyle>[0]): PIXI.TextStyle;
-}

package/src/foundry/client/pixi/core/shapes/ray.d.ts

@@ -1,200 +0,0 @@
-import type { LineIntersection } from '../../../../common/utils/geometry.mjs.js';
-
-declare global {
-  interface RayIntersection {
-    /** The x-coordinate of intersection */
-    x: number;
-
-    /** The y-coordinate of intersection */
-    y: number;
-
-    /** The proximity to the Ray origin, as a ratio of distance */
-    t0: number;
-
-    /** The proximity to the Ray destination, as a ratio of distance */
-    t1: number;
-  }
-
-  /**
-   * A ray for the purposes of computing sight and collision
-   * Given points A[x,y] and B[x,y]
-   *
-   * Slope-Intercept form:
-   * y = a + bx
-   * y = A.y + ((B.y - A.Y) / (B.x - A.x))x
-   *
-   * Parametric form:
-   * R(t) = (1-t)A + tB
-   */
-  class Ray {
-    /**
-     * @param A - The origin of the Ray
-     * @param B - The destination of the Ray
-     */
-    constructor(A: Point, B: Point);
-
-    /**
-     * The origin point, `{x, y}`
-     */
-    A: Point;
-
-    /**
-     * The destination point, `{x, y}`
-     */
-    B: Point;
-
-    /**
-     * The origin y-coordinate
-     */
-    y0: number;
-
-    /**
-     * The origin x-coordinate
-     */
-    x0: number;
-
-    /**
-     * The horizontal distance of the ray, x1 - x0
-     */
-    dx: number;
-
-    /**
-     * The vertical distance of the ray, y1 - y0
-     */
-    dy: number;
-
-    /**
-     * The slope of the ray, dy over dx
-     */
-    slope: number;
-
-    /**
-     * The cached angle, computed lazily in Ray#angle
-     * @defaultValue `undefined`
-     * @internal
-     */
-    protected _angle: number | undefined;
-
-    /**
-     * The cached distance, computed lazily in Ray#distance
-     * @defaultValue `undefined`
-     * @internal
-     */
-    protected _distance: number | undefined;
-
-    /**
-     * The normalized angle of the ray in radians on the range (-PI, PI).
-     * The angle is computed lazily (only if required) and cached.
-     */
-    get angle(): number;
-    set angle(value: number);
-
-    /**
-     * A bounding rectangle that encompasses the Ray
-     */
-    get bounds(): NormalizedRectangle;
-
-    /**
-     * The distance (length) of the Ray in pixels.
-     * The distance is computed lazily (only if required) and cached.
-     */
-    get distance(): number;
-    set distance(value: number);
-
-    /**
-     * A factory method to construct a Ray from an origin point, an angle, and a distance
-     * @param x        - The origin x-coordinate
-     * @param y        - The origin y-coordinate
-     * @param radians  - The ray angle in radians
-     * @param distance - The distance of the ray in pixels
-     * @returns The constructed Ray instance
-     */
-    static fromAngle(x: number, y: number, radians: number, distance: number): Ray;
-
-    /**
-     * A factory method to construct a Ray from points in array format.
-     * @param A - The origin point [x,y]
-     * @param B - The destination point [x,y]
-     * @returns The constructed Ray instance
-     */
-    static fromArrays(A: PointArray, B: PointArray): Ray;
-
-    /**
-     * Project the Array by some proportion of it's initial distance.
-     * Return the coordinates of that point along the path.
-     * @param t - The distance along the Ray
-     * @returns The coordinates of the projected point
-     */
-    project(t: number): { x: number; y: number };
-
-    /**
-     * Create a Ray by projecting a certain distance towards a known point.
-     * @param origin   - The origin of the Ray
-     * @param point    - The point towards which to project
-     * @param distance - The distance of projection
-     */
-    static towardsPoint(origin: Point, point: Point, distance: number): Ray;
-
-    /**
-     * Create a Ray by projecting a certain squared-distance towards a known point.
-     * @param origin    - The origin of the Ray
-     * @param point     - The point towards which to project
-     * @param distance2 - The squared distance of projection
-     */
-    static towardsPointSquared(origin: Point, point: Point, distance2: number): Ray;
-
-    /**
-     * Reverse the direction of the Ray, returning a second Ray
-     */
-    reverse(): Ray;
-
-    /**
-     * Create a new ray which uses the same origin point, but a slightly offset angle and distance
-     * @param offset   - An offset in radians which modifies the angle of the original Ray
-     * @param distance - A distance the new ray should project, otherwise uses the same distance.
-     * @returns A new Ray with an offset angle
-     */
-    shiftAngle(angleOffset: number, distance?: number): Ray;
-
-    /**
-     * Find the point I[x,y] and distance t* on ray R(t) which intersects another ray
-     * @see foundry.utils.lineLineIntersection
-     */
-    intersectSegment(coords: [x0: number, y0: number, x1: number, y1: number]): LineIntersection | null;
-  }
-
-  /**
-   * A subclass of Ray that is used specifically for computing source polygons
-   *
-   * This was used for the RadialSweepPolygon but can now be deleted once that is
-   * @deprecated since v9d2
-   */
-  class SightRay extends Ray {
-    /**
-     * The array of sorted collision points which apply for this Ray.
-     */
-    collisions: WallEndpoint[];
-
-    /**
-     * The target endpoint at which this Ray was fired
-     */
-    endpoint: WallEndpoint | null;
-
-    /**
-     * The result objects which records the outcome of this Ray
-     */
-    result: {
-      collisions: unknown[];
-      continuation: unknown | undefined;
-      limitation: number;
-      superfluous: boolean;
-      stopped: boolean;
-      activeWalls: unknown | undefined;
-    };
-
-    /**
-     * The final collision point that this SightRay encountered.
-     */
-    get lastCollision(): WallEndpoint | null;
-  }
-}

package/src/foundry/client/pixi/core/shapes/source-polygon.d.ts

@@ -1,110 +0,0 @@
-interface PointSourcePolygonConfig {
-  /** The type of polygon being computed */
-  type?: foundry.CONST.WALL_RESTRICTION_TYPES;
-
-  /** The angle of emission, if limited */
-  angle?: number;
-
-  /** The desired density of padding rays, a number per PI */
-  density?: number;
-
-  /** A limited radius of the resulting polygon */
-  radius?: number;
-
-  /** The direction of facing, required if the angle is limited */
-  rotation?: number;
-
-  /** Display debugging visualization and logging for the polygon */
-  debug?: boolean;
-
-  /** Is this polygon constrained by any walls? */
-  walls?: boolean;
-
-  /** The object (if any) that spawned this polygon. */
-  source?: PointSource;
-}
-
-/**
- * An extension of the default PIXI.Polygon which is used to represent the line of sight for a point source.
- */
-declare abstract class PointSourcePolygon extends PIXI.Polygon {
-  /**
-   * The origin point of the source polygon.
-   */
-  origin: Point;
-
-  /**
-   * The configuration of this polygon.
-   * @defaultValue `{}`
-   */
-  config: PointSourcePolygonConfig;
-
-  /**
-   * A cached array of SightRay objects used to compute the polygon.
-   * @defaultValue `[]`
-   * @remarks This is documented as `SightRay[]` but that's only correct for the {@link RadialSweepPolygon}
-   */
-  rays: Ray[];
-
-  /**
-   * Compute the rectangular bounds for the Polygon.
-   * @param points - The initially provided array of coordinates
-   * @returns The computed Rectangular bounds
-   */
-  protected _getBounds(points: number[]): PIXI.Rectangle;
-
-  /**
-   * Benchmark the performance of polygon computation for this source
-   * @param iterations - The number of test iterations to perform
-   * @param args       - Arguments passed to the compute method
-   */
-  static benchmark(
-    iterations: number,
-    ...args: Parameters<typeof PointSourcePolygon['create']>
-  ): ReturnType<typeof foundry.utils.benchmark>;
-
-  /**
-   * Compute the polygon given a point origin and radius
-   * @param origin - The origin source point
-   * @param config - Configuration options which customize the polygon computation
-   *                 (default: `{}`)
-   * @returns The computed polygon instance
-   */
-  static create(
-    origin: Point,
-    config?: Parameters<PointSourcePolygon['initialize']>[1] | undefined
-  ): ReturnType<PointSourcePolygon['compute']>;
-
-  /**
-   * Compute the polygon using the origin and configuration options.
-   * @returns The computed polygon
-   */
-  compute(): this;
-
-  /**
-   * Perform the implementation-specific computation
-   */
-  protected abstract _compute(): void;
-
-  /**
-   * Customize the provided configuration object for this polygon type.
-   * @param origin - The provided polygon origin
-   * @param config - The provided configuration object
-   */
-  initialize(origin: Point, config: PointSourcePolygonConfig): void;
-
-  /**
-   * Visualize the polygon, displaying its computed area, rays, and collision points
-   */
-  visualize(): void;
-}
-
-/**
- * Compare sight performance between different algorithms
- * @param n    - The number of iterations
- * @param args - Arguments passed to the polygon compute function
- */
-declare function benchmarkSight(
-  n: number,
-  ...args: Parameters<typeof ClockwiseSweepPolygon['benchmark']>
-): Promise<void>;

package/src/foundry/client/pixi/groups/effects.d.ts

@@ -1,29 +0,0 @@
-/**
- * A container group which contains visual effects rendered above the primary group.
- */
-declare class EffectsCanvasGroup extends PIXI.Container {
-  constructor();
-
-  walls: WallsLayer;
-
-  lighting: LightingLayer;
-
-  weather: WeatherLayer;
-
-  sight: SightLayer;
-
-  /** @defaultValue `true` */
-  sortableChildren: boolean;
-
-  /**
-   * The name of this canvas group
-   * @defaultValue `"effects"`
-   */
-  static groupName: string;
-
-  /**
-   * Create the member layers of the scene container
-   * @internal
-   */
-  protected _createLayers(): void;
-}

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

@@ -1,3 +0,0 @@
-import './effects';
-import './interface';
-import './primary';

package/src/foundry/client/pixi/groups/interface.d.ts

@@ -1,27 +0,0 @@
-/**
- * A container group which displays interface elements rendered above other canvas groups.
- */
-declare class InterfaceCanvasGroup extends PIXI.Container {
-  constructor();
-
-  sounds: SoundsLayer;
-
-  notes: NotesLayer;
-
-  controls: ControlsLayer;
-
-  /** @defaultValue `true` */
-  sortableChildren: boolean;
-
-  /**
-   * The name of this canvas group
-   * @defaultValue `"interface"`
-   */
-  static groupName: string;
-
-  /**
-   * Create the member layers of the scene container
-   * @internal
-   */
-  protected _createLayers(): void;
-}

package/src/foundry/client/pixi/groups/primary.d.ts

@@ -1,40 +0,0 @@
-/**
- * A cached container group which renders the primary visible contents of a Scene.
- */
-declare class PrimaryCanvasGroup extends CachedContainer {
-  constructor();
-
-  background: BackgroundLayer;
-
-  drawings: DrawingsLayer;
-
-  grid: GridLayer;
-
-  templates: TemplateLayer;
-
-  tokens: TokenLayer;
-
-  foreground: ForegroundLayer;
-
-  /** @defaultValue `true` */
-  sortableChildren: boolean;
-
-  /**
-   * The name of this canvas group
-   * @defaultValue `"primary"`
-   */
-  static groupName: string;
-
-  /**
-   * @defaultValue `[0, 0, 0, 0]`
-   */
-  override clearColor: [r: number, g: number, b: number, a: number];
-
-  /**
-   * Create the member layers of the scene container
-   * @internal
-   */
-  protected _createLayers(): void;
-
-  override render(renderer: Parameters<PIXI.Container['render']>[0]): void;
-}

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

@@ -1,10 +0,0 @@
-import './board';
-import './core';
-import './groups';
-import './layer';
-import './layers';
-import './perception';
-import './placeables';
-import './placeables/index';
-import './sources';
-import './webgl';