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

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[]);
 }

package/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts

@@ -1,65 +1,16 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyTextureExtractor extends TextureExtractor {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { Brand, InexactPartial } from "fvtt-types/utils";
 
 declare global {
-  namespace TextureExtractor {
-    type AnyConstructor = typeof AnyTextureExtractor;
-
-    interface ConstructorOptions {
-      /** @defaultValue `"TextureExtractor"` */
-      callerName: string;
-
-      controlHash: boolean;
-
-      /** @defaultValue `PIXI.FORMATS.RED` */
-      format: PIXI.FORMATS;
-    }
-
-    interface TextureExtractionOptions {
-      /**
-       * The texture the pixels are extracted from.
-       * Otherwise, extract from the renderer.
-       */
-      texture: PIXI.Texture | PIXI.RenderTexture | null;
-
-      /** The rectangle which the pixels are extracted from. */
-      frame: PIXI.Rectangle;
-
-      /** The compression mode to apply, or NONE */
-      compression: TextureExtractor.COMPRESSION_MODES;
-
-      /** The optional image mime type. */
-      type: string;
-
-      /** The optional image quality. */
-      quality: string;
-
-      /** The optional debug flag to use. */
-      debug: boolean;
-    }
-
-    interface COMPRESSION_MODES {
-      readonly NONE: 0;
-      readonly BASE64: 1;
-    }
-  }
-
   /**
    * A class or interface that provide support for WebGL async read pixel/texture data extraction.
    */
   class TextureExtractor {
-    constructor(
-      renderer: PIXI.Renderer,
-      { callerName, controlHash, format }?: InexactPartial<TextureExtractor.ConstructorOptions>,
-    );
+    constructor(renderer: PIXI.Renderer, options?: TextureExtractor.ConstructorOptions);
 
     /**
      * List of compression that could be applied with extraction
      */
-    static COMPRESSION_MODES: TextureExtractor.COMPRESSION_MODES;
+    static COMPRESSION_MODES: TextureExtractor.CompressionModes;
 
     /**
      * Debug flag.
@@ -75,7 +26,7 @@ declare global {
      * Extract a rectangular block of pixels from the texture (without un-pre-multiplying).
      * @param options - Options which configure extraction behavior
      */
-    extract(options: InexactPartial<TextureExtractor.TextureExtractionOptions>): ReturnType<Semaphore["add"]>;
+    extract(options?: TextureExtractor.TextureExtractionOptions): Promise<string | Uint8ClampedArray>;
 
     /**
      * Free all the bound objects.
@@ -87,4 +38,82 @@ declare global {
      */
     contextChange(): void;
   }
+
+  namespace TextureExtractor {
+    type Any = AnyTextureExtractor;
+    type AnyConstructor = typeof AnyTextureExtractor;
+
+    /** @internal */
+    type _ConstructorOptions = InexactPartial<{
+      /**
+       * The caller name associated with this instance of texture extractor (optional, used for debug)
+       * @defaultValue `"TextureExtractor"`
+       * @remarks Default provided by ?? in function body
+       */
+      callerName: string | null;
+
+      /**
+       * Does the TextureCompressor neeed to control the hash?
+       * @remarks Passed to `new TextureCompressor()`, where it is provided a default of `false` if null
+       */
+      controlHash: boolean | null;
+
+      /**
+       * The PIXI Format this TextureExtractor uses
+       * @defaultValue `PIXI.FORMATS.RED`
+       * @remarks Construction throws if this isn't `.RED` or `.RGBA`, so can't be null
+       */
+      format: PIXI.FORMATS;
+    }>;
+
+    /** Options for the constructor of {@link TextureExtractor} */
+    interface ConstructorOptions extends _ConstructorOptions {}
+
+    /** @internal */
+    type _ExtractOptions = InexactPartial<{
+      /**
+       * The texture the pixels are extracted from.
+       * Otherwise, extract from the renderer.
+       * @remarks Can't be null despite Foundry's typedef claiming it can, as eventually `texture?.baseTexture.resolution` is accessed
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture;
+
+      /** The rectangle which the pixels are extracted from. */
+      frame: PIXI.Rectangle;
+
+      /** The compression mode to apply, or NONE */
+      compression: TextureExtractor.COMPRESSION_MODES;
+
+      /**
+       * The optional image mime type.
+       * @privateRemarks Allowed to be null because it has an `??` default in `TextureExtractor##compressBufferWorker`
+       * via `##compressBuffer`, the only place it is actually used, despite being passed to other functions as well
+       */
+      type: string | null;
+
+      /**
+       * The optional image quality.
+       *  @privateRemarks Foundry types as `string` but is clearly meant to be `number` by usage. Allowing null due to
+       * it having a `??` default in the path any browser someone is realistically using for Foundry will take.
+       */
+      quality: number | null;
+
+      /** The optional debug flag to use. */
+      debug: boolean | null;
+    }>;
+
+    /** Options for {@link TextureExtractor#extract} */
+    interface TextureExtractionOptions extends _ExtractOptions {}
+
+    type COMPRESSION_MODES = Brand<number, "TextureExtractor.COMPRESSION_MODES">;
+
+    interface CompressionModes {
+      NONE: 0 & COMPRESSION_MODES;
+      BASE64: 1 & COMPRESSION_MODES;
+    }
+  }
+}
+
+declare abstract class AnyTextureExtractor extends TextureExtractor {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts

@@ -1,8 +1,4 @@
-import type { Mixin } from "../../../../../types/utils.d.mts";
-
-declare abstract class AnyBaseShader extends BaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType, Mixin } from "fvtt-types/utils";
 
 declare class BaseShader {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -109,11 +105,15 @@ declare class BaseShader {
 }
 
 declare global {
-  namespace BaseShader {
-    type AnyConstructor = typeof AnyBaseShader;
-  }
-
-  function BaseShaderMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+  function BaseShaderMixin<BaseClass extends BaseShaderMixin.BaseClass>(
     ShaderClass: BaseClass,
   ): Mixin<typeof BaseShader, BaseClass>;
+
+  namespace BaseShaderMixin {
+    /** @privateRemarks Can't extend `AnyMixedConstructor` if it's using the `BaseClass` union; `PIXI.Shader` is the parent of `Filter`, so it's used instead */
+    type AnyMixedConstructor = ReturnType<typeof BaseShaderMixin<PIXI.Shader.AnyConstructor>>;
+    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+    type BaseClass = PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor;
+  }
 }

package/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts

@@ -1,35 +1,19 @@
-import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
-
-declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType, ToMethod } from "fvtt-types/utils";
 
 declare global {
-  namespace AbstractBaseShader {
-    type AnyConstructor = typeof AnyAbstractBaseShader;
-
-    type Coordinates =
-      | { x: number; y: number }
-      | { x: number; y: number; z: number }
-      | { x: number; y: number; z: number; w: number };
-
-    type UniformValue = boolean | number | Int32List | Float32List | Coordinates | Coordinates[] | PIXI.Texture;
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-    type Uniforms = {
-      readonly [K: string]: AbstractBaseShader.UniformValue;
-    };
-
-    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
-
-    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
-  }
-
   /**
    * This class defines an interface which all shaders utilize
    */
   abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
-    constructor(program: PIXI.Program, uniforms: AbstractBaseShader.Uniforms);
+    /**
+     * @param program  - The program to use with this shader.
+     * @param uniforms - The current uniforms of the Shader
+     */
+    constructor(
+      program: PIXI.Program,
+      /** @defaultValue `{}` */
+      uniforms?: AbstractBaseShader.Uniforms,
+    );
 
     /**
      * The raw vertex shader used by this class.
@@ -63,8 +47,8 @@ declare global {
      */
     static create<ThisType extends AbstractBaseShader.AnyConstructor>(
       this: ThisType,
-      initialUniforms: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): FixedInstanceType<ThisType>;
 
     /**
      * Reset the shader uniforms back to their initial values.
@@ -81,6 +65,7 @@ declare global {
      * Perform operations which are required before binding the Shader to the Renderer.
      * @param mesh - The mesh display object linked to this shader.
      * @param renderer - The renderer
+     * @privateRemarks Foundry marks this as protected despite it getting called from `QuadMesh#_render`
      */
     protected _preRender: AbstractBaseShader.PreRenderFunction;
 
@@ -91,4 +76,36 @@ declare global {
      */
     protected get _defaults(): AbstractBaseShader.Uniforms;
   }
+
+  namespace AbstractBaseShader {
+    type AnyConstructor = typeof AnyAbstractBaseShader;
+
+    type Coordinates = { x: number; y: number; z?: number } | { x: number; y: number; z: number; w?: number };
+
+    type UniformValue =
+      | boolean
+      | number
+      | null
+      | Int32List
+      | Float32List
+      | Coordinates
+      | Coordinates[]
+      | Color.RGBColorVector
+      | Color.RGBAColorVector
+      | PIXI.Texture
+      | PIXI.Matrix;
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+    type Uniforms = {
+      readonly [K: string]: AbstractBaseShader.UniformValue;
+    };
+
+    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
+
+    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
+  }
+}
+
+declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts

@@ -1,14 +1,6 @@
-export {};
-
-declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { FixedInstanceType } from "fvtt-types/utils";
 
 declare global {
-  namespace AbstractBaseFilter {
-    type AnyConstructor = typeof AnyAbstractBaseFilter;
-  }
-
   /**
    * An abstract filter which provides a framework for reusable definition
    */
@@ -42,6 +34,15 @@ declare global {
        * @defaultValue `{}`
        */
       initialUniforms?: AbstractBaseShader.Uniforms,
-    ): InstanceType<ThisType>;
+    ): FixedInstanceType<ThisType>;
   }
