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

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/mapLayer.d.ts

@@ -1,139 +0,0 @@
-import { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } 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>;
-
-    /**
-     * @override
-     * @remarks It returns Promise<this> but is overridden by a subclass in this way.
-     */
-    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;
-      zIndex: 0;
-      controllableObjects: true;
-      rotatableObjects: true;
-    }
-
-    type DropData =
-      | { type: 'Tile'; img: string; tileSize?: number; x: number; y: number }
-      | ({ type: string } & Partial<Record<string, unknown>>);
-  }
-}
-
-interface MapLayerConstructorData {
-  bgPath?: string;
-  /**
-   * @defaultValue `1`
-   */
-  level?: number;
-}

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/mapLayers/backgroundLayer.d.ts

@@ -1,43 +0,0 @@
-import {
-  ConfiguredDocumentClassForName,
-  ConfiguredObjectClassForName,
-  DataSourceForPlaceable
-} from '../../../../../../../types/helperTypes';
-
-declare global {
-  /**
-   * 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
-     */
-    outline: PIXI.Graphics | undefined;
-
-    draw(): Promise<this>;
-
-    /**
-     * Draw a background outline which emphasizes what portion of the canvas is playable space and what is buffer.
-     */
-    protected _drawOutline(): PIXI.Graphics | undefined;
-
-    getDocuments(): Exclude<this['documentCollection'], null> | InstanceType<ConfiguredDocumentClassForName<'Tile'>>[];
-
-    getZIndex(): number;
-
-    storeHistory(
-      type: PlaceablesLayer.HistoryEventType,
-      data: DataSourceForPlaceable<InstanceType<ConfiguredObjectClassForName<'Tile'>>>
-    ): void;
-  }
-}

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/mapLayers/foregroundLayer.d.ts

