@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.0

package/src/foundry/foundry.js/pixi/containers/placeableObjects/token.d.ts

@@ -258,6 +258,12 @@ declare global {
      */
     refresh(): this;
 
+    /**
+     * Size and display the Token Icon
+     * @internal
+     */
+    protected _refreshIcon(): void;
+
     /**
      * Draw the Token border, taking into consideration the grid type and border color
      * @internal
@@ -444,27 +450,12 @@ declare global {
 
     /**
      * Set this Token as an active target for the current game User
-     * @param targeted       - Is the Token now targeted?
-     *                         (default: `true`)
-     * @param user           - Assign the token as a target for a specific User
-     *                         (default: `null` which will use the current user)
-     * @param releaseOthers  - Release other active targets for the same player?
-     *                         (default: `true`)
-     * @param groupSelection - Is this target being set as part of a group selection workflow?
-     *                         (default: `false`)
-     */
-    setTarget(
-      targeted?: boolean,
-      {
-        user,
-        releaseOthers,
-        groupSelection
-      }?: {
-        user?: InstanceType<ConfiguredDocumentClass<typeof User>> | null;
-        releaseOthers?: boolean;
-        groupSelection?: boolean;
-      }
-    ): void;
+     * @param targeted - Is the Token now targeted?
+     *                   (default: `true`)
+     * @param context  - Additional context options
+     *                   (default `{}`)
+     */
+    setTarget(targeted?: boolean, context?: Token.SetTargetContext | undefined): void;
 
     /**
      * Add or remove the currently controlled Tokens from the active combat encounter
@@ -519,12 +510,8 @@ declare global {
     /** @override */
     protected _getShiftedPosition(dx: number, dy: number): { x: number; y: number };
 
-    /**
-     * Extend the PlaceableObject.rotate method to prevent rotation if the Token is in the midst of a movement animation
-     * @returns Actually a Promise<void>
-     * @remarks The return type is `Promise<this> | undefined` but this breaks the interface of PlaceableObject, see https://gitlab.com/foundrynet/foundryvtt/-/issues/6876
-     */
-    rotate(...args: Parameters<PlaceableObject['rotate']>): any;
+    /** @override */
+    rotate(...args: Parameters<PlaceableObject['rotate']>): Promise<this>;
 
     /** @override */
     protected _onCreate(
@@ -718,5 +705,25 @@ declare global {
        */
       overlay?: boolean | undefined;
     }
+
+    interface SetTargetContext {
+      /**
+       * Assign the token as a target for a specific User
+       * @defaultValue `null`
+       */
+      user?: InstanceType<ConfiguredDocumentClass<typeof User>> | null | undefined;
+
+      /**
+       * Release other active targets for the same player?
+       * @defaultValue `true`
+       */
+      releaseOthers?: boolean | undefined;
+
+      /**
+       * Is this target being set as part of a group selection workflow?
+       * @defaultValue `Is this target being set as part of a group selection workflow?`
+       */
+      groupSelection?: boolean | undefined;
+    }
   }
 }

