@league-of-foundry-developers/foundry-vtt-types 0.8.9-3 → 0.8.9-4

package/src/foundry/foundry.js/clientDocuments/rollTable.d.ts

@@ -1,16 +1,221 @@
-// TODO
+import { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
+
 declare global {
   /**
-   * The client-side RollTable document which extends the common BaseRollTable abstraction.
+   * The client-side RollTable document which extends the common BaseRollTable model.
    * Each RollTable document contains RollTableData which defines its data schema.
    *
    * @see {@link data.RollTableData}              The RollTable data schema
    * @see {@link documents.RollTables}            The world-level collection of RollTable documents
    * @see {@link applications.RollTableConfig}    The RollTable configuration application
-   *
-   * @param data - Initial data provided to construct the RollTable document
    */
-  class RollTable extends ClientDocumentMixin(foundry.documents.BaseRollTable) {}
-}
+  class RollTable extends ClientDocumentMixin(foundry.documents.BaseRollTable) {
+    /**
+     * @param data    - Initial data provided to construct the RollTable document
+     * @param context - The document context, see {@link foundry.abstract.Document}
+     */
+    constructor(
+      data: ConstructorParameters<typeof foundry.documents.BaseRollTable>[0],
+      context?: ConstructorParameters<typeof foundry.documents.BaseRollTable>[1]
+    );
+
+    /**
+     * Display a result drawn from a RollTable in the Chat Log along.
+     * Optionally also display the Roll which produced the result and configure aspects of the displayed messages.
+     *
+     * @param results - An Array of one or more TableResult Documents which were drawn and should be displayed
+     * @param options - Additional options which modify message creation
+     */
+    toMessage(
+      results: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[],
+      options?: Partial<RollTable.ToMessageOptions>
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseChatMessage>> | undefined>;
+
+    /**
+     * Draw a result from the RollTable based on the table formula or a provided Roll instance
+     * @param options - Optional arguments which customize the draw behavior
+     * @returns A Promise which resolves to an object containing the executed roll and the produced results
+     */
+    draw(options?: RollTable.DrawOptions): Promise<RollTableDraw>;
+
+    /**
+     * Draw multiple results from a RollTable, constructing a final synthetic Roll as a dice pool of inner rolls.
+     * @param number  - The number of results to draw
+     * @param options - Optional arguments which customize the draw
+     * @returns The drawn results
+     */
+    drawMany(number: number, options?: Partial<RollTable.DrawOptions>): Promise<RollTableDraw>;
+
+    /**
+     * Normalize the probabilities of rolling each item in the RollTable based on their assigned weights
+     */
+    normalize(): Promise<this | undefined>;
+
+    /**
+     * Reset the state of the RollTable to return any drawn items to the table
+     * @remarks Actually, returns list of TableEntries updated, not the RollTable.
+     * As written, it force updates all records, not just the ones already drawn.
+     */
+    reset(): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[]>;
+
+    /**
+     * Evaluate a RollTable by rolling its formula and retrieving a drawn result.
+     *
+     * Note that this function only performs the roll and identifies the result, the RollTable#draw function should be
+     * called to formalize the draw from the table.
+     *
+     * @example
+     * ```typescript
+     * // Draw results using the default table formula
+     * const defaultResults = await table.roll();
+     *
+     * // Draw results using a custom roll formula
+     * const roll = new Roll("1d20 + @abilities.wis.mod", actor.getRollData());
+     * const customResults = await table.roll({roll});
+     * ```
+     */
+    roll(options?: RollTable.RollOptions): Promise<RollTableDraw>;
+
+    /**
+     * Get an Array of valid results for a given rolled total
+     * @param value - The rolled value
+     * @returns An Array of results
+     */
+    getResultsForRoll(value: number): InstanceType<ConfiguredDocumentClass<typeof TableResult>>[];
+
+    /** @override */
+    protected _onCreateEmbeddedDocuments(
+      embeddedName: string,
+      documents: foundry.abstract.Document<any, any>[],
+      result: Record<string, unknown>[],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
+    /** @override */
+    _onDeleteEmbeddedDocuments(
+      embeddedName: string,
+      documents: InstanceType<ConfiguredDocumentClass<typeof TableResult>>[],
+      result: string[],
+      options: DocumentModificationContext,
+      userId: string
+    ): void;
+
+    /** @override */
+    toCompendium(pack?: CompendiumCollection<CompendiumCollection.Metadata>): Omit<
+      foundry.data.RollTableData['_source'],
+      '_id' | 'folder' | 'permission'
+    > & {
+      permission?: foundry.data.RollTableData extends { toObject(): infer U } ? U : never;
+    };
+
+    /**
+     * Create a new RollTable entity using all of the Entities from a specific Folder as new results.
+     * @param folder  - The Folder entity from which to create a roll table
+     * @param options - Additional options passed to the RollTable.create method
+     */
+    static fromFolder(
+      folder: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseFolder>>,
+      options?: DocumentModificationOptions
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseRollTable>> | undefined>;
+
+    /**
+     * The RollTable#getTableResult method is deprecated in favor of RollTable#results#get and will be removed in 0.9.0
+     * @deprecated since 0.8.0
+     */
+    getTableResult(id: string): ReturnType<this['results']['get']>;
+  }
 
+  namespace RollTable {
+    /**
+     * Optional arguments which customize the draw
+     */
+    interface DrawOptions {
+      /**
+       * An existing Roll instance to use for drawing from the table
+       */
+      roll: Roll;
+
+      /**
+       * Allow drawing recursively from inner RollTable results
+       * @defaultValue `true`
+       */
+      recursive: boolean;
+
+      /**
+       * One or more table results which have been drawn
+       * @defaultValue `[]`
+       */
+      results: foundry.data.TableResultData[];
+
+      /**
+       * Whether to automatically display the results in chat
+       * @defaultValue `true`
+       */
+      displayChat: boolean;
+
+      /**
+       * The chat roll mode to use when displaying the result
+       */
+      rollMode: foundry.CONST.DiceRollMode;
+    }
+
+    /**
+     * Additional options which modify message creation
+     */
+    interface ToMessageOptions {
+      /**
+       * An optional Roll instance which produced the drawn results
+       */
+      roll: Roll | null;
+
+      /**
+       * Additional data which customizes the created messages
+       * @defaultValue `{}`
+       */
+      messageData: ConstructorParameters<typeof foundry.documents.BaseChatMessage>[0];
+
+      /**
+       * Additional options which customize the created messages
+       * @defaultValue `{}`
+       */
+      messageOptions: ConstructorParameters<typeof foundry.documents.BaseChatMessage>[1];
+    }
+
+    interface RollOptions {
+      /**
+       * An alternative dice Roll to use instead of the default formula for the table
+       */
+      roll?: Roll;
+
+      /**
+       * If a RollTable entity is drawn as a result, recursively roll it
+       * @defaultValue `true`
+       */
+      recursive?: boolean;
+
+      /**
+       * An internal flag used to track recursion depth
+       * @defaultValue `0`
+       */
+      _depth?: number;
+    }
+  }
+
+  /**
+   * An object containing the executed Roll and the produced results
+   */
+  interface RollTableDraw {
+    /**
+     * The Dice roll which generated the draw
+     */
+    roll: Roll;
+
+    /**
+     * An array of drawn TableResult documents
+     */
+    results: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseTableResult>>[];
+  }
+}
 export {};

package/src/foundry/foundry.js/clientDocuments/tableResult.d.ts

@@ -0,0 +1,30 @@
+declare global {
+  /**
+   * The client-side TableResult document which extends the common BaseTableResult model.
+   * Each TableResult belongs to the results collection of a RollTable entity.
+   * Each TableResult contains a TableResultData object which provides its source data.
+   *
+   * @see {@link data.TableResultData}        The TableResult data schema
+   * @see {@link documents.RollTable}         The RollTable document which contains TableResult embedded documents
+   */
+  class TableResult extends ClientDocumentMixin(foundry.documents.BaseTableResult) {
+    /**
+     * @param data   - Initial data provided to construct the TableResult document
+     * @param parent - The parent RollTable document to which this result belongs
+     */
+    constructor(...args: ConstructorParameters<typeof foundry.documents.BaseTableResult>);
+
+    /**
+     * A path reference to the icon image used to represent this result
+     */
+    get icon(): string;
+
+    /**
+     * Prepare a string representation for the result which (if possible) will be a dynamic link or otherwise plain text
+     * @returns The text to display
+     */
+    getChatText(): string;
+  }
+}
+
+export {};

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

@@ -1562,7 +1562,7 @@ declare global {
       /**
        * @defaultValue `TableResult`
        */
-      documentClass: ConfiguredDocumentClassOrDefault<typeof foundry.documents.BaseTableResult>; // TODO TableResult
+      documentClass: ConfiguredDocumentClassOrDefault<typeof TableResult>;
     };
 
     /**

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

@@ -113,6 +113,19 @@ declare global {
    * This is only for debugging, and may be removed in the future, so it's not safe to use.
    */
   let _token: InstanceType<CONFIG['Token']['objectClass']> | null;
+
+  /*
+   * Global Vairables
+   * The following variables are declared directly in foundry's HTML file (or more concretely, in `main.hbs`)
+   */
+
+  const SIGNED_EULA: boolean;
+
+  const ROUTE_PREFIX: string;
+
+  const MESSAGES:
+    | { type: Notifications.Notification['type']; message: string; options: Notifications.Options }[]
+    | null;
 }
 
 export {};

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

@@ -1,4 +1,7 @@
 import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { DocumentModificationOptions } from '../../../../common/abstract/document.mjs';
+import type { WallData } from '../../../../common/data/data.mjs';
+import type { HoverInOptions } from '../placeableObject';
 
 declare global {
   /**
@@ -6,35 +9,35 @@ declare global {
    * Walls are used to restrict Token movement or visibility as well as to define the areas of effect for ambient lights
    * and sounds.
    *
+   * @see {@link WallDocument}
    * @see {@link WallsLayer}
    * @see {@link WallConfig}
-   *
-   * @example
-   * ```typescript
-   * Wall.create<Wall>({
-   *  c = [100, 200, 400, 600],
-   *  move: CONST.WALL_MOVEMENT_TYPES.NORMAL,
-   *  sense: CONST.WALL_SENSE_TYPES.NORMAL,
-   *  dir: CONST.WALL_DIRECTIONS.BOTH,
-   *  door: CONST.WALL_DOOR_TYPES.DOOR,
-   *  ds: CONST.WALL_DOOR_STATES.CLOSED
-   * });
-   * ```
    */
-  class Wall extends PlaceableObject<InstanceType<ConfiguredDocumentClass<typeof WallDocument>>> {
+  class Wall extends PlaceableObject<ConcreteWallDocument> {
     /**
      * @remarks Not used for `Wall`
      */
     controlIcon: null;
+
     /**
      * @remarks Type is `MouseInteractionManager<this, this['endpoints']>`
      */
     mouseInteractionManager: MouseInteractionManager<this, any> | null;
 
+    constructor(document: ConcreteWallDocument);
+
     /**
      * An reference the Door Control icon associated with this Wall, if any
+     * @internal
+     * @defaultValue `null`
      */
-    protected doorControl: DoorControl | null;
+    doorControl: DoorControl | null;
+
+    /**
+     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
+     * @defaultValue `undefined`
+     */
+    roof: Tile | undefined;
 
     /** @override */
     static get embeddedName(): 'Wall';
@@ -42,7 +45,7 @@ declare global {
     /**
      * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
      */
-    get coords(): Wall.Data['c'];
+    get coords(): Wall['data']['c'];
 
     /** @override */
     get bounds(): NormalizedRectangle;
@@ -50,7 +53,7 @@ declare global {
     /**
      * Return the coordinates [x,y] at the midpoint of the wall segment
      */
-    get midpoint(): [number, number];
+    get midpoint(): PointArray;
 
     /** @override */
     get center(): PIXI.Point;
@@ -70,8 +73,6 @@ declare global {
     /** @override */
     draw(): Promise<this>;
 
-    endpoints: PIXI.Graphics;
-
     /** @override */
     protected _createInteractionManager(): NonNullable<this['mouseInteractionManager']>;
 
@@ -82,7 +83,7 @@ declare global {
      * Draw a directional prompt icon for one-way walls to illustrate their direction of effect.
      * @returns The drawn icon
      */
-    protected _drawDirection(): PIXI.Sprite | void; // TODO: returning void may be unreachable
+    protected _drawDirection(): PIXI.Sprite | null;
 
     /** @override */
     refresh(): this;
@@ -92,26 +93,33 @@ declare global {
      * @param coords - The original wall coordinates
      * @param pad    - The amount of padding to apply
      * @returns A constructed Polygon for the line
+     * @internal
      */
     protected _getWallHitPolygon(coords: [number, number, number, number], pad: number): PIXI.Polygon;
 
     /**
      * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
+     * @internal
      */
     protected _getWallColor(): number;
 
-    /** @override */
+    /**
+     * @override
+     * @param chain - (default: `false`)
+     */
     protected _onControl({ chain }?: PlaceableObject.ControlOptions & { chain?: boolean }): void;
 
     /** @override */
-    protected _onRelease(): void;
+    protected _onRelease(options?: PlaceableObject.ReleaseOptions): void;
 
     /** @override */
-    destroy(options?: { children?: boolean; texture?: boolean; baseTexture?: boolean }): void;
+    destroy(options?: Parameters<PIXI.Container['destroy']>[0]): void;
 
     /**
      * Test whether the Wall direction lies between two provided angles
      * This test is used for collision and vision checks against one-directional walls
+     * @param lower - The lower-bound limiting angle in radians
+     * @param upper - The upper-bound limiting angle in radians
      */
     isDirectionBetweenAngles(lower: number, upper: number): boolean;
 
@@ -127,37 +135,44 @@ declare global {
      * @returns An object reporting ids and endpoints of the linked segments
      */
     getLinkedSegments(): {
-      ids: string;
-      walls: Wall[];
+      ids: string[];
+      walls: WallsLayer['placeables'];
       endpoints: Array<[number, number]>;
     };
 
     /** @override */
-    protected _onCreate(): void;
+    protected _onCreate(data: WallData['_source'], options: DocumentModificationOptions, userId: string): void;
 
     /** @override */
-    protected _onUpdate(changed: DeepPartial<foundry.data.WallData>, options?: any, userId?: string): void;
+    protected _onUpdate(
+      changed: DeepPartial<WallData['_source']>,
+      options?: DocumentModificationOptions,
+      userId?: string
+    ): void;
 
     /** @override */
-    protected _onDelete(): void;
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
     /**
      * Callback actions when a wall that contains a door is moved or its state is changed
      * @param doorChange - Update vision and sound restrictions
+     *                     (default: `false`)
+     * @internal
      */
     protected _onModifyWall(doorChange?: boolean): Promise<void>;
 
     /** @override */
-    protected _canControl(user?: User, event?: PIXI.InteractionEvent): boolean;
+    protected _canControl(user: InstanceType<ConfiguredDocumentClass<typeof User>>, event?: any): boolean;
 
     /** @override */
-    protected _onHoverIn(event: PIXI.InteractionEvent, options?: { hoverOutOthers: boolean }): void;
+    protected _onHoverIn(event: PIXI.InteractionEvent, options?: HoverInOptions): false | void;
 
     /** @override */
-    protected _onHoverOut(event: PIXI.InteractionEvent): void;
+    protected _onHoverOut(event: PIXI.InteractionEvent): false | void;
 
     /**
      * Handle mouse-hover events on the line segment itself, pulling the Wall to the front of the container stack
+     * @internal
      */
     protected _onMouseOverLine(event: PIXI.InteractionEvent): void;
 
@@ -179,42 +194,6 @@ declare global {
     /** @override */
     protected _onDragLeftDrop(event: PIXI.InteractionEvent): Promise<any>;
   }
-
-  namespace Wall {
-    interface Data {
-      /**
-       * Coordinates of the endpoints
-       */
-      c: [number, number, number, number];
-      /**
-       * 0 - both
-       * 1 - left
-       * 2 - right
-       */
-      dir?: foundry.CONST.WallDirection;
-      /**
-       * 0 - wall
-       * 1 - door
-       * 2 - secret
-       */
-      door: foundry.CONST.WallDoorType;
-      /**
-       * 0 - closed
-       * 1 - open
-       * 2 - locked
-       */
-      ds: foundry.CONST.WallDoorState;
-      /**
-       * 0 - blocked
-       * 1 - allowed
-       */
-      move: foundry.CONST.WallMovementType;
-      /**
-       * 0 - opaque
-       * 1 - transparent
-       * 2 - terrain
-       */
-      sense: foundry.CONST.WallSenseType;
-    }
-  }
 }
+
+type ConcreteWallDocument = InstanceType<ConfiguredDocumentClass<typeof WallDocument>>;

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

@@ -18,12 +18,13 @@ declare abstract class AbstractBaseMaskFilter extends PIXI.Filter {
    * @param defaultUniforms - Initial uniforms provided to the filter
    *                          (default: `{}`)
    * @param channel         - A color channel to target for masking.
-   *                          (default: `r`)
+   *                          (default: `'r'`)
    */
-  static create(
+  static create<T extends AbstractBaseMaskFilter>(
+    this: ConstructorOf<T>,
     defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
     channel?: 'r' | 'g' | 'b'
-  ): AbstractBaseMaskFilter;
+  ): T;
 
   /**
    * @override

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

@@ -0,0 +1 @@
+import './inverseOcclusionMaskFilter';

package/src/foundry/foundry.js/pixi/filters/abstractBaseMaskFilters/inverseOcclusionMaskFilter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A filter used to control channels intensity using an externally provided mask texture.
+ * The mask channel used must be provided at filter creation.
+ * Contributed by SecretFire#4843
+ */
+declare class InverseOcclusionMaskFilter extends AbstractBaseMaskFilter {
+  static fragmentShader(channel: 'r' | 'g' | 'b'): string;
+
+  /**
+   * @param defaultUniforms - (default: `{}`)
+   * @param channel  - (default `'r'`)
+   */
+  static create<T extends InverseOcclusionMaskFilter>(
+    this: ConstructorOf<T>,
+    defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
+    channel?: 'r' | 'g' | 'b'
+  ): T;
+}

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

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

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

@@ -12,21 +12,10 @@ declare class SpecialEffect {
 
   /**
    * Use this flag as a way to pass a stop signal into the animation frame
+   * @internal
    */
   protected _stop: boolean | null;
 
-  static get label(): string;
-
-  static get effectOptions(): SpecialEffect.Options;
-
-  getParticleEmitters(): PIXI.particles.Emitter[];
-
-  play(duration: number): void;
-
-  stop(): void;
-
-  protected _startEmitter(emitter: PIXI.particles.Emitter): void;
-
   static OPTION_TYPES: {
     VALUE: 1;
     CHECKBOX: 2;
@@ -51,6 +40,39 @@ declare class SpecialEffect {
    * ```
    */
   static DEFAULT_CONFIG: PIXI.particles.EmitterConfig | PIXI.particles.OldEmitterConfig;
+
+  /**
+   * @defaultValue `'Special Effect'`
+   */
+  static get label(): string;
+
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   density: {
+   *     label: "Particle Density",
+   *     type: this.OPTION_TYPES.RANGE,
+   *     value: 0.5,
+   *     min: 0.1,
+   *     max: 5,
+   *     step: 0.1
+   *   }
+   * }
+   * ```
+   */
+  static get effectOptions(): SpecialEffect.Options;
+
+  getParticleEmitters(): PIXI.particles.Emitter[];
+
+  play(duration: number): void;
+
+  stop(): void;
+
+  /**
+   * @internal
+   */
+  protected _startEmitter(emitter: PIXI.particles.Emitter): void;
 }
 
 declare namespace SpecialEffect {

package/src/foundry/foundry.js/specialEffects/autumnLeavesWeatherEffect.d.ts

@@ -1,17 +1,14 @@
 /**
  * A special full-screen weather effect which uses one Emitters to render gently falling autumn leaves
  */
-
 declare class AutumnLeavesWeatherEffect extends SpecialEffect {
+  /**
+   * @defaultValue `'Autumn Leaves'`
+   */
   static get label(): string;
 
-  static get effectOptions(): SpecialEffect.Options;
-
-  getParticleEmitters(): PIXI.particles.Emitter[];
-
-  protected _getLeafEmitter(parent: PIXI.Container): PIXI.particles.Emitter;
-
   /**
+   * Configuration for the falling leaves particle effect
    * @defaultValue
    * ```typescript
    * {
@@ -55,4 +52,28 @@ declare class AutumnLeavesWeatherEffect extends SpecialEffect {
    * ```
    */
   static LEAF_CONFIG: PIXI.particles.EmitterConfig | PIXI.particles.OldEmitterConfig;
+
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   density: {
+   *     label: "Particle Density",
+   *     type: this.OPTION_TYPES.RANGE,
+   *     value: 1,
+   *     min: 0.05,
+   *     max: 1,
+   *     step: 0.05
+   *   }
+   * }
+   * ```
+   */
+  static get effectOptions(): SpecialEffect.Options;
+
+  getParticleEmitters(): PIXI.particles.Emitter[];
+
+  /**
+   * @internal
+   */
+  protected _getLeafEmitter(parent: PIXI.Container): PIXI.particles.Emitter;
 }

package/src/foundry/foundry.js/specialEffects/index.d.ts

@@ -0,0 +1,3 @@
+import './autumnLeavesWeatherEffect';
+import './rainWeatherEffect';
+import './snowWeatherEffect';