+
+  namespace AbstractBaseFilter {
+    interface Any extends AnyAbstractBaseFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractBaseMaskFilter {
-    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
-  }
-
   /**
    * This class defines an interface for masked custom filters
    */
@@ -18,12 +10,22 @@ declare global {
      */
     static vertexShader: string;
 
+    /** @remarks Foundry does not use the `currentState` param */
     override apply(
       filterManager: PIXI.FilterSystem,
       input: PIXI.RenderTexture,
       output: PIXI.RenderTexture,
       clear: PIXI.CLEAR_MODES,
-      currentState: PIXI.FilterState,
+      currentState?: PIXI.FilterState,
     ): void;
   }
+
+  namespace AbstractBaseMaskFilter {
+    interface Any extends AnyAbstractBaseMaskFilter {}
+    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
+  }
+}
+
+declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AlphaBlurFilterPass {
-    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
-  }
-
-  namespace AlphaBlurFilter {
-    type AnyConstructor = typeof AnyAlphaBlurFilter;
-  }
-
   /**
    * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -106,6 +90,11 @@ declare global {
     ): void;
   }
 
+  namespace AlphaBlurFilterPass {
+    interface Any extends AnyAlphaBlurFilterPass {}
+    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
+  }
+
   /**
    * Apply a gaussian blur going inward by using alpha as the penetrating channel.
    */
@@ -122,9 +111,9 @@ declare global {
      */
     constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
 
-    blurXFilter: typeof AlphaBlurFilterPass;
+    blurXFilter: AlphaBlurFilterPass;
 
-    blurYFilter: typeof AlphaBlurFilterPass;
+    blurYFilter: AlphaBlurFilterPass;
 
     _repeatEdgePixels: boolean;
 
@@ -178,8 +167,21 @@ declare global {
     /**
      * Provided for completeness with PIXI.BlurFilter
      */
-    get blendMode(): number;
+    get blendMode(): PIXI.BLEND_MODES;
 
     set blendMode(value);
   }
+
+  namespace AlphaBlurFilter {
+    interface Any extends AnyAlphaBlurFilter {}
+    type AnyConstructor = typeof AnyAlphaBlurFilter;
+  }
+}
+
+declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
+  constructor(arg0: never, ...args: never[]);
 }