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

package/src/foundry/foundry.js/applications/formApplications/tokenConfig.d.ts

@@ -1,175 +1,162 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
-/**
- * A Token Configuration Application
- * @typeParam P - the type of the options object
- */
-declare class TokenConfig<P extends TokenConfig.Options = TokenConfig.Options> extends FormApplication<
-  P,
-  TokenConfig.Data,
-  Token
-> {
-  /**
-   * @param token   - The Token object for which settings are being configured
-   * @param options - TokenConfig ui options (see Application)
-   */
-  constructor(token: Token, options?: Partial<P>);
-
-  /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   classes: ["sheet", "token-sheet"],
-   *   template: "templates/scene/token-config.html",
-   *   width: 480,
-   *   height: "auto",
-   *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "character"}]
-   * });
-   * ```
-   */
-  static get defaultOptions(): TokenConfig.Options;
-
-  /** @override */
-  get id(): string;
+import type { ConfiguredDocumentClassForName } from '../../../../types/helperTypes';
+import type { TokenDataConstructorData } from '../../../common/data/data.mjs/tokenData.js';
 
+declare global {
   /**
-   * Convenience access for the Token object
+   * The Application responsible for configuring a single Token document within a parent Scene.
+   * @typeParam Options - The type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
    */
-  get token(): this['object'];
+  class TokenConfig<
+    Options extends FormApplication.Options = FormApplication.Options,
+    Data extends object = TokenConfig.Data<Options>
+  > extends FormApplication<
+    Options,
+    Data,
+    InstanceType<ConfiguredDocumentClassForName<'Token'>> | InstanceType<ConfiguredDocumentClassForName<'Actor'>>
+  > {
+    constructor(
+      object:
+        | InstanceType<ConfiguredDocumentClassForName<'Token'>>
+        | InstanceType<ConfiguredDocumentClassForName<'Actor'>>,
+      options?: Partial<Options>
+    );
+
+    token: InstanceType<ConfiguredDocumentClassForName<'Token'>> | PrototypeTokenDocument;
 
-  /**
-   * Convenience access for the Token's linked Actor, if any
-   */
-  get actor(): this['token']['actor'];
-
-  /** @override */
-  get title(): string;
-
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<P>): Promise<TokenConfig.Data>;
-
-  /** @override */
-  render(force?: boolean, options?: Application.RenderOptions<P>): Promise<void>;
-
-  /**
-   * Inspect the Actor data model and identify the set of attributes which could be used for a Token Bar
-   */
-  static getTrackedAttributeChoices(attributes: TokenConfig.Attributes): Partial<Record<string, string[]>>;
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "token-sheet"],
+     *   template: "templates/scene/token-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [{ navSelector: ".tabs", contentSelector: "form", initial: "character" }],
+     * })
+     * ```
+     */
+    static get defaultOptions(): FormApplication.Options;
 
-  /**
-   * Test whether an individual data object is a valid attribute - containing both a "value" and "max" field
-   * @param data  - The data object to search
-   * @param _path - The attribute path being recursed
-   *                (default: `[]`)
-   * @returns An object containing both bar and value attribute paths
-   */
-  protected static getTrackedAttributes(data: object, _path: string[]): TokenConfig.Attributes;
+    /** @override */
+    get id(): string;
 
-  /**
-   * Get an Object of image paths and filenames to display in the Token sheet
-   */
-  protected _getAlternateTokenImages(): Promise<Partial<Record<string, string>>>;
+    /**
+     * A convenience accessor to test whether we are configuring the prototype Token for an Actor.
+     */
+    get isPrototype(): boolean;
 
-  /** @override */
-  activateListeners(html: JQuery): void;
+    /**
+     * Convenience access to the Actor document that this Token represents
+     */
+    get actor(): InstanceType<ConfiguredDocumentClassForName<'Actor'>>;
 
-  /** @override */
-  protected _getSubmitData(
-    updateData?: TokenConfig.FormData
-  ): ReturnType<FormApplication['_getSubmitData']> & { lightAlpha: number };
+    /** @override */
+    get title(): string;
 
-  /** @override */
-  protected _updateObject(event: Event, formData: TokenConfig.FormData): Promise<void>;
+    /** @override */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
 