@@ -1,71 +0,0 @@
-import { ConfiguredDocumentClassForName, ConfiguredObjectClassForName } from '../../../../../../../types/helperTypes';
-
-declare global {
-  /**
-   * 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;
-
-    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;
-
-    /**
-     * 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]>;
-  }
-}

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/mapLayers/index.d.ts

@@ -1,2 +0,0 @@
-import './backgroundLayer';
-import './foregroundLayer';

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

@@ -1,14 +0,0 @@
-import './baseGrid';
-import './baseGrids';
-import './cachedContainer';
-import './cachedContainers';
-import './canvasLayer';
-import './canvasLayers';
-import './controlIcon';
-import './cursor';
-import './doorControl';
-import './effectsCanvasGroup';
-import './interfaceCanvasGroup';
-import './placeableObject';
-import './placeableObjects';
-import './ruler';

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

@@ -1,127 +0,0 @@
-import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
-import { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
-
-declare global {
-  /**
-   * A MeasuredTemplate is an implementation of PlaceableObject which represents an area of the canvas grid which is
-   * covered by some effect.
-   */
-  class MeasuredTemplate extends PlaceableObject<
-    InstanceType<ConfiguredDocumentClass<typeof MeasuredTemplateDocument>>
-  > {
-    constructor(document: InstanceType<ConfiguredDocumentClass<typeof MeasuredTemplateDocument>>);
-
-    controlIcon: ControlIcon | null;
-    template: PIXI.Graphics | null;
-    ruler: PreciseText | null;
-
-    /**
-     * The tiling texture used for this template, if any
-     */
-    texture: PIXI.Texture | null;
-
-    /**
-     * The template shape used for testing point intersection
-     */
-    shape: PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.Rectangle | PIXI.RoundedRectangle;
-
-    /**
-     * Internal property used to configure the control border thickness
-     */
-    protected _borderThickness: number;
-
-    /** @override */
-    static embeddedName: 'MeasuredTemplate';
-
-    /** @override */
-    get bounds(): Rectangle;
-
-    /**
-     * A convenience accessor for the border color as a numeric hex code
-     */
-    get borderColor(): string | number;
-
-    /**
-     * A convenience accessor for the fill color as a numeric hex code
-     */
-    get fillColor(): string | number;
-
-    /**
-     * A flag for whether the current User has full ownership over the MeasuredTemplate document.
-     */
-    get owner(): boolean;
-
-    /** @override */
-    draw(): Promise<this>;
-
-    /**
-     * Draw the ControlIcon for the MeasuredTemplate
-     */
-    protected _drawControlIcon(): ControlIcon;
-
-    /**
-     * Draw the Text label used for the MeasuredTemplate
-     */
-    protected _drawRulerText(): PreciseText;
-
-    /** @override */
-    refresh(): this;
-
-    /**
-     * Get a Circular area of effect given a radius of effect
-     */
-    protected _getCircleShape(distance: number): PIXI.Circle;
-
-    /**
-     * Get a Conical area of effect given a direction, angle, and distance
-     */
-    protected _getConeShape(direction: number, angle: number, distance: number): PIXI.Polygon;
-
-    /**
-     * Get a Rectangular area of effect given a width and height
-     */
-    protected _getRectShape(direction: number, distance: number): NormalizedRectangle;
-
-    /**
-     * Get a rotated Rectangular area of effect given a width, height, and direction
-     */
-    protected _getRayShape(direction: number, distance: number, width: number): PIXI.Polygon;
-
-    /**
-     * Draw the rotation control handle and assign event listeners
-     */
-    protected _drawRotationHandle(radius: number): void;
-
-    /**
-     * Update the displayed ruler tooltip text
-     */
-    protected _refreshRulerText(): void;
-
-    /**
-     * Highlight the grid squares which should be shown under the area of effect
-     */
-    highlightGrid(): void;
-
-    /** @override */
-    rotate(angle: number, snap: number): Promise<this>;
-
-    /** @override */
-    protected _canControl(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
-
-    /** @override */
-    protected _canConfigure(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
-
-    /** @override */
-    protected _canView(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
-
-    /** @override */
-    protected _onUpdate(
-      data: DeepPartial<InstanceType<ConfiguredDocumentClass<typeof MeasuredTemplateDocument>>['data']['_source']>,
-      options?: DocumentModificationOptions,
-      userId?: string
-    ): void;
-
-    /** @override */
-    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
-  }
-}

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

@@ -1,199 +0,0 @@
-import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
-import type { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
-import type { WallData } from '../../../../common/data/data.mjs';
-import type { HoverInOptions } from '../placeableObject';
-
-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;
-
-    /**
-     * @remarks Type is `MouseInteractionManager<this, this['endpoints']>`
-     */
-    mouseInteractionManager: MouseInteractionManager<this> | null;
-
-    constructor(document: ConcreteWallDocument);
-
-    /**
-     * An reference the Door Control icon associated with this Wall, if any
-     * @internal
-     * @defaultValue `null`
-     */
-    doorControl: DoorControl | null;
-
-    /**
-     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
-     * @defaultValue `undefined`
-     */
-    roof: Tile | undefined;
-
-    /** @override */
-    static get embeddedName(): 'Wall';
-
-    /**
-     * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
-     */
-    get coords(): Wall['data']['c'];
-
-    /** @override */
-    get bounds(): NormalizedRectangle;
-
-    /**
-     * 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>;
-
-    /** @override */
-    protected _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
-     */
-    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;
-
-    /**
-     * @override
-     * @param chain - (default: `false`)
-     */
-    protected _onControl({ chain }?: PlaceableObject.ControlOptions & { chain?: boolean }): void;
-
-    /** @override */
-    protected _onRelease(options?: PlaceableObject.ReleaseOptions): void;
-
-    /** @override */
-    destroy(options?: Parameters<PIXI.Container['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<[number, number]>;
-    };
-
-    /** @override */
-    protected _onCreate(data: WallData['_source'], options: DocumentModificationOptions, userId: string): void;
-
-    /** @override */
-    protected _onUpdate(
-      changed: DeepPartial<WallData['_source']>,
-      options?: DocumentModificationOptions,
-      userId?: string
-    ): void;
-
-    /** @override */
-    protected _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>;
-
-    /** @override */
-    protected _canControl(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
-
-    /** @override */
-    protected _onHoverIn(event: PIXI.InteractionEvent, options?: HoverInOptions): false | void;
-
-    /** @override */
-    protected _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;
-
-    /** @override */
-    protected _onClickLeft(event: PIXI.InteractionEvent): boolean;
-
-    /** @override */
-    protected _onClickLeft2(event: PIXI.InteractionEvent): void;
-
-    /** @override */
-    protected _onClickRight2(event: PIXI.InteractionEvent): void;
-
-    /** @override */
-    protected _onDragLeftStart(event: PIXI.InteractionEvent): void;
-
-    /** @override */
-    protected _onDragLeftMove(event: PIXI.InteractionEvent): void;
-
-    /** @override */
-    protected _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<any>;
-  }
-}
-
-type ConcreteWallDocument = InstanceType<ConfiguredDocumentClass<typeof WallDocument>>;

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

@@ -1,40 +0,0 @@
-/**
- * This class defines an interface for masked custom filters
- */
-declare abstract class AbstractBaseMaskFilter extends PIXI.Filter {
-  /**
-   * The default vertex shader used by all instances of AbstractBaseMaskFilter
-   */
-  static vertexShader: string;
-
-  /**
-   * The fragment shader which renders this filter.
-   * A subclass of AbstractBaseMaskFilter must implement the fragmentShader(channel) static field.
-   */
-  static fragmentShader: ((channel: 'r' | 'g' | 'b') => string) | null;
-
-  /**
-   * A factory method for creating the filter using its defined default values
-   * @param defaultUniforms - Initial uniforms provided to the filter
-   *                          (default: `{}`)
-   * @param channel         - A color channel to target for masking.
-   *                          (default: `'r'`)
-   */
-  static create<T extends AbstractBaseMaskFilter>(
-    this: ConstructorOf<T>,
-    defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
-    channel?: 'r' | 'g' | 'b'
-  ): T;
-
-  /**
-   * @override
-   * @param currentState - (unused)
-   */
-  apply(
-    filterManager: PIXI.systems.FilterSystem,
-    input: PIXI.RenderTexture,
-    output: PIXI.RenderTexture,
-    clear: PIXI.CLEAR_MODES,
-    currentState: any
-  ): void;
-}

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

@@ -1 +0,0 @@
-import './inverseOcclusionMaskFilter';

package/src/foundry/foundry.js/pixi/filters/abstractBaseMaskFilters/inverseOcclusionMaskFilter.d.ts

@@ -1,18 +0,0 @@
-/**
- * A filter used to control channels intensity using an externally provided mask texture.
- * The mask channel used must be provided at filter creation.
- * Contributed by SecretFire#4843
- */
-declare class InverseOcclusionMaskFilter extends AbstractBaseMaskFilter {
-  static fragmentShader(channel: 'r' | 'g' | 'b'): string;
-
-  /**
-   * @param defaultUniforms - (default: `{}`)
-   * @param channel  - (default `'r'`)
-   */
-  static create<T extends InverseOcclusionMaskFilter>(
-    this: ConstructorOf<T>,
-    defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
-    channel?: 'r' | 'g' | 'b'
-  ): T;
-}

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

@@ -1,2 +0,0 @@
-import './abstractBaseMaskFilter';
-import './abstractBaseMaskFilters';

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

@@ -1,2 +0,0 @@
-import './gridHighlight';
-import './resizeHandle';

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

@@ -1,11 +0,0 @@
-import './blendModes';
-import './containers';
-import './filters';
-import './graphics';
-import './meshes';
-import './points';
-import './polygons';
-import './rectangles';
-import './shaders';
-import './texts';
-import './transforms';

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

@@ -1 +0,0 @@
-import './samplerMesh';

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

@@ -1 +0,0 @@
-import './wallEndpoint';