package/src/foundry/foundry.js/pixi/filters/abstractFilter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * An abstract filter which provides a framework for reusable definition
+ */
+declare abstract class AbstractFilter extends PIXI.Filter {
+  /**
+   * The default uniforms used by the filter
+   * @defaultValue `{}`
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * The fragment shader which renders this filter.
+   * @defaultValue `undefined`
+   * @remarks This is a function in {@link GlowFilter}. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static fragmentShader: string | ((quality: number, distance: number) => string) | undefined;
+
+  /**
+   * The vertex shader which renders this filter.
+   * @defaultValue `undefined`
+   */
+  static vertexShader: string | undefined;
+
+  /**
+   * A factory method for creating the filter using its defined default values
+   * @param uniforms - (default: `{}`)
+   */
+  static create(uniforms: AbstractBaseShader.Uniforms): AbstractFilter;
+
+  /**
+   * Always target the resolution of the render texture or renderer
+   */
+  // @ts-expect-error this is a property on PIXI.Filter
+  get resolution(): number;
+  set resolution(value: number);
+
+  /**
+   * Always target the MSAA level of the render texture or renderer
+   */
+  get multisample(): PIXI.MSAA_QUALITY;
+  set multisample(value: PIXI.MSAA_QUALITY);
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/fogColorFilter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A filter which is rendering explored color according to FoW intensity.
+ */
+declare class FogColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   exploredColor: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/forceColorFilter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A filter which forces all non-transparent pixels to a specific color and transparency.
+ */
+declare class ForceColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   color: [1, 1, 1],
+   *   alpha: 1.0
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/glowFilter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A filter which implements an inner or outer glow around the source texture.
+ * Incorporated from https://github.com/pixijs/filters/tree/main/filters/glow
+ */
+declare class GlowFilter extends AbstractFilter {
+  /**
+   * @override
+   * @defaultValue
+   * ```typescript
+   * {
+   *   distance: 10,
+   *   innerStrength: 0,
+   *   glowColor: [1, 1, 1, 1],
+   *   quality: 0.1,
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms & { distance: number; quality: number };
+
+  /**
+   * @override
+   * @remarks This could change, see https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static fragmentShader(quality: number, distance: number): string;
+
+  /** @override */
+  static vertexShader: string;
+
+  /** @override */
+  static create(uniforms: AbstractBaseShader.Uniforms): GlowFilter;
+}

package/src/foundry/foundry.js/pixi/filters/abstractFilters/index.d.ts

@@ -0,0 +1,4 @@
+import './fogColorFilter';
+import './forceColorFilter';
+import './glowFilter';
+import './roofMaskFilter';

package/src/foundry/foundry.js/pixi/filters/abstractFilters/roofMaskFilter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * This filter turns pixels with an alpha channel < alphaThreshold in transparent pixels
+ * Then, optionally, it can turn the result in the chosen color (default: pure white).
+ * The alpha [threshold,1] is re-mapped to [0,1] with an hermite interpolation slope to prevent pixelation.
+ */
+declare class RoofMaskFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   alphaThreshold: 0.75,
+   *   turnToColor: false,
+   *   color: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}

package/src/foundry/foundry.js/pixi/filters/index.d.ts

@@ -1,2 +1,4 @@
 import './abstractBaseMaskFilter';
 import './abstractBaseMaskFilters';
+import './abstractFilter';
+import './abstractFilters';

package/src/foundry/foundry.js/roll.d.ts

@@ -16,7 +16,7 @@ declare global {
    * console.log(r.terms);    // [Die, OperatorTerm, NumericTerm, OperatorTerm, NumericTerm]
    *
    * // Execute the roll
-   * r.evaluate();
+   * await r.evaluate();
    *
    * // The resulting equation after it was rolled
    * console.log(r.result);   // 16 + 2 + 4
@@ -142,7 +142,7 @@ declare global {
      * @example
      * ```typescript
      * let r = new Roll("2d6 + 4 + 1d4");
-     * r.evaluate();
+     * await r.evaluate();
      * console.log(r.result); // 5 + 4 + 2
      * console.log(r.total);  // 11
      * ```

package/src/foundry/foundry.js/rollTerms/poolTerm.d.ts

@@ -59,6 +59,11 @@ declare global {
      */
     static CLOSE_REGEXP: RegExp;
 
+    /**
+     * A regular expression pattern used to match the entirety of a DicePool expression.
+     */
+    static REGEXP: RegExp;
+
     /**
      * @defaultValue `["terms", "modifiers", "rolls", "results"]`
      */

package/src/types/augments/index.d.ts

@@ -1,3 +1,5 @@
+import './pixiGraphicsSmooth';
+import './pixiLegacyGraphics';
 import './pixiParticles';
 import './simple-peer';
 import './socket.io-client';

package/src/types/augments/pixiGraphicsSmooth.d.ts

@@ -0,0 +1,7 @@
+import * as graphicsSmooth from '@pixi/graphics-smooth';
+
+declare global {
+  namespace PIXI {
+    export import smooth = graphicsSmooth; // eslint-disable-line @typescript-eslint/no-unused-vars
+  }
+}

package/src/types/augments/pixiLegacyGraphics.d.ts

@@ -0,0 +1,7 @@
+declare global {
+  namespace PIXI {
+    export const LegacyGraphics: typeof PIXI.Graphics;
+  }
+}
+
+export {};