-  /**
-   * Update certain fields of a linked actor token when token configuration is changed
-   * @param tokenData - The new token data
-   */
-  protected _updateActorData(tokenData: TokenConfig.FormData): ReturnType<Actor['update']> | void;
+    /** @override */
+    render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<this>;
 
-  /**
-   * Handle Token assignment requests to update the default prototype Token
-   * @param event - The left-click event on the assign token button
-   */
-  protected _onAssignToken(event: JQuery.ClickEvent): Promise<void>;
+    /**
+     * Get an Object of image paths and filenames to display in the Token sheet
+     * @internal
+     */
+    protected _getAlternateTokenImages(): Promise<Record<string, string>>;
 
-  /**
-   * Handle changing the attribute bar in the drop-down selector to update the default current and max value
-   */
-  protected _onBarChange(ev: JQuery.ChangeEvent): Promise<void>;
-}
+    /** @override */
+    activateListeners(html: JQuery): void;
 
-declare namespace TokenConfig {
-  interface Attributes {
-    bar: string[][];
-    value: string[][];
-  }
+    /** @override */
+    protected _getSubmitData(updateData?: TokenDataConstructorData): Record<string, unknown> & { lightAlpha: number };
 
-  interface Data {
-    cssClasses: 'prototype' | '';
-    isPrototype: Options['configureDefault'];
-    hasAlternates: boolean;
-    alternateImages: TokenConfig['_getAlternateTokenImages'] | [];
-    object: foundry.utils.Duplicated<TokenConfig['token']['data']>;
-    options: TokenConfig['options'];
-    gridUnits: Scene['data']['gridUnits'] | Game['system']['gridUnits'];
-    barAttributes: ReturnType<typeof TokenConfig['getTrackedAttributeChoices']>;
-    bar1: ReturnType<TokenConfig['object']['getBarAttribute']>;
-    bar2: ReturnType<TokenConfig['object']['getBarAttribute']>;
-    displayModes: Record<foundry.CONST.TokenDisplayMode, string>;
-    actors: Array<Pick<Actor, '_id' | 'name'>>;
-    dispositions: Record<foundry.CONST.TokenDisposition, string>;
-    lightAnimations: { [Key in keyof typeof CONFIG['Canvas']['lightAnimations']]: string } & { '': 'None' };
-    lightAlpha: number;
-    isGM: User['isGM'];
-  }
+    /** @override */
+    protected _updateObject(
+      event: Event,
+      formData: TokenConfig.FormData
+    ): Promise<
+      | InstanceType<ConfiguredDocumentClassForName<'Token'>>
+      | InstanceType<ConfiguredDocumentClassForName<'Actor'>>
+      | undefined
+    >;
 
-  interface FormData {
-    actorId: Token.Data['actorId'];
-    actorLink: Token.Data['actorLink'];
-    alternateImages?: string;
-    'bar1.attribute': Token.Data['bar1']['attribute'];
-    'bar2.attribute': Token.Data['bar2']['attribute'];
-    brightLight: Token.Data['brightLight'] | null;
-    brightSight: Token.Data['brightSight'] | null;
-    dimLight: Token.Data['dimLight'] | null;
-    dimSight: Token.Data['dimSight'] | null;
-    displayBars: Token.Data['displayBars'];
-    displayName: Token.Data['displayName'];
-    disposition: Token.Data['disposition'];
-    elevation: Token.Data['elevation'] | null;
-    height: Token.Data['height'] | null;
-    img: Token.Data['img'];
-    lightAlpha: Token.Data['lightAlpha'];
-    lightAngle: Token.Data['lightAngle'] | null;
-    'lightAnimation.intensity': Token.Data['lightAnimation']['intensity'];
-    'lightAnimation.speed': Token.Data['lightAnimation']['speed'];
-    'lightAnimation.type': Token.Data['lightAnimation']['type'];
-    lightColor: Token.Data['lightColor'];
-    lockRotation: Token.Data['lockRotation'];
-    mirrorX: Token.Data['mirrorX'];
-    mirrorY: Token.Data['mirrorY'];
-    name: Token.Data['name'];
-    rotation: Token.Data['rotation'] | null;
-    scale: Token.Data['scale'];
-    sightAngle: Token.Data['sightAngle'] | null;
-    tint: Token.Data['tint'];
-    vision: Token.Data['vision'];
-    width: Token.Data['width'] | null;
-    x: Token.Data['x'] | null;
-    y: Token.Data['y'] | null;
-  }
+    /**
+     * Handle Token assignment requests to update the default prototype Token
+     * @param event - The left-click event on the assign token button
+     * @internal
+     */
+    protected _onAssignToken(event: JQuery.ClickEvent): void;
 
-  interface Options extends FormApplication.Options {
     /**
-     * Configure the default actor token on submit
+     * Handle changing the attribute bar in the drop-down selector to update the default current and max value
+     * @internal
      */
-    configureDefault?: boolean;
+    protected _onBarChange(ev: JQuery.ChangeEvent): void;
+  }
+
+  namespace TokenConfig {
+    interface Attributes {
+      bar: string[][];
+      value: string[][];
+    }
+
+    interface Data<Options extends FormApplication.Options = FormApplication.Options> {
+      cssClasses: string;
+      isPrototype: boolean;
+      hasAlternates: boolean;
+      alternateImages: Record<string, string> | [];
+      object: foundry.data.PrototypeTokenData | foundry.data.TokenData;
+      options: Options;
+      gridUnits: string | undefined;
+      barAttributes: Record<string, string[]>;
+      bar1: ReturnType<TokenDocument['getBarAttribute']>;
+      bar2: ReturnType<TokenDocument['getBarAttribute']>;
+      displayModes: Record<foundry.CONST.TOKEN_DISPLAY_MODES, string>;
+      actors: { _id: string; name: string }[];
+      dispositions: Record<foundry.CONST.TOKEN_DISPOSITIONS, string>;
+      lightAnimations: { [Key in keyof typeof CONFIG.Canvas.lightAnimations]: string } & { '': string };
+      lightAlpha: number;
+      isGM: boolean;
+    }
+
+    interface FormData {
+      actorId: string;
+      actorLink: boolean;
+      alternateImages?: string;
+      alpha: number;
+      'bar1.attribute': string;
+      'bar2.attribute': string;
+      brightLight: number | null;
+      brightSight: number | null;
+      dimLight: number | null;
+      dimSight: number | null;
+      displayBars: foundry.CONST.TOKEN_DISPLAY_MODES;
+      displayName: foundry.CONST.TOKEN_DISPLAY_MODES;
+      disposition: foundry.CONST.TOKEN_DISPOSITIONS;
+      elevation: number | null;
+      height: number | null;
+      img: string;
+      lightAlpha: number;
+      lightAngle: number | null;
+      'lightAnimation.intensity': number;
+      'lightAnimation.speed': number;
+      'lightAnimation.type': string;
+      lightColor: string;
+      lockRotation: boolean;
+      mirrorX: boolean;
+      mirrorY: boolean;
+      name: StringTerm;
+      rotation: number | null;
+      scale: number;
+      sightAngle: number | null;
+      tint: string;
+      vision: boolean;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+    }
   }
 }

