@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 13.340.0

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

@@ -1,9 +1,10 @@
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
   namespace Tile {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Tile>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshShape: boolean;
@@ -71,31 +72,31 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Tile.RenderFlags>>;
+      redraw: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshShape", "refreshElevation", "refreshVideo"], alias: true }` */
-      refresh: RenderFlag<Partial<Tile.RenderFlags>>;
+      refresh: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshFrame"] }` */
-      refreshState: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshState: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshPerception", "refreshFrame"] }` */
-      refreshShape: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshShape: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshMesh: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshMesh: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshFrame: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshFrame: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh"] }` */
-      refreshElevation: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshElevation: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshPerception: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshPerception: RenderFlag<Tile.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshVideo: RenderFlag<Partial<Tile.RenderFlags>>;
+      refreshVideo: RenderFlag<Tile.RenderFlags>;
     };
 
     /**
@@ -207,6 +208,7 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;

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

@@ -1,10 +1,22 @@
-import type { RequiredProps } from "../../../../types/utils.d.mts";
+import type { NullishProps, RequiredProps, FixedInstanceType } from "fvtt-types/utils";
+import type BaseToken from "../../../common/documents/token.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace Token {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Token>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
+
+    type Schema = BaseToken.Schema;
+    type Parent = BaseToken.Parent;
+
+    type Metadata = BaseToken.Metadata;
+
+    type SchemaField = BaseToken.SchemaField;
+    type ConstructorData = BaseToken.ConstructorData;
+    type UpdateData = BaseToken.UpdateData;
+    type Properties = BaseToken.Properties;
+    type Source = BaseToken.Source;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       redrawEffects: boolean;
@@ -214,6 +226,110 @@ declare global {
       /** @defaultValue `false` */
       pan?: boolean;
     }
+
+    interface AnimationContext {
+      /** The name of the animation */
+      name: string | symbol;
+
+      /** The final animation state */
+      to: NullishProps<Token.AnimationData>;
+
+      /** The duration of the animation */
+      duration: number;
+
+      /** The current time of the animation */
+      time: number;
+
+      /** Asynchronous functions that are executed before the animation starts */
+      preAnimate: ((context: Token.AnimationContext) => Promise<void>)[];
+
+      /** Synchronous functions that are executed after the animation ended */
+      postAnimate: ((context: Token.AnimationContext) => void)[];
+
+      /** Synchronous functions that are executed each frame after `ontick` and before {@link Token#_onAnimationUpdate} */
+      onAnimate: ((context: Token.AnimationContext) => void)[];
+
+      /**
+       * The promise of the animation, which resolves to true if the animation
+       * completed, to false if it was terminated, and rejects if an error occurred.
+       * Undefined in the first frame (at time 0) of the animation.
+       */
+      promise?: Promise<boolean> | undefined;
+    }
+
+    /**
+     * The texture data for a token animation.
+     */
+    interface TextureData {
+      /** The texture file path. */
+      src: string;
+
+      /** The texture anchor X. */
+      anchorX: number;
+
+      /** The texture anchor Y. */
+      anchorY: number;
+
+      /** The texture scale X. */
+      scaleX: number;
+
+      /** The texture scale Y. */
+      scaleY: number;
+
+      /** The texture tint. */
+      tint: Color;
+    }
+
+    /**
+     * The ring subject data.
+     */
+    interface RingSubjectData {
+      /** The ring subject texture. */
+      texture: string;
+
+      /** The ring subject scale. */
+      scale: number;
+    }
+
+    /**
+     * The ring data.
+     */
+    interface RingData {
+      /** The ring subject data. */
+      subject: RingSubjectData;
+    }
+
+    /**
+     * Token animation data.
+     */
+    interface AnimationData {
+      /** The x position in pixels. */
+      x: number;
+
+      /** The y position in pixels. */
+      y: number;
+
+      /** The width in grid spaces. */
+      width: number;
+
+      /** The height in grid spaces. */
+      height: number;
+
+      /** The alpha value. */
+      alpha: number;
+
+      /** The rotation in degrees. */
+      rotation: number;
+
+      /** The texture data. */
+      texture: TextureData;
+
+      /** The ring data. */
+      ring: RingData;
+
+      /** The elevation in grid units */
+      elevation?: number | undefined;
+    }
   }
 
   /**
@@ -226,49 +342,49 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Token.RenderFlags>>;
+      redraw: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      redrawEffects: RenderFlag<Partial<Token.RenderFlags>>;
+      redrawEffects: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshSize", "refreshPosition", "refreshElevation", "refreshBars", "refreshNameplate", "refreshBorder", "refreshShader"], alias: true }` */
-      refresh: RenderFlag<Partial<Token.RenderFlags>>;
+      refresh: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshVisibility", "refreshBorder"] }` */
-      refreshState: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshState: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshBorder", "refreshBars", "refreshPosition", "refreshTarget", "refreshEffects"] }` */
-      refreshSize: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshSize: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh", "refreshVisibility"] }` */
-      refreshPosition: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshPosition: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshMesh"] }` */
-      refreshElevation: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshElevation: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshVisibility: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshVisibility: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshEffects: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshEffects: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshMesh: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshMesh: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshShader: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshShader: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshBars: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshBars: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshNameplate: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshNameplate: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshBorder: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshBorder: RenderFlag<Token.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshTarget: RenderFlag<Partial<Token.RenderFlags>>;
+      refreshTarget: RenderFlag<Token.RenderFlags>;
     };
 
     /**
@@ -302,6 +418,11 @@ declare global {
      */
     light: foundry.canvas.sources.PointLightSource;
 
