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

package/src/foundry/client/pixi/placeables/template.d.mts

@@ -0,0 +1,211 @@
+import type { RequiredProps } from "../../../../types/utils.d.mts";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace MeasuredTemplate {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof MeasuredTemplate>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshShape: boolean;
+
+      refreshTemplate: boolean;
+
+      refreshPosition: boolean;
+
+      refreshGrid: boolean;
+
+      refreshText: boolean;
+    }
+
+    interface ObjectHUD extends globalThis.ObjectHUD {
+      /**
+       * Template control icon
+       */
+      icon?: ControlIcon;
+
+      /**
+       * Ruler text tooltip
+       */
+      ruler?: PreciseText;
+    }
+
+    type InitializedObjectHUD = RequiredProps<ObjectHUD, "icon" | "ruler">;
+  }
+
+  /**
+   * A type of Placeable Object which highlights an area of the grid as covered by some area of effect.
+   * @see {@link MeasuredTemplateDocument}
+   * @see {@link TemplateLayer}
+   */
+  class MeasuredTemplate extends PlaceableObject<MeasuredTemplateDocument.ConfiguredInstance> {
+    /**
+     * The geometry shape used for testing point intersection
+     * @defaultValue `undefined`
+     */
+    shape: PIXI.Circle | PIXI.Ellipse | PIXI.Polygon | PIXI.Rectangle | PIXI.RoundedRectangle | undefined;
+
+    /**
+     * The tiling texture used for this template, if any
+     */
+    texture: PIXI.Texture | undefined;
+
+    /**
+     * The template graphics
+     * @defaultValue `undefined`
+     */
+    template: PIXI.Graphics | undefined;
+
+    /**
+     * The template control icon
+     */
+    controlIcon: ControlIcon | undefined;
+
+    /**
+     * The measurement ruler label
+     */
+    ruler: PreciseText;
+
+    /**
+     * Internal property used to configure the control border thickness
+     * @defaultValue `3`
+     */
+    protected _borderThickness: number;
+
+    static override embeddedName: "MeasuredTemplate";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshShape"], alias: true }` */
+      refresh: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshPosition", "refreshGrid", "refreshText", "refreshTemplate"] }` */
+      refreshShape: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshTemplate: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshGrid"] }` */
+      refreshPosition: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshGrid: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshText: RenderFlag<Partial<MeasuredTemplate.RenderFlags>>;
+    };
+
+    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;
+
+    /**
+     * Is this MeasuredTemplate currently visible on the Canvas?
+     */
+    get isVisible(): boolean;
+
+    /**
+     * A unique identifier which is used to uniquely identify related objects like a template effect or grid highlight.
+     */
+    get highlightId(): string;
+
+    protected override _draw(): Promise<void>;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    protected _applyRenderFlags(flags: MeasuredTemplate.RenderFlags): void;
+
+    protected override _getTargetAlpha(): number;
+
+    /**
+     * Compute the geometry for the template using its document data.
+     * Subclasses can override this method to take control over how different shapes are rendered.
+     */
+    protected _computeShape(): PIXI.Circle | PIXI.Rectangle | PIXI.Polygon;
+
+    /**
+     * Refresh the display of the template outline and shape.
+     * Subclasses may override this method to take control over how the template is visually rendered.
+     */
+    protected _refreshTemplate(): void;
+
+    /**
+     * Get a Circular area of effect given a radius of effect
+     * @internal
+     */
+    static getCircleShape(distance: number): PIXI.Circle;
+
+    /**
+     * Get a Conical area of effect given a direction, angle, and distance
+     * @internal
+     */
+    static getConeShape(direction: number, angle: number, distance: number): PIXI.Polygon;
+
+    /**
+     * Get a Rectangular area of effect given a width and height
+     * @internal
+     */
+    static getRectShape(direction: number, distance: number): PIXI.Rectangle;
+
+    /**
+     * Get a rotated Rectangular area of effect given a width, height, and direction
+     * @internal
+     */
+    static getRayShape(direction: number, distance: number, width: number): PIXI.Polygon;
+
+    /**
+     * Update the displayed ruler tooltip text
+     */
+    protected _refreshRulerText(): void;
+
+    /**
+     * Highlight the grid squares which should be shown under the area of effect
+     */
+    highlightGrid(): void;
+
+    /**
+     * Get the shape to highlight on a Scene which uses grid-less mode.
+     */
+    protected _getGridHighlightShape(): PIXI.Polygon | PIXI.Circle | PIXI.Rectangle;
+
+    /**
+     * Get an array of points which define top-left grid spaces to highlight for square or hexagonal grids.
+     */
+    protected _getGridHighlightPositions(): Point[];
+
+    override rotate(angle: number, snap: number): Promise<this>;
+
+    protected override _canControl(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent): boolean;
+
+    protected override _canConfigure(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent): boolean;
+
+    protected override _canView(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent): boolean;
+
+    /**
+     * @privateRemarks _onUpdate is overridden but with no signature changes.
+     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    protected override _canHUD(user: User.ConfiguredInstance, event?: PIXI.FederatedEvent): boolean;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
+  }
+}

package/src/foundry/client/pixi/placeables/tile.d.mts

@@ -0,0 +1,284 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace Tile {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Tile>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshShape: boolean;
+
+      refreshMesh: boolean;
+
+      refreshFrame: boolean;
+
+      refreshElevation: boolean;
+
+      refreshPerception: boolean;
+
+      refreshVideo: boolean;
+    }
+
+    interface RefreshOptions {
+      /**
+       * Also refresh the perception layer.
+       * @defaultValue `false`
+       */
+      refreshPerception?: boolean | undefined;
+    }
+
+    interface PlayOptions {
+      /** Should the video loop? */
+      loop?: boolean | undefined;
+      /** A specific timestamp between 0 and the video duration to begin playback */
+      offset?: number | undefined;
+      /** Desired volume level of the video's audio channel (if any) */
+      volume?: number | undefined;
+    }
+
+    interface OcclusionOptions {
+      /**
+       * Test corners of the hit-box in addition to the token center?
+       * @defaultValue `true`
+       */
+      corners?: boolean | undefined;
+    }
+
+    interface AlphaMapOptions {
+      /**
+       * Keep the Uint8Array of pixel alphas?
+       * @defaultValue `false`
+       */
+      keepPixels?: boolean | undefined;
+
+      /**
+       * Keep the pure white RenderTexture?
+       * @defaultValue `false`
+       */
+      keepTexture?: boolean | undefined;
+    }
+  }
+
+  /**
+   * A Tile is an implementation of PlaceableObject which represents a static piece of artwork or prop within the Scene.
+   * Tiles are drawn inside the {@link TilesLayer} container.
+   *
+   * @see {@link TileDocument}
+   * @see {@link TilesLayer}
+   */
+  class Tile extends PlaceableObject<TileDocument.ConfiguredInstance> {
+    static override embeddedName: "Tile";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshShape", "refreshElevation", "refreshVideo"], alias: true }` */
+      refresh: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshFrame"] }` */
+      refreshState: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshMesh", "refreshPerception", "refreshFrame"] }` */
+      refreshShape: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshMesh: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshFrame: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshMesh"] }` */
+      refreshElevation: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshPerception: RenderFlag<Partial<Tile.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshVideo: RenderFlag<Partial<Tile.RenderFlags>>;
+    };
+
+    /**
+     * The Tile border frame
+     */
+    frame:
+      | (PIXI.Container & {
+          border: PIXI.Graphics;
+          handle: ResizeHandle;
+        })
+      | undefined;
+
+    /**
+     * The primary tile image texture
+     * @defaultValue `undefined`
+     */
+    texture: PIXI.Texture | undefined;
+
+    /**
+     * The Tile image sprite
+     * @defaultValue `undefined`
+     */
+    tile: PIXI.Sprite | undefined;
+
+    /**
+     * A Tile background which is displayed if no valid image texture is present
+     * @defaultValue `undefined`
+     */
+    bg: PIXI.Graphics | undefined;
+
+    /**
+     * A flag which tracks if the Tile is currently playing
+     * @defaultValue `false`
+     */
+    playing: boolean;
+
+    /**
+     * Get the native aspect ratio of the base texture for the Tile sprite
+     */
+    get aspectRatio(): number;
+
+    override get bounds(): Rectangle;
+
+    /**
+     * The HTML source element for the primary Tile texture
+     */
+    get sourceElement(): HTMLImageElement | HTMLVideoElement | undefined;
+
+    /**
+     * Does this Tile depict an animated video texture?
+     */
+    get isVideo(): boolean;
+
+    /**
+     * Is this tile a roof?
+     */
+    get isRoof(): boolean;
+
+    /**
+     * Is this tile occluded?
+     * @defaultValue `false`
+     */
+    get occluded(): boolean;
+
+    /**
+     * The effective volume at which this Tile should be playing, including the global ambient volume modifier
+     */
+    get volume(): number;
+
+    /**
+     * Debounce assignment of the Tile occluded state to avoid cases like animated token movement which can rapidly
+     */
+    debounceSetOcclusion(occluded: boolean): void;
+
+    /**
+     * Create a preview tile with a background texture instead of an image
+     * @param data - Initial data with which to create the preview Tile
+     */
+    static createPreview(data: foundry.documents.BaseTile.ConstructorData): Tile.ConfiguredInstance;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    override clear(): void;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    protected override _applyRenderFlags(flags: Tile.RenderFlags): void;
+
+    /**
+     * Refresh the display of the Tile resizing handle.
+     * Shift the position of the drag handle from the bottom-right (default) depending on which way we are dragging.
+     */
+    protected _refreshHandle(b: Rectangle): void;
+
+    /**
+     * @privateRemarks _onUpdate and _onDelete are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    override activateListeners(): void;
+
+    protected override _canConfigure(user: User, event?: PIXI.FederatedEvent): boolean;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    protected override _onClickLeft2(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
+
+    protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouse-over event on a control handle
+     * @param event - The mouseover event
+     */
+    protected _onHandleHoverIn(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouse-out event on a control handle
+     * @param event - The mouseout event
+     */
+    protected _onHandleHoverOut(event: PIXI.FederatedEvent): void;
+
+    /**
+     * When we start a drag event - create a preview copy of the Tile for re-positioning
+     * @param event - The mousedown event
+     */
+    protected _onHandleMouseDown(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle the beginning of a drag event on a resize handle
+     * @param event - The mousedown event
+     */
+    protected _onHandleDragStart(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mousemove while dragging a tile scale handler
+     * @param event - The mousemove event
+     */
+    protected _onHandleDragMove(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouseup after dragging a tile scale handler
+     * @param event - The mouseup event
+     */
+    protected _onHandleDragDrop(event: PIXI.FederatedEvent): Promise<this>;
+
+    /**
+     * Handle cancellation of a drag event for one of the resizing handles
+     */
+    protected _onHandleDragCancel(event: PIXI.FederatedEvent): void;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "Tile#testOcclusion has been deprecated in favor of PrimaryCanvasObject#testOcclusion"
+     */
+    testOcclusion(token: Token.ConfiguredInstance, options?: Tile.OcclusionOptions): boolean;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "Tile#containsPixel has been deprecated in favor of PrimaryCanvasObject#containsPixel"
+     */
+    containsPixel(x: number, y: number): boolean;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "Tile#getPixelAlpha has been deprecated in favor of PrimaryCanvasObject#getPixelAlpha"
+     */
+    getPixelAlpha(...args: any[]): unknown;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "Tile#_getAlphaBounds has been deprecated in favor of PrimaryCanvasObject#_getAlphaBounds"
+     */
+    _getAlphaBounds(): unknown;
+
+    /**
+     * @remarks Not used
+     */
+    controlIcon: null;
+  }
+}