@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1

package/src/foundry/client/canvas/containers/_module.d.mts

@@ -0,0 +1,25 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
+
+export * as types from "./_types.mjs";
+
+export { default as CachedContainer } from "./advanced/cached-container.mjs";
+export { default as UnboundContainer } from "./advanced/unbound-container.mjs";
+export { default as FullCanvasObjectMixin } from "./advanced/full-canvas-mixin.mjs";
+
+export { default as ControlIcon } from "./elements/control-icon.mjs";
+export { default as Cursor } from "./elements/cursor.mjs";
+export { default as DoorControl } from "./elements/door-control.mjs";
+export { default as DoorMesh } from "./elements/door-mesh.mjs";
+export { default as GridMesh } from "./elements/grid-mesh.mjs";
+export { default as GridHighlight } from "./elements/grid-highlight.mjs";
+export { default as PointSourceMesh } from "./elements/point-source-mesh.mjs";
+export { default as PreciseText } from "./elements/precise-text.mjs";
+export { default as QuadMesh } from "./elements/quad-mesh.mjs";
+export { default as ResizeHandle } from "./elements/resize-handle.mjs";
+export { default as SpriteMesh } from "./elements/sprite-mesh.mjs";
+
+export { default as ParticleEffect } from "./elements/particles/particle-effect.mjs";
+export { default as AutumnLeavesWeatherEffect } from "./elements/particles/leaves.mjs";

package/src/foundry/client/canvas/containers/_types.d.mts

@@ -0,0 +1,14 @@
+import type { GridMesh } from "./_module.mjs";
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+// After seeing that none of these types add anything or are even exported a
+// very reasonable question may be: Why on earth does this file exist?
+//
+// Well this is the file in which Foundry defines these types. We don't house
+// them here because it has poor discoverability. It's also just nice to
+// have as reference to keep us synced with the latest version of Foundry.
+
+export {};
+
+type GridMeshData = GridMesh.MeshData;

package/src/foundry/client/canvas/containers/advanced/cached-container.d.mts