+    /**
+     * The current animations of this Token.
+     */
+    get animationContexts(): Map<string, Token.AnimationContext>;
+
     /**
      * A reference to an animation that is currently in progress for this Token, if any
      * @internal
@@ -573,6 +694,12 @@ declare global {
      */
     protected _drawEffect(src: string, tint: number | null): Promise<PIXI.Sprite | undefined>;
 
+    /**
+     * Draw the effect icons for ActiveEffect documents which apply to the Token's Actor.
+     * Called by {@link Token#drawEffects}.
+     */
+    protected _drawEffects(): Promise<void>;
+
     /**
      * Draw the overlay effect icon
      */
@@ -742,6 +869,7 @@ declare global {
 
     protected override _onControl(options?: Token.ControlOptions): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onRelease(
       options: PlaceableObject.ReleaseOptions,
     ): Promise<TokenDocument.ConfiguredInstance> | undefined;
@@ -768,7 +896,8 @@ declare global {
 
     protected override _onClickRight2(event: PIXI.FederatedEvent): void;
 
-    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<any>;
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 

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

@@ -1,10 +1,11 @@
+import type { FixedInstanceType } from "fvtt-types/utils";
 import type { LineIntersection } from "../../../common/utils/geometry.d.mts";
 import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
 
 declare global {
   namespace Wall {
     type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Wall>;
-    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+    type ConfiguredInstance = FixedInstanceType<ConfiguredClass>;
 
     interface RenderFlags extends PlaceableObject.RenderFlags {
       refreshLine: boolean;
@@ -37,25 +38,25 @@ declare global {
 
     static override RENDER_FLAGS: {
       /** @defaultValue `{ propagate: ["refresh"] }` */
-      redraw: RenderFlag<Partial<Wall.RenderFlags>>;
+      redraw: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
-      refresh: RenderFlag<Partial<Wall.RenderFlags>>;
+      refresh: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
-      refreshState: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshState: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
-      refreshLine: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshLine: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshEndpoints: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshEndpoints: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshDirection: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshDirection: RenderFlag<Wall.RenderFlags>;
 
       /** @defaultValue `{}` */
-      refreshHighlight: RenderFlag<Partial<Wall.RenderFlags>>;
+      refreshHighlight: RenderFlag<Wall.RenderFlags>;
     };
 
     /**
@@ -125,7 +126,7 @@ declare global {
     /**
      * Return the coordinates [x,y] at the midpoint of the wall segment
      */
-    get midpoint(): Canvas.PointArray;
+    get midpoint(): Canvas.PointTuple;
 
     override get center(): PIXI.Point;
 
@@ -265,6 +266,7 @@ declare global {
 
     protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
 
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
 
     /**

package/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts

@@ -1,37 +1,7 @@
-import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyBatchRenderer extends BatchRenderer {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { ToMethod, InexactPartial, IntentionalPartial } from "fvtt-types/utils";
+import type { IBatchableElement, ViewableBuffer } from "pixi.js";
 
 declare global {
-  namespace BatchRenderer {
-    type AnyConstructor = typeof AnyBatchRenderer;
-
-    type PackInterleavedGeometryFunction = ToMethod<
-      (
-        element: PIXI.IBatchableElement,
-        attributeBuffer: PIXI.ViewableBuffer,
-        indexBuffer: Uint16Array,
-        aIndex: number,
-        iIndex: number,
-      ) => void
-    >;
-
-    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
-
-    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
-
-    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
-
-    interface ShaderGeneratorOptions {
-      vertex: typeof BatchRenderer.defaultVertexSrc;
-      fragment: typeof BatchRenderer.defaultFragmentTemplate;
-      uniforms: typeof BatchRenderer.defaultUniforms;
-    }
-  }
-
   /**
    * A batch renderer with a customizable data transfer function to packed geometries.
    */
@@ -83,7 +53,18 @@ declare global {
 
     override start(): void;
 
-    override packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction;
+    /**
+     * @privateRemarks This signature must match `PIXI.BatchRenderer#packInterleavedGeometry`, as opposed to being
+     * a `PackInterleavedGeometryFunction`, as these params will be piped there if the subclass in question
+     * doesn't implement `_packInterleavedGeometry`
+     */
+    override packInterleavedGeometry(
+      element: IBatchableElement,
+      attributeBuffer: ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
 
     /**
      * Verify if a PIXI plugin exists. Check by name.
@@ -92,4 +73,40 @@ declare global {
      */
     static hasPlugin(name: string): boolean;
   }
+
+  namespace BatchRenderer {
+    interface Any extends AnyBatchRenderer {}
+    type AnyConstructor = typeof AnyBatchRenderer;
+
+    type PackInterleavedGeometryFunction = ToMethod<
+      (
+        /**
+         * @privateRemarks The `element` param is `Partial`'d here because at least one `_packInterleavedGeometry` implementation (`DepthSampleShader`'s)
+         * omits properties from the parent PIXI interface. Neither `PIXI.BatchRenderer` nor any Foundry implementations provide any default vaules for
+         * properties of this interface, so no `InexactPartial` or `NullishProps`.
+         */
+        element: IntentionalPartial<PIXI.IBatchableElement>,
+        attributeBuffer: PIXI.ViewableBuffer,
+        indexBuffer: Uint16Array,
+        aIndex: number,
+        iIndex: number,
+      ) => void
+    >;
+
+    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
+
+    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
+
+    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
+
+    interface ShaderGeneratorOptions {
+      vertex: typeof BatchRenderer.defaultVertexSrc;
+      fragment: typeof BatchRenderer.defaultFragmentTemplate;
+      uniforms: typeof BatchRenderer.defaultUniforms;
+    }
+  }
+}
+
+declare abstract class AnyBatchRenderer extends BatchRenderer {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BatchShaderGenerator {
-    type AnyConstructor = typeof AnyBatchShaderGenerator;
-  }
-
   /**
    * A batch shader generator that could handle extra uniforms during initialization.
    * @param vertexSrc    - The vertex shader source
@@ -27,4 +19,13 @@ declare global {
 
     override generateShader(maxTextures: number): PIXI.Shader;
   }
+
+  namespace BatchShaderGenerator {
+    interface Any extends AnyBatchShaderGenerator {}
+    type AnyConstructor = typeof AnyBatchShaderGenerator;
+  }
+}
+
+declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/helpers/{framebugger-snapshot.d.mts → framebuffer-snapshot.d.mts}

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FramebufferSnapshot {
-    type AnyConstructor = typeof AnyFramebufferSnapshot;
-  }
-
   /**
    * Provide the necessary methods to get a snapshot of the framebuffer into a render texture.
    * Class meant to be used as a singleton.
@@ -27,4 +19,13 @@ declare global {
      */
     getFramebufferTexture(renderer: PIXI.Renderer): PIXI.RenderTexture;
   }
+
+  namespace FramebufferSnapshot {
+    interface Any extends AnyFramebufferSnapshot {}
+    type AnyConstructor = typeof AnyFramebufferSnapshot;
+  }
+}
+
+declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/helpers/index.d.mts

@@ -1,3 +1,3 @@
-import "./framebugger-snapshot.d.mts";
+import "./framebuffer-snapshot.d.mts";
 import "./smooth-noise.d.mts";
 import "./texture-extractor.d.mts";

package/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts

@@ -1,28 +1,6 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace SmoothNoise {
-    interface ConstructorOptions {
-      /**
-       * The generated noise will be on the range [0, amplitude].
-       * @defaultValue `1`
-       */
-      amplitude: number;
-
-      /**
-       * An adjustment factor for the input x values which place them on an appropriate range.
-       * @defaultValue `1`
-       */
-      scale: number;
-
-      /**
-       * The number of pre-generated random numbers to generate.
-       * @defaultValue `256`
-       */
-      maxReferences: number;
-    }
-  }
-
   /**
    * A smooth noise generator for one-dimensional values.
    */
@@ -62,4 +40,33 @@ declare global {
      */
     generate(x: number): number;
   }
+
+  namespace SmoothNoise {
+    interface Any extends AnySmoothNoise {}
+    type AnyConstructor = typeof AnySmoothNoise;
+
+    interface ConstructorOptions {
+      /**
+       * The generated noise will be on the range [0, amplitude].
+       * @defaultValue `1`
+       */
+      amplitude: number;
+
+      /**
+       * An adjustment factor for the input x values which place them on an appropriate range.
+       * @defaultValue `1`
+       */
+      scale: number;
+
+      /**
+       * The number of pre-generated random numbers to generate.
+       * @defaultValue `256`
+       */
+      maxReferences: number;
+    }
+  }
+}
+
+declare abstract class AnySmoothNoise extends SmoothNoise {
+  constructor(arg0: never, ...args: never[]);
 }