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

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-canvas-object.d.mts

@@ -0,0 +1,177 @@
+import type { Mixin } from "../../../../../types/utils.d.mts";
+import type Document from "../../../../common/abstract/document.d.mts";
+
+declare class PrimaryCanvasObject {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * An optional reference to the object that owns this PCO.
+   * This property does not affect the behavior of the PCO itself.
+   * @defaultValue `null`
+   */
+  object: PlaceableObject | null;
+
+  /**
+   * The elevation of this object.
+   * @defaultValue `0`
+   */
+  get elevation(): number;
+
+  set elevation(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation within the same layer.
+   */
+  get sort(): number;
+
+  set sort(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation of different layers.
+   */
+  get sortLayer(): number;
+
+  set sortLayer(value);
+
+  /**
+   * A key which resolves ties amongst objects at the same elevation within the same layer and same sort.
+   */
+  get zIndex(): number;
+
+  set zIndex(value);
+
+  /**
+   * Event fired when this display object is added to a parent.
+   * @param parent - The new parent container.
+   */
+  protected _onAdded(parent: PIXI.Container): void;
+
+  /**
+   * Event fired when this display object is removed from its parent.
+   * @param parent - Parent from which the PCO is removed.
+   */
+  protected _onRemoved(parent: PIXI.Container): void;
+
+  updateCanvasTransform(): void;
+
+  _onCanvasBoundsUpdate(): void;
+
+  /**
+   * Does this object render to the depth buffer?
+   */
+  get shouldRenderDepth(): boolean;
+
+  /**
+   * Does this object render to the depth buffer?
+   */
+  _shouldRenderDepth(): boolean;
+
+  /**
+   * Render the depth of this object.
+   */
+  renderDepthData(renderer: PIXI.Renderer): void;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks `"PrimaryCanvasObject#renderOcclusion is deprecated in favor of PrimaryCanvasObject#renderDepthData"`
+   */
+  renderOcclusion(renderer: PIXI.Renderer): void;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"PrimaryCanvasObject#document is deprecated."`
+   */
+  get document(): Document.Any | null;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   * @remarks `"PrimaryCanvasObject#updateBounds is deprecated and has no effect."`
+   */
+  updateBounds(): void;
+}
+
+declare class CanvasTransformMixinClass {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * The transform matrix from local space to canvas space.
+   */
+  canvasTransform: PIXI.Matrix;
+
+  /**
+   * The update ID of canvas transform matrix.
+   */
+  protected _canvasTransformID: number;
+
+  /**
+   * The canvas bounds of this object.
+   */
+  canvasBounds: PIXI.Rectangle;
+
+  /**
+   * The canvas bounds of this object.
+   */
+  protected _canvasBounds: PIXI.Bounds;
+
+  /**
+   * The update ID of the canvas bounds.
+   * Increment to force recalculation.
+   */
+  protected _canvasBoundsID: number;
+
+  /**
+   * Calculate the canvas bounds of this object.
+   */
+  protected _calculateCanvasBounds(): void;
+
+  /**
+   * Recalculate the canvas transform and bounds of this object and its children, if necessary.
+   */
+  updateCanvasTransform(): void;
+
+  /**
+   * Called when the canvas transform changed.
+   */
+  protected _onCanvasTransformUpdate(): void;
+
+  /**
+   * Called when the canvas bounds changed.
+   */
+  protected _onCanvasBoundsUpdate(): void;
+
+  /**
+   * Is the given point in canvas space contained in this object?
+   * @param point - The point in canvas space.
+   */
+  containsCanvasPoint(point: PIXI.IPointData): boolean;
+}
+
+declare global {
+  /**
+   * A mixin which decorates a DisplayObject with additional properties expected for rendering in the PrimaryCanvasGroup.
+   * @param DisplayObject - The parent DisplayObject class being mixed
+   * @returns A DisplayObject subclass mixed with PrimaryCanvasObject features
+   */
+  function PrimaryCanvasObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+    DisplayObject: BaseClass,
+  ): Mixin<typeof PrimaryCanvasObject, ReturnType<typeof CanvasTransformMixin<BaseClass>>>;
+
+  namespace PrimaryCanvasObjectMixin {
+    type MixinClass = typeof PrimaryCanvasObject;
+  }
+
+  /**
+   * A mixin which decorates a DisplayObject with additional properties for canvas transforms and bounds.
+   * @param DisplayObject - The parent DisplayObject class being mixed
+   * @returns A DisplayObject subclass mixed with CanvasTransformMixin features
+   */
+  function CanvasTransformMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+    DisplayObject: BaseClass,
+  ): Mixin<typeof CanvasTransformMixinClass, BaseClass>;
+
+  namespace CanvasTransformMixin {
+    type MixinClass = typeof CanvasTransformMixinClass;
+  }
+}

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-graphics.d.mts

@@ -0,0 +1,30 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A basic PCO which is handling drawings of any shape.
+   */
+  class PrimaryGraphics extends PrimaryCanvasObjectMixin(PIXI.Graphics) {
+    /**
+     * @param options - A config object
+     */
+    constructor(
+      options?: InexactPartial<{
+        /** A geometry passed to the graphics. */
+        geometry: PIXI.GraphicsGeometry;
+
+        /** The name of the PCO. */
+        name: string;
+
+        /** Any object that owns this PCO. */
+        object: PlaceableObject;
+      }>,
+    );
+
+    override _calculateCanvasBounds(): void;
+
+    override updateCanvasTransform(): void;
+
+    override containsCanvasPoint(point: PIXI.IPointData): boolean;
+  }
+}

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-occludable-object.d.mts

@@ -0,0 +1,161 @@
+import type { InexactPartial, Mixin } from "../../../../../types/utils.d.mts";
+
+declare class PrimaryOccludableObject {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * Is this occludable object hidden for Gamemaster visibility only?
+   * @defaultValue `false`
+   */
+  hidden: boolean;
+
+  /**
+   * A flag which tracks whether the primary canvas object is currently in an occluded state.
+   * @defaultValue `false`
+   */
+  occluded: boolean;
+
+  /**
+   * The occlusion mode of this occludable object.
+   * @defaultValue `CONST.OCCLUSION_MODES.NONE`
+   */
+  occlusionMode: typeof CONST.OCCLUSION_MODES;
+
+  /**
+   * The unoccluded alpha of this object.
+   * @defaultValue `1`
+   */
+  unoccludedAlpha: number;
+
+  /**
+   * The occlusion alpha of this object.
+   * @defaultValue `0`
+   */
+  occludedAlpha: number;
+
+  /**
+   * Fade this object on hover?
+   * @defaultValue `true`
+   */
+  get hoverFade(): boolean;
+
+  set hoverFade(value);
+
+  /**
+   * The amount of rendered FADE, RADIAL, and VISION occlusion.
+   */
+  protected _occlusionState: PrimaryOccludableObjectMixin.OcclusionState;
+
+  /**
+   * The state of hover-fading.
+   */
+  protected _hoverFadeState: PrimaryOccludableObjectMixin.HoverFadeState;
+
+  /**
+   * Get the blocking option bitmask value.
+   */
+  protected get _restrictionState(): number;
+
+  /**
+   * Is this object blocking light?
+   */
+  get restrictsLight(): boolean;
+
+  set restrictsLight(enabled);
+
+  /**
+   * Is this object blocking weather?
+   */
+  get restrictsWeather(): boolean;
+
+  set restrictsWeather(enabled);
+
+  /**
+   * Is this occludable object... occludable?
+   */
+  get isOccludable(): boolean;
+
+  /**
+   * Debounce assignment of the PCO occluded state to avoid cases like animated token movement which can rapidly
+   * change PCO appearance.
+   * Uses a 50ms debounce threshold.
+   * Objects which are in the hovered state remain occluded until their hovered state ends.
+   */
+  debounceSetOcclusion: (occluded: boolean) => void;
+
+  updateCanvasTransform(): void;
+
+  _shouldRenderDepth: boolean;
+
+  /**
+   * Test whether a specific Token occludes this PCO.
+   * Occlusion is tested against 9 points, the center, the four corners-, and the four cardinal directions
+   * @param token   - The Token to test
+   * @param options - Additional options that affect testing
+   * @returns Is the Token occluded by the PCO?
+   */
+  testOcclusion(
+    token: Token,
+    options?: InexactPartial<{
+      /** Test corners of the hit-box in addition to the token center? */
+      corners: boolean;
+    }>,
+  ): boolean;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   */
+  get roof(): boolean;
+
+  /**
+   * @deprecated since v12, will be removed in v14
+   */
+  containsPixel(x: number, y: number, alphaThreshold: number): boolean;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   */
+  renderOcclusion(renderer: PIXI.Renderer): void;
+}
+
+declare global {
+  function PrimaryOccludableObjectMixin<BaseClass extends PIXI.DisplayObject.AnyConstructor>(
+    DisplayObject: BaseClass,
+  ): Mixin<typeof PrimaryOccludableObject, ReturnType<typeof PrimaryCanvasObjectMixin<BaseClass>>>;
+
+  namespace PrimaryOccludableObjectMixin {
+    type MixinClass = typeof PrimaryOccludableObject;
+
+    interface OcclusionState {
+      /** The amount of FADE occlusion */
+      fade: number;
+
+      /** The amount of RADIAL occlusion */
+      radial: number;
+
+      /** The amount of VISION occlusion */
+      vision: number;
+    }
+
+    interface HoverFadeState {
+      /** The hovered state */
+      hovered: boolean;
+
+      /** The last time when a mouse event was hovering this object */
+      hoveredTime: number;
+
+      /** The faded state */
+      faded: boolean;
+
+      /** The fading state */
+      fading: boolean;
+
+      /** The time the fade animation started */
+      fadingTime: number;
+
+      /** The amount of occlusion */
+      occlusion: number;
+    }
+  }
+}

package/src/foundry/client/pixi/placeables/primary-canvas-objects/primary-sprite-mesh.d.mts

@@ -0,0 +1,111 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+// TODO: Remove when #2570 is completed
+declare const PrimaryBaseSamplerShader: BaseSamplerShader;
+
+declare namespace PrimaryBaseSamplerShader {
+  type AnyConstructor = unknown;
+}
+
+declare global {
+  /**
+   * A basic PCO sprite mesh which is handling occlusion and depth.
+   */
+  class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
+    constructor(
+      options?:
+        | InexactPartial<{
+            /** Texture passed to the SpriteMesh. */
+            texture: PIXI.Texture;
+
+            /** The shader class used to render this sprite. */
+            shaderClass: PrimaryBaseSamplerShader.AnyConstructor;
+
+            /** The name of this sprite. */
+            name: string;
+          }>
+        | PIXI.Texture,
+      shaderClass?: PrimaryBaseSamplerShader.AnyConstructor,
+    );
+
+    /**
+     * The texture alpha data.
+     */
+    _textureAlphaData: TextureLoader.TextureAlphaData | null;
+
+    /**
+     * The texture alpha threshold used for point containment tests.
+     * If set to a value larger than 0, the texture alpha data is
+     * extracted from the texture at 25% resolution.
+     */
+    textureAlphaThreshold: number;
+
+    override _onTextureUpdate(): void;
+
+    override setShaderClass(shaderClass: PrimaryBaseSamplerShader.AnyConstructor): void;
+
+    /**
+     * An all-in-one helper method: Resizing the PCO according to desired dimensions and options.
+     * This helper computes the width and height based on the following factors:
+     *
+     * - The ratio of texture width and base width.
+     * - The ratio of texture height and base height.
+     *
+     * Additionally, It takes into account the desired fit options:
+     *
+     * - (default) "fill" computes the exact width and height ratio.
+     * - "cover" takes the maximum ratio of width and height and applies it to both.
+     * - "contain" takes the minimum ratio of width and height and applies it to both.
+     * - "width" applies the width ratio to both width and height.
+     * - "height" applies the height ratio to both width and height.
+     *
+     * You can also apply optional scaleX and scaleY options to both width and height. The scale is applied after fitting.
+     *
+     * **Important**: By using this helper, you don't need to set the height, width, and scale properties of the DisplayObject.
+     *
+     * **Note**: This is a helper method. Alternatively, you could assign properties as you would with a PIXI DisplayObject.
+     * @param baseWidth  - The base width used for computations.
+     * @param baseHeight - The base height used for computations.
+     * @param options    - The options.
+     */
+    resize(
+      baseWidth: number,
+      baseHeight: number,
+      options?: InexactPartial<{
+        /** The fit type. */
+        fit: "fill" | "cover" | "contain" | "width" | "height";
+
+        /** The scale on X axis. */
+        scaleX: number;
+
+        /** The scale on Y axis. */
+        scaleY: number;
+      }>,
+    ): void;
+
+    protected override _updateBatchData(): void;
+
+    protected override _calculateCanvasBounds(): void;
+
+    /**
+     * Is the given point in canvas space contained in this object?
+     * @param point                 - The point in canvas space
+     * @param textureAlphaThreshold - The minimum texture alpha required for containment
+     */
+    containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+
+    override renderDepthData(renderer: PIXI.Renderer): void;
+
+    /**
+     * Render the sprite with ERASE blending.
+     * Note: The sprite must not have visible/renderable children.
+     * @param renderer - The renderer
+     */
+    protected _renderVoid(renderer: PIXI.Renderer): void;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     */
+    getPixelAlpha(x: number, y: number): number;
+  }
+}

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

@@ -0,0 +1,134 @@
+import type Sound from "../../../client-esm/audio/sound.d.mts";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace AmbientSound {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientSound>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshField: boolean;
+
+      refreshPosition: boolean;
+    }
+
+    interface SyncOptions {
+      /**
+       * A duration in milliseconds to fade volume transition
+       * @defaultValue `250`
+       */
+      fade: number;
+    }
+
+    interface UpdateSourceOptions {
+      /**
+       * Defer refreshing the SoundsLayer to manually call that refresh later.
+       * @defaultValue `false`
+       */
+      defer?: boolean | undefined;
+
+      /**
+       * Indicate that this SoundSource has been deleted.
+       * @defaultValue `false`
+       */
+      deleted?: boolean | undefined;
+    }
+  }
+
+  /**
+   * An AmbientSound is an implementation of PlaceableObject which represents a dynamic audio source within the Scene.
+   * @see {@link AmbientSoundDocument}
+   * @see {@link SoundsLayer}
+   */
+  class AmbientSound extends PlaceableObject<AmbientSoundDocument.ConfiguredInstance> {
+    constructor(document: AmbientSoundDocument.ConfiguredInstance);
+
+    /**
+     * The Sound which manages playback for this AmbientSound effect
+     */
+    sound: Sound | null;
+
+    /**
+     * A SoundSource object which manages the area of effect for this ambient sound
+     */
+    source: foundry.canvas.sources.PointSoundSource;
+
+    static override embeddedName: "AmbientSound";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
+      refresh: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
+      refreshField: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshPosition: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<Partial<AmbientSound.RenderFlags>>;
+    };
+
+    /**
+     * Is this ambient sound is currently audible based on its hidden state and the darkness level of the Scene?
+     */
+    get isAudible(): boolean;
+
+    override get bounds(): PIXI.Rectangle;
+
+    /**
+     * The named identified for the source object associated with this ambient sound
+     */
+    get sourceId(): string;
+
+    /**
+     * A convenience accessor for the sound radius in pixels
+     */
+    get radius(): number;
+
+    /**
+     * Toggle playback of the sound depending on whether or not it is audible
+     * @param isAudible - Is the sound audible?
+     * @param volume    - The target playback volume
+     * @param options   - Additional options which affect sound synchronization
+     */
+    sync(isAudible: boolean, volume: number, options?: Partial<AmbientSound.SyncOptions>): void;
+
+    override clear(): this;
+
+    protected override _draw(): Promise<void>;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    protected _applyRenderFlags(flags: AmbientSound.RenderFlags): void;
+
+    /**
+     * Refresh the display of the ControlIcon for this AmbientSound source
+     */
+    refreshControl(): void;
+
+    /**
+     * Compute the field-of-vision for an object, determining its effective line-of-sight and field-of-vision polygons
+     * @param options - (default: `{}`)
+     */
+    updateSource(options?: AmbientSound.UpdateSourceOptions): void;
+
+    /**
+     * @privateRemarks _onCreate, _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.
+     */
+
+    protected override _canHUD(user: User.ConfiguredInstance, event?: any): boolean;
+
+    protected override _canConfigure(user: User.ConfiguredInstance, event?: any): boolean;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragEnd(): void;
+  }
+}