@league-of-foundry-developers/foundry-vtt-types 0.8.9-6 → 9.238.0

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

@@ -1,11 +1,14 @@
 import './baseGrid';
 import './baseGrids';
 import './cachedContainer';
+import './cachedContainers';
 import './canvasLayer';
 import './canvasLayers';
 import './controlIcon';
 import './cursor';
 import './doorControl';
+import './effectsCanvasGroup';
+import './interfaceCanvasGroup';
 import './placeableObject';
 import './placeableObjects';
 import './ruler';

package/src/foundry/foundry.js/pixi/containers/interfaceCanvasGroup.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A container group which displays interface elements rendered above other canvas groups.
+ */
+declare class InterfaceCanvasGroup extends PIXI.Container {
+  constructor();
+
+  sounds: SoundsLayer;
+
+  notes: NotesLayer;
+
+  controls: ControlsLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"interface"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}

package/src/foundry/foundry.js/pixi/containers/placeableObject.d.ts

@@ -17,6 +17,9 @@ declare global {
      */
     constructor(document: D);
 
+    /** @internal */
+    protected _original?: this | undefined;
+
     /**
      * Retain a reference to the Scene within which this Placeable Object resides
      */
@@ -50,7 +53,7 @@ declare global {
      * A mouse interaction manager instance which handles mouse workflows related to this object.
      * @defaultValue `null`
      */
-    mouseInteractionManager: MouseInteractionManager<this, ControlIcon | this> | null;
+    mouseInteractionManager: MouseInteractionManager<this> | null;
 
     /**
      * An indicator for whether the object is currently controlled

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

@@ -258,7 +258,7 @@ declare global {
      * @param mode - The mode from CONST.TOKEN_DISPLAY_MODES
      * @returns Is the attribute viewable?
      */
-    protected _canViewMode(mode: foundry.CONST.TokenDisplayMode): boolean;
+    protected _canViewMode(mode: foundry.CONST.TOKEN_DISPLAY_MODES): boolean;
 
     /**
      * Animate Token movement along a certain path which is defined by a Ray object

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

@@ -22,7 +22,7 @@ declare global {
     /**
      * @remarks Type is `MouseInteractionManager<this, this['endpoints']>`
      */
-    mouseInteractionManager: MouseInteractionManager<this, any> | null;
+    mouseInteractionManager: MouseInteractionManager<this> | null;
 
     constructor(document: ConcreteWallDocument);
 

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

@@ -2,7 +2,20 @@
  * A helper class used by the Sight Layer to represent a source of vision or illumination.
  */
 declare class PointSource {
-  constructor();
+  /**
+   * @param object - The object responsible for the PointSource
+   */
+  constructor(object: PlaceableObject, sourceType: PointSource.SourceType);
+
+  /**
+   * The object responsible for the PointSource
+   */
+  object: PlaceableObject;
+
+  /**
+   * The type of source
+   */
+  sourceType: PointSource.SourceType;
 
   /**
    * The light or darkness container for this source
@@ -20,11 +33,17 @@ declare class PointSource {
    */
   active: boolean;
 
+  /**
+   * The range of Scene darkness values for which this Source should be active
+   * @defaultValue `{ min: 0, max: 0 }`
+   */
+  darkness: { min: number; max: number };
+
   /**
    * Internal flag for whether this is a darkness source
    * @defaultValue `false`
    */
-  darkness: boolean;
+  isDarkness: boolean;
 
   /**
    * Is the light source limited by an angle of emission?
@@ -41,27 +60,66 @@ declare class PointSource {
   /**
    * Internal flag for animation throttling time
    * @defaultValue `0`
+   * @internal
    */
   protected _animateTime: number;
 
   /**
    * An integer seed which de-synchronizes otherwise similar animations
    * @defaultValue `null`
+   * @internal
    */
   protected _animateSeed: number | null;
 
+  /**
+   * A flag for the lighting channels version that this source is using.
+   * @defaultValue `0`
+   * @internal
+   */
+  protected _lightingVersion: number;
+
   /**
    * A flag for whether to re-initialize illumination shader uniforms the next time the light is rendered.
    * @defaultValue `true`
+   * @internal
    */
   protected _resetIlluminationUniforms: boolean;
 
   /**
    * A flag for whether to re-initialize coloration shader uniforms the next time the light is rendered.
    * @defaultValue `true`
+   *@internal
    */
   protected _resetColorationUniforms: boolean;
 
+  /**
+   * An internal flag for whether to render coloration for this source
+   * @defaultValue `false`
+   * @internal
+   */
+  protected _hasColor: boolean;
+
+  /**
+   * The default Geometry stored in the GPU for all Point Source meshes.
+   */
+  static GEOMETRY: PIXI.Geometry;
+
+  /**
+   * Create the structure of a source Container which can be rendered to the sight layer shadow-map
+   * @returns The constructed light source container
+   * @internal
+   */
+  protected _createContainer(shaderCls: ConstructorOf<AbstractBaseShader>): PIXI.Container;
+
+  /**
+   * Initialize the source with provided object data.
+   *
+   * @param data - Input data which configures the source.
+   *
+   * @returns A reference to the initialized source
+   */
+  initialize(data?: PointSource.Data): PointSource.Initialized<this>;
+
   /**
    * The x-coordinate of the source location
    * @defaultValue `undefined`
@@ -117,16 +175,10 @@ declare class PointSource {
   alpha?: number;
 
   /**
-   * A level of darkness beyond which this light is active
+   * The source type from CONST.SOURCE_TYPES
    * @defaultValue `undefined`
    */
-  darknessThreshold?: number;
-
-  /**
-   * The source type from {@link SOURCE_TYPES}
-   * @defaultValue `undefined`
-   */
-  type?: foundry.CONST.SourceType;
+  type?: foundry.CONST.SOURCE_TYPES;
 
   /**
    * An animation configuration for the source
@@ -143,7 +195,7 @@ declare class PointSource {
   /**
    * @defaultValue `undefined`
    */
-  colorRGB?: [number, number, number];
+  colorRGB?: [r: number, g: number, b: number];
 
   /**
    * @defaultValue `undefined`
@@ -160,92 +212,25 @@ declare class PointSource {
    */
   los?: PIXI.Polygon;
 
-  /**
-   * Create the structure of a source Container which can be rendered to the sight layer shadow-map
-   * @returns The constructed light source container
-   */
-  protected _createContainer(shaderCls: ConstructorOf<AbstractBaseShader>): PIXI.Container;
-
-  /**
-   * Initialize the source with provided object data.
-   *
-   * @param x                 - The x-coordinate of the source location
-   *                            (default: `0`)
-   * @param y                 - The y-coordinate of the source location
-   *                            (default: `0`)
-   * @param z                 - An optional z-index sorting for the source
-   *                            (default: `null`)
-   * @param dim               - The allowed radius of dim vision or illumination
-   *                            (default: `0`)
-   * @param bright            - The allowed radius of bright vision or illumination
-   *                            (default: `0`)
-   * @param angle             - The angle of emission for this point source
-   *                            (default: `360`)
-   * @param rotation          - The angle of rotation for this point source
-   *                            (default: `0`)
-   * @param color             - A tint color for the emitted light, if any
-   *                            (default: `null`)
-   * @param alpha             - An opacity for the emitted light, if any
-   *                            (default: `0.5`)
-   * @param darknessThreshold - A level of darkness beyond which this light is active
-   *                            (default: `0`)
-   * @param type              - The source type from SOURCE_TYPES
-   *                            (default: `SOURCE_TYPES.LOCAL`)
-   * @param animation         - An animation configuration for the source
-   *                            (default: `{type: null}`)
-   * @param seed              - An integer seed to synchronize (or de-synchronize) animations
-   *                            (default: `undefined`)
-   *
-   * @returns A reference to the initialized source
-   */
-  initialize({
-    x,
-    y,
-    z,
-    dim,
-    bright,
-    angle,
-    rotation,
-    color,
-    alpha,
-    darknessThreshold,
-    type,
-    animation,
-    seed
-  }?: {
-    x?: number;
-    y?: number;
-    z?: number | null;
-    dim?: number;
-    bright?: number;
-    angle?: number;
-    rotation?: number;
-    color?: number | string | null;
-    alpha?: number;
-    darknessThreshold?: number;
-    type?: string;
-    animation?: PointSource.Animation;
-    seed?: number;
-  }): this;
-
   /**
    * Initialize the shaders used for this animation.
    * Reset the current shader values back to defaults.
    * Swap to a different Shader instance if necessary.
+   * @internal
    */
   protected _initializeShaders(): void;
 
   /**
    * Initialize the blend mode and vertical sorting of this source relative to others in the container.
+   * @internal
    */
   protected _initializeBlending(): void;
 
   /**
    * Draw the display of this source for the darkness/light container of the SightLayer.
-   * @param updateChannels - Is this drawing initiated because lighting channels have changed?
    * @returns The rendered light container
    */
-  drawLight({ updateChannels }?: { updateChannels?: boolean }): PIXI.Container;
+  drawLight(): PIXI.Container;
 
   /**
    * Draw and return a container used to depict the visible color tint of the light source on the LightingLayer
@@ -256,6 +241,7 @@ declare class PointSource {
   /**
    * A common helper function for updating the display of a source container.
    * Assign the container position, dimensions, and polygons.
+   * @internal
    */
   protected _drawContainer(c: PIXI.Container): PIXI.Container;
 
@@ -269,25 +255,31 @@ declare class PointSource {
    * A torch animation where the luminosity and coloration decays each frame and is revitalized by flashes
    * @param dt        - Delta time
    * @param speed     - The animation speed, from 1 to 10
+   *                    (default: `5`)
    * @param intensity - The animation intensity, from 1 to 10
+   *                    (default: `5`)
    */
-  animateTorch: PointSource.AnimationFunction;
+  animateTorch(dt: number, { speed, intensity }?: PointSource.AnimationProperties): void;
 
   /**
    * A basic "pulse" animation which expands and contracts.
    * @param dt        - Delta time
    * @param speed     - The animation speed, from 1 to 10
+   *                    (default: `5`)
    * @param intensity - The animation intensity, from 1 to 10
+   *                    (default: `5`)
    */
-  animatePulse: PointSource.AnimationFunction;
+  animatePulse(dt: number, { speed, intensity }?: PointSource.AnimationProperties): void;
 
   /**
    * Emanate waves of light from the source origin point
    * @param dt        - Delta time
    * @param speed     - The animation speed, from 1 to 10
+   *                    (default: `5`)
    * @param intensity - The animation intensity, from 1 to 10
+   *                    (default: `5`)
    */
-  animateTime: PointSource.AnimationFunction;
+  animateTime(dt: number, { speed, intensity }?: PointSource.AnimationProperties): void;
 
   /**
    * Evolve a value using a stochastic AR(1) process
@@ -298,6 +290,7 @@ declare class PointSource {
    * @param max    - The maximum allowed outcome, or null
    * @param min    - The minimum allowed outcome, or null
    * @returns The new value of the process
+   * @internal
    */
   protected _ar1(
     y: number,
@@ -309,11 +302,106 @@ declare class PointSource {
       min
     }: { phi?: number; center?: number; sigma?: number; max?: number | null; min?: number | null }
   ): number;
-
-  static GEOMETRY: PIXI.Geometry;
 }
 
 declare namespace PointSource {
+  type SourceType = 'light' | 'sight';
+
+  interface Data {
+    /**
+     * The x-coordinate of the source location
+     * @defaultValue `0`
+     */
+    x?: number;
+
+    /** The y-coordinate of the source location
+     * @defaultValue `0`
+     */
+    y?: number;
+
+    /** An optional z-index sorting for the source
+     * @defaultValue `null`
+     */
+    z?: number | null;
+
+    /** The allowed radius of dim vision or illumination
+     * @defaultValue `0`
+     */
+    dim?: number;
+
+    /** The allowed radius of bright vision or illumination
+     * @defaultValue `0`
+     */
+    bright?: number;
+
+    /** The angle of emission for this point source
+     * @defaultValue `360`
+     */
+    angle?: number;
+
+    /**
+     * The angle of rotation for this point source
+     * @defaultValue `0`
+     */
+    rotation?: number;
+
+    /**
+     * A tint color for the emitted light, if any
+     * @defaultValue `null`
+     */
+    color?: number | string | null;
+
+    /** An opacity for the emitted light, if any
+     * @defaultValue `0.5`
+     */
+    alpha: number;
+
+    /**
+     * A darkness range (min and max) for which the source should be active
+     * @defaultValue `{ min: 0, max: 1 }`
+     */
+    darkness?: { min: number; max: number };
+
+    /**
+     * The source type from CONST.SOURCE_TYPES
+     * @defaultValue `CONST.SOURCE_TYPES.LOCAL`
+     */
+    type?: foundry.CONST.SOURCE_TYPES;
+
+    /**
+     * An animation configuration for the source
+     * @defaultValue `{ type: null }`
+     */
+    animation?: PointSource.Animation;
+
+    /**
+     * An integer seed to synchronize (or de-synchronize) animations
+     */
+    seed?: number;
+  }
+
+  type Initialized<P extends PointSource> = P &
+    Required<
+      Pick<
+        P,
+        | 'animation'
+        | 'angle'
+        | 'alpha'
+        | 'bright'
+        | 'color'
+        | 'dim'
+        | 'rotation'
+        | 'type'
+        | 'x'
+        | 'y'
+        | 'z'
+        | 'colorRGB'
+        | 'ratio'
+        | 'fov'
+        | 'los'
+      >
+    >;
+
   interface AnimationProperties {
     speed?: number;
     intensity?: number;

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

@@ -42,7 +42,7 @@ declare global {
     /**
      * Options which modify or describe the Roll
      */
-    options: Partial<Options>;
+    options: InexactPartial<Options>;
 
     /**
      * The identified terms of the Roll
@@ -72,10 +72,8 @@ declare global {
      */
     protected _total: number | undefined;
 
-    /**
-     * A Proxy environment for safely evaluating a string using only available Math functions
-     */
-    static MATH_PROXY: MathProxy;
+    /** A Proxy environment for safely evaluating a string using only available Math functions */
+    static MATH_PROXY: Math;
 
     /**
      * The HTML template path used to render a complete Roll object to the chat log
@@ -117,6 +115,9 @@ declare global {
      */
     get total(): number | undefined;
 
+    /** Whether this Roll contains entirely deterministic terms or whether there is some randomness. */
+    get isDeterministic(): boolean;
+
     /**
      * Alter the Roll expression by adding or multiplying the number of dice which are rolled
      * @param multiply        - A factor to multiply. Dice are multiplied before any additions.
@@ -146,21 +147,21 @@ declare global {
      * console.log(r.total);  // 11
      * ```
      */
-    evaluate(options?: Partial<Options & { async: false }>): this;
-    evaluate(options: Partial<Options> & { async: true }): Promise<this>;
-    evaluate(options?: Partial<Options>): this | Promise<this>;
+    evaluate(options?: InexactPartial<Options & { async: false }>): this;
+    evaluate(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    evaluate(options?: InexactPartial<Options>): this | Promise<this>;
 
     /**
      * Evaluate the roll asynchronously.
      * A temporary helper method used to migrate behavior from 0.7.x (sync by default) to 0.9.x (async by default).
      */
-    protected _evaluate(options?: Partial<Omit<Options, 'async'>>): Promise<this>;
+    protected _evaluate(options?: InexactPartial<Omit<Options, 'async'>>): Promise<this>;
 
     /**
      * Evaluate the roll synchronously.
      * A temporary helper method used to migrate behavior from 0.7.x (sync by default) to 0.9.x (async by default).
      */
-    protected _evaluateSync(options?: Partial<Omit<Options, 'async'>>): this;
+    protected _evaluateSync(options?: InexactPartial<Omit<Options, 'async'>>): this;
 
     /**
      * Safely evaluate the final total result for the Roll using its component terms.
@@ -172,9 +173,9 @@ declare global {
      * Alias for evaluate.
      * @see Roll#evaluate
      */
-    roll(options?: Partial<Options & { async: false }>): this;
-    roll(options: Partial<Options> & { async: true }): Promise<this>;
-    roll(options?: Partial<Options>): this | Promise<this>;
+    roll(options?: InexactPartial<Options & { async: false }>): this;
+    roll(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    roll(options?: InexactPartial<Options>): this | Promise<this>;
 
     /**
      * Create a new Roll object using the original provided formula and data.
@@ -182,9 +183,9 @@ declare global {
      * @param options - Evaluation options passed to Roll#evaluate
      * @returns A new Roll object, rolled using the same formula and data
      */
-    reroll(options?: Partial<Options & { async: false }>): this;
-    reroll(options: Partial<Options> & { async: true }): Promise<this>;
-    reroll(options?: Partial<Options>): this | Promise<this>;
+    reroll(options?: InexactPartial<Options & { async: false }>): this;
+    reroll(options: InexactPartial<Options> & { async: true }): Promise<this>;
+    reroll(options?: InexactPartial<Options>): this | Promise<this>;
 
     /**
      * A factory method which constructs a Roll instance using the default configured Roll class.
@@ -197,7 +198,7 @@ declare global {
     static create<D extends Record<string, unknown> = {}>(
       formula: string,
       data?: D,
-      options?: Partial<Options>
+      options?: InexactPartial<Options>
     ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<D>;
 
     /**
@@ -229,7 +230,7 @@ declare global {
      *                  (default: `10000`)
      * @returns The rolled totals
      */
-    static simulate(formula: string, n?: number): number[];
+    static simulate(formula: string, n?: number): Promise<number[]>;
 
     /**
      * Parse a formula by following an order of operations:
@@ -302,7 +303,7 @@ declare global {
      *                   (default: `{}`)
      * @returns An array of terms, split on dice pool terms
      */
-    protected _splitGroup(_formula: string, options?: Partial<SplitGroupOptions>): string[];
+    protected _splitGroup(_formula: string, options?: InexactPartial<SplitGroupOptions>): string[];
 
     /**
      * Split a formula by identifying arithmetic terms
@@ -373,15 +374,15 @@ declare global {
      */
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData?: T,
-      { rollMode, create }?: { rollMode?: foundry.CONST.DiceRollMode; create?: true }
+      { rollMode, create }?: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create?: true }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DiceRollMode; create: false }
+      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: false }
     ): MessageData<T>;
     toMessage<T extends DeepPartial<ConstructorParameters<ConfiguredDocumentClass<typeof ChatMessage>>[0]> = {}>(
       messageData: T,
-      { rollMode, create }: { rollMode?: foundry.CONST.DiceRollMode; create: boolean }
+      { rollMode, create }: { rollMode?: foundry.CONST.DICE_ROLL_MODES; create: boolean }
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof ChatMessage>> | undefined> | MessageData<T>;
 
     /**
@@ -441,13 +442,8 @@ declare global {
      */
     static fromTerms(
       terms: RollTerm[],
-      options?: Partial<Options>
+      options?: InexactPartial<Options>
     ): typeof CONFIG.Dice.rolls extends [infer T] ? T : Roll<{}>;
-
-    /**
-     * @deprecated since 0.8.1
-     */
-    get _rolled(): boolean;
   }
 }
 
@@ -488,19 +484,12 @@ interface SplitGroupOptions {
 interface Data {
   formula: string;
   results: Array<number | string>;
-  terms: Array<(PoolTerm.TermData & { class: 'DicePool' }) | DiceTerm.Data>;
+  terms: Array<PoolTerm.TermData | DiceTerm.Data>;
   total: number | null;
 }
 
 type Flavor = Record<`%F${number}%`, string>;
 
-/**
- * @deprecated since 0.8.1
- */
-interface MathProxy extends Math {
-  safeEval: (arg: Parameters<typeof Roll['safeEval']>) => ReturnType<typeof Roll['safeEval']>;
-}
-
 type MessageData<T extends DeepPartial<ConstructorParameters<typeof ChatMessage>[0]>> = {
   user: string;
   type: typeof foundry.CONST.CHAT_MESSAGE_TYPES['ROLL'];

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

@@ -41,14 +41,17 @@ declare abstract class RollTerm {
   /** Optional flavor text which modifies and describes this term. */
   get flavor(): string;
 
+  /** Whether this term is entirely deterministic or contains some randomness. */
+  get isDeterministic(): boolean;
+
   /**
    * Evaluate the roll term, populating the results Array.
    * @param options - (default: `{}`)
    * @returns The evaluated dice term
    */
-  evaluate(options?: Partial<RollTerm.EvaluationOptions & { async: false }>): this;
-  evaluate(options: Partial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
-  evaluate(options?: Partial<RollTerm.EvaluationOptions>): this | Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions & { async: false }>): this;
+  evaluate(options: InexactPartial<RollTerm.EvaluationOptions> & { async: true }): Promise<this>;
+  evaluate(options?: InexactPartial<RollTerm.EvaluationOptions>): this | Promise<this>;
 
   protected _evaluate({ minimize, maximize }?: { minimize?: boolean; maximize?: boolean }): Promise<this>;
 
@@ -107,7 +110,7 @@ declare namespace RollTerm {
     /**
      * Evaluate the roll asynchronously, receiving a Promise as the returned value.
      * This will become the default behavior in version 10.x
-     * @defaultValue `false`
+     * @defaultValue `true`
      */
     async: boolean;
   }