@@ -0,0 +1,138 @@
+import type { Identity, NullishProps } from "#utils";
+import { SpriteMesh } from "#client/canvas/containers/_module.mjs";
+
+/**
+ * A special type of PIXI.Container which draws its contents to a cached RenderTexture.
+ * This is accomplished by overriding the Container#render method to draw to our own special RenderTexture.
+ */
+declare class CachedContainer extends PIXI.Container {
+  /**
+   * Construct a CachedContainer.
+   * @param sprite - A specific sprite to bind to this CachedContainer and its renderTexture.
+   */
+  constructor(sprite?: PIXI.Sprite | SpriteMesh);
+
+  /**
+   * The texture configuration to use for this cached container
+   * @remarks Foundry marked as `@abstract`
+   */
+  static textureConfiguration: CachedContainer.TextureConfiguration;
+
+  /**
+   * A map of render textures, linked to their render function and an optional RGBA clear color.
+   */
+  protected _renderPaths: Map<PIXI.RenderTexture, CachedContainer.RenderOptions>;
+
+  /**
+   * An RGBA array used to define the clear color of the RenderTexture
+   * @defaultValue `[0, 0, 0, 1]`
+   */
+  clearColor: Color.RGBAColorVector;
+
+  /**
+   * Should our Container also be displayed on screen, in addition to being drawn to the cached RenderTexture?
+   * @defaultValue `false`
+   */
+  displayed: boolean;
+
+  /**
+   * If true, the Container is rendered every frame.
+   * If false, the Container is rendered only if {@link CachedContainer.renderDirty | `CachedContainer#renderDirty`} is true.
+   * @defaultValue `true`
+   */
+  autoRender: boolean;
+
+  /**
+   * Does the Container need to be rendered?
+   * Set to false after the Container is rendered.
+   * @defaultValue `true`
+   */
+  renderDirty: boolean;
+
+  /**
+   * The primary render texture bound to this cached container.
+   */
+  get renderTexture(): PIXI.RenderTexture;
+
+  /**
+   * Set the alpha mode of the cached container render texture.
+   */
+  set alphaMode(mode: PIXI.ALPHA_MODES);
+
+  /** @remarks Foundry provides no getter, this is for accurate typing only, as without it Typescript would infer the type as `PIXI.ALPHA_MODES` */
+  get alphaMode(): undefined;
+
+  /**
+   * A bound Sprite which uses this container's render texture
+   */
+  get sprite(): PIXI.Sprite | SpriteMesh | undefined;
+
+  set sprite(sprite: PIXI.Sprite | SpriteMesh);
+
+  /**
+   * Create a render texture, provide a render method and an optional clear color.
+   * @param options - Optional parameters.
+   * @returns A reference to the created render texture.
+   */
+  createRenderTexture(options?: CachedContainer.RenderOptions): PIXI.RenderTexture;
+
+  /**
+   * Remove a previously created render texture.
+   * @param renderTexture - The render texture to remove.
+   * @param destroy - Should the render texture be destroyed?
+   *                  (default: `true`)
+   */
+  removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean | null): void;
+
+  /**
+   * Clear the cached container, removing its current contents.
+   * @param destroy - Tell children that we should destroy texture as well.
+   * @returns A reference to the cleared container for chaining.
+   * @remarks Added possibility of void return due to child classes
+   */
+  clear(destroy?: boolean): CachedContainer | void;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+  override render(renderer: PIXI.Renderer): void;
+
+  /**
+   * Resize a render texture passed as a parameter with the renderer.
+   * @param renderer - The active canvas renderer.
+   * @param rt       - The render texture to resize.
+   */
+  static resizeRenderTexture(renderer: PIXI.Renderer, rt: PIXI.RenderTexture): void;
+}
+
+declare namespace CachedContainer {
+  interface Any extends AnyCachedContainer {}
+  interface AnyConstructor extends Identity<typeof AnyCachedContainer> {}
+
+  /** @internal */
+  type _TextureConfiguration = NullishProps<{
+    multisample: PIXI.MSAA_QUALITY;
+    scaleMode: PIXI.SCALE_MODES;
+    format: PIXI.FORMATS;
+
+    /** @remarks Only exists on DarknessLevelContainer and is seemingly unused there */
+    mipmap: PIXI.MIPMAP_MODES;
+  }>;
+
+  interface TextureConfiguration extends _TextureConfiguration {}
+
+  /** @internal */
+  type _RenderOptions = NullishProps<{
+    /** Render function that will be called to render into the RT. */
+    renderFunction: (renderer: PIXI.Renderer) => void;
+
+    /** An optional clear color to clear the RT before rendering into it. */
+    clearColor: Color.RGBAColorVector;
+  }>;
+  interface RenderOptions extends _RenderOptions {}
+}
+
+export default CachedContainer;
+
+declare abstract class AnyCachedContainer extends CachedContainer {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/advanced/full-canvas-mixin.d.mts

@@ -0,0 +1,28 @@
+import type { FixedInstanceType, Mixin } from "#utils";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class FullCanvasObject {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /** @remarks Overrides the mixed PIXI class's method, @see {@link PIXI.DisplayObject.calculateBounds | `PIXI.DisplayObject#calculateBounds`} */
+  calculateBounds(): void;
+}
+
+/**
+ * Augment any PIXI.DisplayObject to assume bounds that are always aligned with the full visible screen.
+ * The bounds of this container do not depend on its children but always fill the entire canvas.
+ * @param Base - Any PIXI DisplayObject subclass
+ */
+declare function FullCanvasObjectMixin<BaseClass extends FullCanvasObjectMixin.BaseClass>(
+  Base: BaseClass,
+): Mixin<typeof FullCanvasObject, BaseClass>;
+
+declare namespace FullCanvasObjectMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof FullCanvasObjectMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type BaseClass = PIXI.DisplayObject.AnyConstructor;
+}
+
+export default FullCanvasObjectMixin;

package/src/foundry/client/canvas/containers/advanced/unbound-container.d.mts