package/src/foundry/foundry.js/applications/formApplications/wallConfig.d.ts

@@ -1,82 +1,72 @@
-/**
- * Wall Configuration Sheet
- */
-declare class WallConfig<P extends WallConfig.Options = WallConfig.Options> extends FormApplication<
-  P,
-  WallConfig.Data,
-  Wall
-> {
-  /**
-   * @param object  - The Wall object for which settings are being configured
-   * @param options - Additional options which configure the rendering of the configuration sheet.
-   */
-  constructor(object: Wall, options?: Partial<P>);
+import type { ConfiguredDocumentClassForName } from '../../../../types/helperTypes';
 
+declare global {
   /**
-   * @defaultValue
-   * ```typescript
-   * const options = super.defaultOptions;
-   * options.id = "wall-config";
-   * options.title = "Wall Configuration";
-   * options.template = "templates/scene/wall-config.html";
-   * options.width = 400;
-   * options.editTargets = [];
-   * ```
+   * The Application responsible for configuring a single Wall document within a parent Scene.
+   * @typeParam Options - The type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
    */
-  static get defaultOptions(): WallConfig.Options;
+  class WallConfig<
+    Options extends FormApplication.Options = FormApplication.Options,
+    Data extends object = WallConfig.Data<Options>
+  > extends FormApplication<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Wall'>>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.id = "wall-config";
+     * options.title = "Wall Configuration";
+     * options.template = "templates/scene/wall-config.html";
+     * options.width = 400;
+     * ```
+     */
+    static get defaultOptions(): FormApplication.Options;
 
-  /**
-   * Provide a dynamically rendered title for the Wall Configuration sheet
-   */
-  get title(): string;
+    /** @override */
+    get title(): string;
 
-  /**
-   * Construct and return the data object used to render the HTML template for this form application.
-   */
-  getData(): WallConfig.Data;
+    /** @override */
+    render(force?: boolean, options?: Application.RenderOptions<Options>): this;
 
-  /**
-   * This method is called upon form submission after form data is validated
-   * @param event    - The initial triggering submission event
-   * @param formData - The object of validated form data with which to update the object
-   */
-  protected _updateObject(event: Event, formData: WallConfig.FormData): Promise<Wall>;
-}
+    /** @override */
+    getData(): Data | Promise<Data>;
 
-declare namespace WallConfig {
-  interface Data {
-    object: foundry.utils.Duplicated<WallConfig['object']['data']>;
-    options: WallConfig['options'];
-    moveTypes: {
-      [Key in keyof typeof foundry.CONST['WALL_MOVEMENT_TYPES'] as typeof foundry.CONST['WALL_MOVEMENT_TYPES'][Key]]: Titlecase<Key>;
-    };
-    senseTypes: {
-      [Key in keyof typeof foundry.CONST['WALL_SENSE_TYPES'] as typeof foundry.CONST['WALL_SENSE_TYPES'][Key]]: Titlecase<Key>;
-    };
-    dirTypes: {
-      [Key in keyof typeof foundry.CONST['WALL_DIRECTIONS'] as typeof foundry.CONST['WALL_DIRECTIONS'][Key]]: Titlecase<Key>;
-    };
-    doorTypes: {
-      [Key in keyof typeof foundry.CONST['WALL_DOOR_TYPES'] as typeof foundry.CONST['WALL_DOOR_TYPES'][Key]]: Titlecase<Key>;
-    };
-    doorStates: {
-      [Key in keyof typeof foundry.CONST['WALL_DOOR_STATES'] as typeof foundry.CONST['WALL_DOOR_STATES'][Key]]: Titlecase<Key>;
-    };
-    isDoor: boolean;
+    /** @override */
+    protected _updateObject(
+      event: Event,
+      formData: WallConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Wall'>> | undefined>;
   }
 
-  interface FormData {
-    dir: foundry.CONST.WallDirection;
-    door: Wall['data']['door'];
-    ds?: Wall['data']['ds'];
-    move: Wall['data']['move'];
-    sense: Wall['data']['sense'];
-  }
+  namespace WallConfig {
+    interface Data<Options extends FormApplication.Options = FormApplication.Options> {
+      object: foundry.data.WallData['_source'];
+      options: Options;
+      moveTypes: {
+        [Key in keyof typeof foundry.CONST.WALL_MOVEMENT_TYPES as typeof foundry.CONST.WALL_MOVEMENT_TYPES[Key]]: Titlecase<Key>;
+      };
+      senseTypes: {
+        [Key in keyof typeof foundry.CONST.WALL_SENSE_TYPES as typeof foundry.CONST.WALL_SENSE_TYPES[Key]]: Titlecase<Key>;
+      };
+      dirTypes: {
+        [Key in keyof typeof foundry.CONST.WALL_DIRECTIONS as typeof foundry.CONST.WALL_DIRECTIONS[Key]]: Titlecase<Key>;
+      };
+      doorTypes: {
+        [Key in keyof typeof foundry.CONST.WALL_DOOR_TYPES as typeof foundry.CONST.WALL_DOOR_TYPES[Key]]: Titlecase<Key>;
+      };
+      doorStates: {
+        [Key in keyof typeof foundry.CONST.WALL_DOOR_STATES as typeof foundry.CONST.WALL_DOOR_STATES[Key]]: Titlecase<Key>;
+      };
+      isDoor: boolean;
+    }
 
-  interface Options extends FormApplication.Options {
-    /**
-     * @defaultValue `[]`
-     */
-    editTargets: string[];
+    interface FormData {
+      dir: foundry.CONST.WALL_DIRECTIONS;
+      door: foundry.CONST.WALL_DOOR_TYPES;
+      ds?: foundry.CONST.WALL_DOOR_STATES;
+      move: foundry.CONST.WALL_MOVEMENT_TYPES;
+      sense: foundry.CONST.WALL_SENSE_TYPES;
+      sound: foundry.CONST.WALL_SENSE_TYPES;
+    }
   }
 }

package/src/foundry/foundry.js/applications/formApplications/worldConfig.d.ts

@@ -1,33 +1,33 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
 /**
  * The World Management setup application
+ * @typeParam Options - The type of the options object
+ * @typeParam Data    - The data structure used to render the handlebars template.
  */
-declare class WorldConfig extends FormApplication<WorldConfig.Options, WorldConfig.Data, Game.World> {
+declare class WorldConfig<
+  Options extends WorldConfig.Options = WorldConfig.Options,
+  Data extends object = WorldConfig.Data
+> extends FormApplication<Options, Data, Game.WorldData<foundry.packages.WorldData>> {
   /**
    * @defaultValue
    * ```typescript
-   * mergeObject(super.defaultOptions, {
+   * foundry.utils.mergeObject(super.defaultOptions, {
    *   id: "world-config",
-   *   template: "templates/setup/world-config.html",
+   *   template: "templates/sidebar/apps/world-config.html",
    *   width: 600,
    *   height: "auto",
-   *   create: false
-   * });
+   *   create: false,
+   * })
    * ```
    */
   static get defaultOptions(): WorldConfig.Options;
 
+  static WORLD_KB_URL: 'https://foundryvtt.com/article/game-worlds/';
+
   /** @override */
   get title(): string;
 
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<WorldConfig.Options>): WorldConfig.Data;
+  /** @override */
+  getData(options?: Partial<Options>): Data | Promise<Data>;
 
   /**
    * @remarks This method returns `Promise<void>`.
@@ -39,16 +39,22 @@ declare class WorldConfig extends FormApplication<WorldConfig.Options, WorldConf
    * @remarks This method does not exist on WorldConfig and only exists to make the typescript compile!
    */
   protected _updateObject(...args: unknown[]): Promise<unknown>;
+
+  /** @override **/
+  activateEditor(name: string, options?: TextEditor.Options, initialContent?: string): void;
 }
 
 declare namespace WorldConfig {
   interface Data {
-    world: WorldConfig['object'];
-    systems: Game.System[];
-    isCreate: WorldConfig['options']['create'];
+    world: Game.WorldData<foundry.packages.WorldData>;
+    isCreate: boolean;
     submitText: string;
     nextDate: string;
     nextTime: string;
+    worldKbUrl: typeof WorldConfig['WORLD_KB_URL'];
+    inWorld: boolean;
+    showEditFields: boolean;
+    systems?: Game.SystemData<foundry.packages.SystemData>[];
   }
 
   interface Options extends FormApplication.Options {
@@ -56,5 +62,7 @@ declare namespace WorldConfig {
      * @defaultValue `false`
      */
     create: boolean;
+
+    inWorld?: boolean;
   }
 }

package/src/foundry/foundry.js/applications/hotbar.d.ts

@@ -133,10 +133,11 @@ declare global {
      */
     protected _canDragDrop(selector: string): boolean;
 
-    /** @override */
-    protected _onDrop(
-      event: DragEvent
-    ): void | ReturnType<InstanceType<ConfiguredDocumentClass<typeof User>>['assignHotbarMacro']>;
+    /**
+     * @override
+     * @internal
+     */
+    protected _onDrop(event: DragEvent): void;
 
     /**
      * Handle click events to toggle display of the macro bar

package/src/foundry/foundry.js/applications/sceneControls.d.ts

@@ -1,15 +1,25 @@
-declare interface SceneControlTool {
+interface SceneControlToolBase {
   name: string;
   title: string;
   icon: string;
   visible?: boolean;
-  toggle?: boolean;
   active?: boolean;
+}
+
+interface SceneControlToolToggle extends SceneControlToolBase {
+  toggle: true;
+  onClick?: (toggled: boolean) => void;
+}
+
+interface SceneControlToolNoToggle extends SceneControlToolBase {
+  toggle?: false;
   button?: boolean;
   onClick?: () => void;
 }
 
-declare interface SceneControl {
+type SceneControlTool = SceneControlToolToggle | SceneControlToolNoToggle;
+
+interface SceneControl {
   name: string;
   title: string;
   layer: string;