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

package/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts

@@ -1,20 +1,71 @@
 export {};
 
-declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace HighlightRegionShader {
-    type AnyConstructor = typeof AnyHighlightRegionShader;
-  }
-
   /**
    * Shader for the Region highlight.
    */
   class HighlightRegionShader extends RegionShader {
+    /**
+     * @defaultValue
+     * ```
+     *  `\
+     *   precision ${PIXI.settings.PRECISION_VERTEX} float;
+     *
+     *   ${this.CONSTANTS}
+     *
+     *   attribute vec2 aVertexPosition;
+     *
+     *   uniform mat3 translationMatrix;
+     *   uniform mat3 projectionMatrix;
+     *   uniform vec2 canvasDimensions;
+     *   uniform vec4 sceneDimensions;
+     *   uniform vec2 screenDimensions;
+     *   uniform mediump float hatchThickness;
+     *
+     *   varying vec2 vCanvasCoord; // normalized canvas coordinates
+     *   varying vec2 vSceneCoord; // normalized scene coordinates
+     *   varying vec2 vScreenCoord; // normalized screen coordinates
+     *   varying float vHatchOffset;
+     *
+     *   void main() {
+     *     vec2 pixelCoord = aVertexPosition;
+     *     vCanvasCoord = pixelCoord / canvasDimensions;
+     *     vSceneCoord = (pixelCoord - sceneDimensions.xy) / sceneDimensions.zw;
+     *     vec3 tPos = translationMatrix * vec3(aVertexPosition, 1.0);
+     *     vScreenCoord = tPos.xy / screenDimensions;
+     *     gl_Position = vec4((projectionMatrix * tPos).xy, 0.0, 1.0);
+     *     vHatchOffset = (pixelCoord.x + pixelCoord.y) / (SQRT2 * 2.0 * hatchThickness);
+     *   }
+     *  `
+     * ```
+     */
     static override vertexShader: string;
 
+    /**
+     * @defaultValue
+     * ```
+     *  `\
+     *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+     *
+     *   varying float vHatchOffset;
+     *
+     *   uniform vec4 tintAlpha;
+     *   uniform float resolution;
+     *   uniform bool hatchEnabled;
+     *   uniform mediump float hatchThickness;
+     *
+     *   void main() {
+     *     gl_FragColor = tintAlpha;
+     *     if ( !hatchEnabled ) return;
+     *     float x = abs(vHatchOffset - floor(vHatchOffset + 0.5)) * 2.0;
+     *     float s = hatchThickness * resolution;
+     *     float y0 = clamp((x + 0.5) * s + 0.5, 0.0, 1.0);
+     *     float y1 = clamp((x - 0.5) * s + 0.5, 0.0, 1.0);
+     *     gl_FragColor *= mix(0.3333, 1.0, y0 - y1);
+     *   }
+     *  `
+     * ```
+     */
     static override fragmentShader: string;
 
     /**
@@ -32,4 +83,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace HighlightRegionShader {
+    interface Any extends AnyHighlightRegionShader {}
+    type AnyConstructor = typeof AnyHighlightRegionShader;
+  }
+}
+
+declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,8 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { InexactPartial, Mixin } from "fvtt-types/utils";
 
 declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -26,24 +22,6 @@ declare class BatchGeometry extends PIXI.Geometry {
 }
 
 declare global {
-  namespace BaseSamplerShader {
-    type AnyConstructor = typeof AnyBaseSamplerShader;
-
-    type PluginName = (typeof BaseSamplerShader)["classPluginName"];
-
-    interface BatchGeometryData {
-      id: string;
-      size: number;
-      normalized: boolean;
-      type: PIXI.TYPES;
-    }
-
-    type ToGeometryClass<G extends PIXI.BatchGeometry.AnyConstructor | BaseSamplerShader.BatchGeometryData[]> =
-      G extends readonly unknown[] ? typeof BatchGeometry : G;
-
-    type BatchGeometry = typeof PIXI.BatchGeometry | BaseSamplerShader.BatchGeometryData[];
-  }
-
   /**
    * A simple shader to emulate a PIXI.Sprite with a PIXI.Mesh (but faster!)
    */
@@ -64,7 +42,7 @@ declare global {
      * The plugin name associated for this instance, if any.
      * Returns "batch" if the shader is disabled.
      */
-    get pluginName(): BaseSamplerShader.PluginName;
+    get pluginName(): (typeof BaseSamplerShader)["classPluginName"];
 
     /**
      * Activate or deactivate this sampler. If set to false, the batch rendering is redirected to "batch".
@@ -203,4 +181,25 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaseSamplerShader {
+    interface Any extends AnyBaseSamplerShader {}
+    type AnyConstructor = typeof AnyBaseSamplerShader;
+
+    interface BatchGeometryData {
+      id: string;
+      size: number;
+      normalized: boolean;
+      type: PIXI.TYPES;
+    }
+
+    type ToGeometryClass<G extends PIXI.BatchGeometry.AnyConstructor | BaseSamplerShader.BatchGeometryData[]> =
+      G extends readonly unknown[] ? typeof BatchGeometry : G;
+
+    type BatchGeometry = typeof PIXI.BatchGeometry | BaseSamplerShader.BatchGeometryData[];
+  }
+}
+
+declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/baseline-illumination.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BaselineIlluminationSamplerShader {
-    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
-  }
-
   /**
    * Compute baseline illumination according to darkness level encoded texture.
    */
@@ -35,4 +27,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaselineIlluminationSamplerShader {
+    interface Any extends AnyBaselineIlluminationSamplerShader {}
+    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
+  }
+}
+
+declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ColorAdjustmentsSamplerShader {
-    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
-  }
-
-  namespace AmplificationSamplerShader {
-    type AnyConstructor = typeof AnyAmplificationSamplerShader;
-  }
-
   /**
    * A color adjustment shader.
    */
@@ -26,6 +10,8 @@ declare global {
      */
     static override classPluginName: string | null;
 
+    static override vertexShader: string;
+
     static override fragmentShader: string;
 
     /**
@@ -33,7 +19,8 @@ declare global {
      * ```js
      * {
      *   tintAlpha: [1, 1, 1, 1],
-     *   tint: [1, 1, 1],  contrast: 0,
+     *   tint: [1, 1, 1],
+     *   contrast: 0,
      *   saturation: 0,
      *   exposure: 0,
      *   sampler: null,
@@ -45,21 +32,30 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
 
-    get linkedToDarknessLevel(): AbstractBaseShader.UniformValue;
+    /** @privateRemarks Inferred from defaultUniforms */
+    get linkedToDarknessLevel(): boolean;
+
+    set linkedToDarknessLevel(link);
 
-    set linkedToDarknessLevel(link: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get contrast(): number;
 
-    get contrast(): AbstractBaseShader.UniformValue;
+    set contrast(contrast);
 
-    set contrast(contrast: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get exposure(): number;
 
-    get exposure(): AbstractBaseShader.UniformValue;
+    set exposure(exposure);
 
-    set exposure(exposure: AbstractBaseShader.UniformValue);
+    /** @privateRemarks Inferred from defaultUniforms */
+    get saturation(): number;
 
-    get saturation(): AbstractBaseShader.UniformValue;
+    set saturation(saturation);
+  }
 
-    set saturation(saturation: AbstractBaseShader.UniformValue);
+  namespace ColorAdjustmentsSamplerShader {
+    interface Any extends AnyColorAdjustmentsSamplerShader {}
+    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
   }
 
   /**
@@ -95,15 +91,28 @@ declare global {
      */
     get brightness(): number;
 
-    set brightness(brightness: AbstractBaseShader.UniformValue);
+    set brightness(brightness);
 
     /**
      * Tint color applied to Light Amplification.
      * Light Amplification tint
      * @defaultValue `[0.48, 1.0, 0.48]`
      */
-    get colorTint(): number[];
+    get colorTint(): Color.RGBColorVector;
 
-    set colorTint(color: AbstractBaseShader.UniformValue);
+    set colorTint(color);
+  }
+
+  namespace AmplificationSamplerShader {
+    interface Any extends AnyAmplificationSamplerShader {}
+    type AnyConstructor = typeof AnyAmplificationSamplerShader;
   }
 }
+
+declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace DepthSamplerShader {
-    type AnyConstructor = typeof AnyDepthSamplerShader;
-
-    interface DepthBatchData extends PIXI.IBatchableElement {
-      elevation: number;
-      textureAlphaThreshold: number;
-      fadeOcclusion: number;
-      radialOcclusion: number;
-      visionOcclusion: number;
-    }
-  }
-
   /**
    * The depth sampler shader.
    */
@@ -100,4 +84,24 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace DepthSamplerShader {
+    interface Any extends AnyDepthSamplerShader {}
+    type AnyConstructor = typeof AnyDepthSamplerShader;
+
+    /** @internal */
+    type PartialPIXIBatchable = Pick<PIXI.IBatchableElement, "_texture" | "vertexData" | "indices" | "uvs">;
+
+    interface DepthBatchData extends PartialPIXIBatchable {
+      elevation: number;
+      textureAlphaThreshold: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+}
+
+declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyFogSamplerShader extends FogSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace FogSamplerShader {
-    type AnyConstructor = typeof AnyFogSamplerShader;
-  }
-
   /**
    * A simple shader which purpose is to make the original texture red channel the alpha channel,
    * and still keeping channel informations. Used in cunjunction with the AlphaBlurFilterPass and Fog of War.
@@ -21,4 +13,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace FogSamplerShader {
+    interface Any extends AnyFogSamplerShader {}
+    type AnyConstructor = typeof AnyFogSamplerShader;
+  }
+}
+
+declare abstract class AnyFogSamplerShader extends FogSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts

@@ -1,23 +1,6 @@
 export {};
 
-declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace OccludableSamplerShader {
-    type AnyConstructor = typeof AnyOccludableSamplerShader;
-
-    interface OccludableBatchData extends PIXI.IBatchableElement {
-      elevation: number;
-      unoccludedAlpha: number;
-      occludedAlpha: number;
-      fadeOcclusion: number;
-      radialOcclusion: number;
-      visionOcclusion: number;
-    }
-  }
-
   /**
    * An occlusion shader to reveal certain area with elevation comparisons.
    * This shader is also working as a batched plugin.
@@ -101,4 +84,23 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace OccludableSamplerShader {
+    interface Any extends AnyOccludableSamplerShader {}
+    type AnyConstructor = typeof AnyOccludableSamplerShader;
+
+    /** @privateRemarks Unlike `DepthSamplerShader`, this class uses every `IBatchableElement` key */
+    interface OccludableBatchData extends PIXI.IBatchableElement {
+      elevation: number;
+      unoccludedAlpha: number;
+      occludedAlpha: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+}
+
+declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts

@@ -23,4 +23,13 @@ declare global {
      */
     protected _configureDepthShader(depthShader: DepthSamplerShader): void;
   }
+
+  namespace PrimaryBaseSamplerShader {
+    interface Any extends AnyPrimaryBaseSamplerShader {}
+    type AnyConstructor = typeof AnyPrimaryBaseSamplerShader;
+  }
+}
+
+declare abstract class AnyPrimaryBaseSamplerShader extends PrimaryBaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts

@@ -1,3 +1,6 @@
+import type { NullishProps } from "../../../../../../utils/index.d.mts";
+import type TokenRing from "../../../../../client-esm/canvas/tokens/ring.d.mts";
+
 export {};
 
 declare global {
@@ -33,7 +36,8 @@ declare global {
     protected static override _preRenderBatch: BatchRenderer.PreRenderBatchFunction;
 
     protected static override _packInterleavedGeometry(
-      element: PIXI.IBatchableElement,
+      /** @privateRemarks Calls super, which is the grandparent class in this case, with no new keys */
+      element: TokenRingSamplerShader.BatchData,
       attributeBuffer: PIXI.ViewableBuffer,
       indexBuffer: Uint16Array,
       aIndex: number,
@@ -44,4 +48,28 @@ declare global {
 
     protected static override _batchFragmentShader: string;
   }
+
+  namespace TokenRingSamplerShader {
+    interface Any extends AnyTokenRingSamplerShader {}
+    type AnyConstructor = typeof AnyTokenRingSamplerShader;
+
+    /** @internal */
+    type RingContainerObject = NullishProps<{
+      object: NullishProps<{
+        ring: TokenRing;
+      }>;
+    }>;
+
+    interface BatchData extends OccludableSamplerShader.OccludableBatchData {
+      /**
+       * @remarks This key is required to be an object as `TokenRingSamplerShader._packInterleavedGeometry` does `element.object.object || {}`.
+       * All `TokenRing` keys are then accessed via optional chaining with `??` defaults.
+       */
+      object: RingContainerObject;
+    }
+  }
+}
+
+declare abstract class AnyTokenRingSamplerShader extends TokenRingSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/background-vision.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace BackgroundVisionShader {
-    type AnyConstructor = typeof AnyBackgroundVisionShader;
-  }
-
   /**
    * The default background shader used for vision sources
    */
@@ -39,4 +31,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace BackgroundVisionShader {
+    interface Any extends AnyBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyBackgroundVisionShader;
+  }
+}
+
+declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveVisionShader {
-    type AnyConstructor = typeof AnyAdaptiveVisionShader;
-  }
-
   /**
    * This class defines an interface which all adaptive vision shaders extend.
    */
@@ -25,7 +17,17 @@ declare global {
 
     /**
      * A mapping of available shader techniques
+     * @remarks Removes all parent techniques other than `LEGACY`
      */
     static override SHADER_TECHNIQUES: Record<string, AdaptiveLightingShader.ShaderTechnique>;
   }
+
+  namespace AdaptiveVisionShader {
+    interface Any extends AnyAdaptiveVisionShader {}
+    type AnyConstructor = typeof AnyAdaptiveVisionShader;
+  }
+}
+
+declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/coloration-vision.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace ColorationVisionShader {
-    type AnyConstructor = typeof AnyColorationVisionShader;
-  }
-
   /**
    * The default coloration shader used for vision sources.
    */
@@ -38,4 +30,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace ColorationVisionShader {
+    interface Any extends AnyColorationVisionShader {}
+    type AnyConstructor = typeof AnyColorationVisionShader;
+  }
+}
+
+declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AmplificationBackgroundVisionShader {
-    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
-  }
-
   /**
    * Shader specialized in light amplification
    */