@@ -0,0 +1,21 @@
+import type { Identity } from "#utils";
+import type { UnboundTransform } from "#client/canvas/geometry/_module.d.mts";
+
+/**
+ * UnboundContainers behave like PIXI.Containers except that they are not bound to their parent's transforms.
+ * However, they normally propagate their own transformations to their children.
+ */
+declare class UnboundContainer extends PIXI.Container {
+  transform: UnboundTransform;
+}
+
+declare namespace UnboundContainer {
+  interface Any extends AnyUnboundContainer {}
+  interface AnyConstructor extends Identity<typeof AnyUnboundContainer> {}
+}
+
+export default UnboundContainer;
+
+declare abstract class AnyUnboundContainer extends UnboundContainer {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/control-icon.d.mts

@@ -0,0 +1,129 @@
+import type { Identity, InexactPartial } from "#utils";
+import { PreciseText } from "#client/canvas/containers/_module.mjs";
+
+/**
+ * A generic helper for drawing a standard Control Icon
+ */
+declare class ControlIcon extends PIXI.Container {
+  /**
+   * @remarks
+   * - Despite being an `={}` param, `options` is required (specifically its `texture` property)
+   * - Foundry adds a `...args` rest param after `options` and calls `super(...args)`, but `new PIXI.Container()` takes no arguments
+   */
+  constructor(options: ControlIcon.Options);
+
+  iconSrc: string;
+
+  size: number;
+
+  rect: [number, number, number, number];
+
+  borderColor: number;
+
+  /**
+   * The color of the icon tint, if any
+   */
+  tintColor: number | null;
+
+  /**
+   * @defaultValue `static`
+   */
+  override eventMode: PIXI.EventMode;
+
+  /**
+   * @defaultValue `false`
+   */
+  override interactiveChildren: boolean;
+
+  override hitArea: PIXI.Rectangle;
+
+  override cursor: string;
+
+  bg: PIXI.Graphics;
+
+  icon: PIXI.Sprite;
+
+  border: PIXI.Graphics;
+
+  tooltip: PreciseText;
+
+  /**
+   * The elevation of the ControlIcon, which is displayed in its tooltip text.
+   * @throws If a set is attempted with anything but a finite number
+   */
+  get elevation(): number;
+
+  set elevation(value);
+
+  /**
+   * Initial drawing of the ControlIcon
+   */
+  draw(): Promise<this>;
+
+  /**
+   * Incremental refresh for ControlIcon appearance.
+   */
+  refresh({ visible, iconColor, borderColor, borderVisible }?: ControlIcon.RefreshOptions): this;
+}
+
+declare namespace ControlIcon {
+  interface Any extends AnyControlIcon {}
+  interface AnyConstructor extends Identity<typeof AnyControlIcon> {}
+
+  /** @internal */
+  type _Options = InexactPartial<{
+    /**
+     * @defaultValue `40`
+     * @remarks Can't be `null` as it only has a parameter default, and `null` coerced to `0` is a nonsensical size value
+     */
+    size: number;
+
+    /**
+     * @defaultValue `0xFF5500`
+     * @remarks Can't be `null` as that's not a valid value for the `PIXI.Color` constructor,
+     * and it only has a parameter default
+     */
+    borderColor: number;
+
+    /**
+     * @defaultValue `null`
+     * @remarks The default value of `null` is equivalent to `0xFFFFFF`, or effectively no tint
+     */
+    tint: number | null;
+
+    /**
+     * @defaultValue `number`
+     * @remarks Can't be null as the `ControlIcon#elevation` setter throws if passed anything but a finite number,
+     * and it only has a parameter default
+     */
+    elevation: number;
+  }>;
+
+  interface Options extends _Options {
+    /** A source string for the icon's texture */
+    texture: string;
+  }
+
+  /** @internal */
+  type _RefreshOptions = InexactPartial<{
+    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
+    visible: boolean;
+
+    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
+    iconColor: number;
+
+    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
+    borderColor: number;
+
+    /** @remarks Can't be `null` because of an explicit `!== undefined` check */
+    borderVisible: boolean;
+  }>;
+
+  interface RefreshOptions extends _RefreshOptions {}
+}
+
+export default ControlIcon;
+
+declare abstract class AnyControlIcon extends ControlIcon {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/cursor.d.mts

@@ -0,0 +1,42 @@
+import type { Identity } from "#utils";
+
+/**
+ * A single Mouse Cursor
+ */
+declare class Cursor extends PIXI.Container {
+  constructor(user: User.Implementation);
+
+  /**
+   * @defaultValue `{x: 0, y: 0}`
+   */
+  target: PIXI.IPointData;
+
+  /**
+   * Update visibility and animations
+   * @param user - The user
+   */
+  refreshVisibility(user: User.Implementation): void;
+
+  /**
+   * Draw the user's cursor as a small dot with their user name attached as text
+   */
+  draw(user: User.Implementation): void;
+
+  /**
+   * Move an existing cursor to a new position smoothly along the animation loop
+   */
+  protected _animate(): void;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+}
+
+declare namespace Cursor {
+  interface Any extends AnyCursor {}
+  interface AnyConstructor extends Identity<typeof AnyCursor> {}
+}
+
+export default Cursor;
+
+declare abstract class AnyCursor extends Cursor {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/door-control.d.mts

@@ -0,0 +1,90 @@
+import type { FixedInstanceType, Identity } from "#utils";
+import type { Wall } from "#client/canvas/placeables/_module.d.mts";
+
+/**
+ * An icon representing a Door Control
+ */
+declare class DoorControl extends PIXI.Container {
+  constructor(wall: Wall.Implementation);
+
+  wall: Wall.Implementation;
+
+  /**
+   * @defaultValue `false`
+   * @remarks "Door controls are not visible by default"
+   */
+  override visible: boolean;
+
+  /**
+   * The center of the wall which contains the door.
+   */
+  get center(): PIXI.Point;
+
+  /**
+   * Draw the DoorControl icon, displaying its icon texture and border
+   */
+  draw(): Promise<this>;
+
+  /** @remarks Not initialized or even defined until set in {@link DoorControl#draw} */
+  bg?: PIXI.Graphics;
+
+  /** @remarks Not initialized or even defined until set in {@link DoorControl#draw} */
+  icon?: PIXI.Sprite;
+
+  /** @remarks Not initialized or even defined until set in {@link DoorControl#draw} */
+  border?: PIXI.Graphics;
+
+  /**
+   * Get the icon texture to use for the Door Control icon based on the door state
+   */
+  protected _getTexture(): foundry.canvas.loadTexture.Return;
+
+  reposition(): void;
+
+  /**
+   * Determine whether the DoorControl is visible to the calling user's perspective.
+   * The control is always visible if the user is a GM and no Tokens are controlled.
+   * @see {@link foundry.canvas.groups.CanvasVisibility.testVisibility | `CanvasVisibility#testVisibility`}
+   */
+  get isVisible(): boolean;
+
+  /**
+   * Handle mouse over events on a door control icon.
+   * @param event - The originating interaction event
+   */
+  protected _onMouseOver(event: PIXI.FederatedEvent<PointerEvent>): false | void;
+
+  /**
+   * Handle mouse out events on a door control icon.
+   * @param event - The originating interaction event
+   */
+  protected _onMouseOut(event: PIXI.FederatedEvent<PointerEvent>): false | void;
+
+  /**
+   * Handle left mouse down events on a door control icon.
+   * This should only toggle between the OPEN and CLOSED states.
+   * @param event - The originating interaction event
+   */
+  protected _onMouseDown(event: PIXI.FederatedEvent<PointerEvent>): false | void | Promise<WallDocument.Implementation>;
+
+  /**
+   * Handle right mouse down events on the door control icon
+   * This should toggle whether the door is LOCKED or CLOSED
+   * @param event - The originating interaction event
+   */
+  protected _onRightDown(event: PIXI.FederatedEvent<PointerEvent>): void | Promise<WallDocument.Implementation>;
+}
+
+declare namespace DoorControl {
+  interface Any extends AnyDoorControl {}
+  interface AnyConstructor extends Identity<typeof AnyDoorControl> {}
+
+  type ConfiguredClass = CONFIG["Canvas"]["doorControlClass"];
+  type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+}
+
+export default DoorControl;
+
+declare abstract class AnyDoorControl extends DoorControl {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/door-mesh.d.mts

@@ -0,0 +1,16 @@
+import type { Identity } from "#utils";
+import type { PrimarySpriteMesh } from "#client/canvas/primary/_module.d.mts";
+
+// TODO: whole class
+declare class DoorMesh extends PrimarySpriteMesh {}
+
+declare namespace DoorMesh {
+  interface Any extends AnyDoorMesh {}
+  interface AnyConstructor extends Identity<typeof AnyDoorMesh> {}
+}
+
+export default DoorMesh;
+
+declare abstract class AnyDoorMesh {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/grid-highlight.d.mts

@@ -0,0 +1,43 @@
+import type { Identity } from "#utils";
+
+/**
+ * A special Graphics class which handles Grid layer highlighting
+ */
+declare class GridHighlight extends PIXI.Graphics {
+  constructor(name: string, ...args: ConstructorParameters<typeof PIXI.Graphics>);
+
+  /**
+   * Track the Grid Highlight name
+   */
+  name: string;
+
+  /**
+   * Track distinct positions which have already been highlighted
+   */
+  positions: Set<GridHighlight.PositionString>;
+
+  /**
+   * Record a position that is highlighted and return whether or not it should be rendered
+   * @param x - The x-coordinate to highlight
+   * @param y - The y-coordinate to highlight
+   * @returns Whether or not to draw the highlight for this location
+   */
+  highlight(x: number, y: number): boolean;
+
+  override clear(): this;
+
+  override destroy(options?: PIXI.IDestroyOptions | boolean): void;
+}
+
+declare namespace GridHighlight {
+  interface Any extends AnyGridHighlight {}
+  interface AnyConstructor extends Identity<typeof AnyGridHighlight> {}
+
+  type PositionString = `${number},${number}`;
+}
+
+export default GridHighlight;
+
+declare abstract class AnyGridHighlight extends GridHighlight {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/containers/elements/grid-mesh.d.mts

@@ -0,0 +1,103 @@
+import type { Identity, InexactPartial } from "#utils";
+import type { GridShader } from "#client/canvas/rendering/shaders/_module.d.mts";
+import { QuadMesh } from "#client/canvas/containers/_module.mjs";
+
+/**
+ * The grid mesh, which uses the {@linkcode GridShader} to render the grid.
+ */
+declare class GridMesh extends QuadMesh {
+  /**
+   * The grid mesh constructor.
+   * @param shaderClass - The shader class
+   */
+  constructor(shaderClass: GridShader.AnyConstructor);
+
+  /**
+   * The data of this mesh.
+   * @defaultValue
+   * ```js
+   * {
+   *   type: CONST.GRID_TYPES.GRIDLESS,
+   *   width: 0,
+   *   height: 0,
+   *   size: 0,
+   *   thickness: 1,
+   *   color: 0,
+   *   alpha: 1
+   * }
+   * ```
+   */
+  data: GridMesh.MeshData;
+
+  /**
+   * Initialize and update the mesh given the (partial) data.
+   * @param data - The (partial) data
+   */
+  initialize(data: GridMesh.InitializationMeshData): this;
+
+  /**
+   * Initialize the data of this mesh given the (partial) data.
+   * @param data - The (partial) data.
+   */
+  protected _initialize(data: GridMesh.InitializationMeshData): void;
+}
+
+declare namespace GridMesh {
+  interface Any extends AnyGridMesh {}
+  interface AnyConstructor extends Identity<typeof AnyGridMesh> {}
+
+  /**
+   * The grid mesh data.
+   */
+  interface MeshData {
+    /**
+     * The type of the grid (see {@linkcode CONST.GRID_TYPES})
+     * @defaultValue `CONST.GRID_TYPES.GRIDLESS`
+     */
+    type: foundry.CONST.GRID_TYPES;
+
+    /**
+     * The width of the grid in pixels
+     * @defaultValue `0`
+     */
+    width: number;
+
+    /**
+     * The height of the grid in pixels
+     * @defaultValue `0`
+     */
+    height: number;
+
+    /**
+     * The size of a grid space in pixels
+     * @defaultValue `0`
+     */
+    size: number;
+
+    /**
+     * The thickness of the grid lines in pixels
+     * @defaultValue `1`
+     */
+    thickness: number;
+
+    /**
+     * The color of the grid
+     * @defaultValue `0`
+     */
+    color: number;
+
+    /**
+     * The alpha of the grid
+     * @defaultValue `1`
+     */
+    alpha: number;
+  }
+
+  interface InitializationMeshData extends InexactPartial<MeshData> {}
+}
+
+export default GridMesh;
+
+declare abstract class AnyGridMesh extends GridMesh {
+  constructor(...args: never);
+}