@@ -29,4 +21,13 @@ declare global {
 
     override get isRequired(): boolean;
   }
+
+  namespace AmplificationBackgroundVisionShader {
+    interface Any extends AnyAmplificationBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
+  }
+}
+
+declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/effects/wave.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace WaveBackgroundVisionShader {
-    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
-  }
-
-  namespace WaveColorationVisionShader {
-    type AnyConstructor = typeof AnyWaveColorationVisionShader;
-  }
-
   /**
    * Shader specialized in wave like senses (tremorsenses)
    */
@@ -37,6 +21,11 @@ declare global {
     override get isRequired(): boolean;
   }
 
+  namespace WaveBackgroundVisionShader {
+    interface Any extends AnyWaveBackgroundVisionShader {}
+    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
+  }
+
   /**
    * The wave vision shader, used to create waves emanations (ex: tremorsense)
    */
@@ -56,4 +45,17 @@ declare global {
 
     override get isRequired(): boolean;
   }
+
+  namespace WaveColorationVisionShader {
+    interface Any extends AnyWaveColorationVisionShader {}
+    type AnyConstructor = typeof AnyWaveColorationVisionShader;
+  }
+}
+
+declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/vision/illumination-vision.d.mts

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace IlluminationVisionShader {
-    type AnyConstructor = typeof AnyIlluminationVisionShader;
-  }
-
   /**
    * The default illumination shader used for vision sources
    */
@@ -33,4 +25,13 @@ declare global {
 
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace IlluminationVisionShader {
+    interface Any extends AnyIlluminationVisionShader {}
+    type AnyConstructor = typeof AnyIlluminationVisionShader;
+  }
+}
+
+declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
+  constructor(arg0: never, ...args: never[]);
 }