@league-of-foundry-developers/foundry-vtt-types 0.8.9-7 → 0.8.9-8

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

@@ -1,103 +1,112 @@
-/**
- * A game settings configuration application
- * This form renders the settings defined via the game.settings.register API which have config = true
- */
-declare class SettingsConfig extends FormApplication<FormApplication.Options, SettingsConfig.Data> {
-  /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   title: game.i18n.localize("SETTINGS.Title"),
-   *   id: "client-settings",
-   *   template: "templates/sidebar/apps/settings-config.html",
-   *   width: 600,
-   *   height: "auto",
-   *   tabs: [
-   *     {navSelector: ".tabs", contentSelector: ".content", initial: "core"}
-   *   ]
-   * })
-   * ```
-   */
-  static get defaultOptions(): typeof FormApplication['defaultOptions'];
+import type { ConfiguredDocumentClass } from '../../../../types/helperTypes';
 
+declare global {
   /**
-   * @param options - (unused)
-   * @override
+   * The Application responsible for displaying and editing a single Setting document.
+   * This form renders the settings defined via the game.settings.register API which have config = true
+   * @typeParam Options - The type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
    */
-  getData(options?: Partial<FormApplication.Options>): SettingsConfig.Data;
+  class SettingsConfig<
+    Options extends FormApplication.Options = FormApplication.Options,
+    Data extends object = SettingsConfig.Data
+  > extends FormApplication<Options, Data> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("SETTINGS.Title"),
+     *   id: "client-settings",
+     *   template: "templates/sidebar/apps/settings-config.html",
+     *   width: 600,
+     *   height: "auto",
+     *   tabs: [{ navSelector: ".tabs", contentSelector: ".content", initial: "core" }],
+     * })
+     * ```
+     */
+    static get defaultOptions(): typeof FormApplication['defaultOptions'];
 
-  /** @override */
-  activateListeners(html: JQuery): void;
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
 
-  /**
-   * Handle activating the button to configure User Role permissions
-   * @param event - The initial button click event
-   */
-  protected _onClickSubmenu(event: JQuery.ClickEvent): void;
+    /** @override */
+    activateListeners(html: JQuery): void;
 
-  /**
-   * Handle button click to reset default settings
-   * @param event - The initial button click event
-   */
-  protected _onResetDefaults(event: JQuery.ClickEvent): void;
+    /**
+     * Handle activating the button to configure User Role permissions
+     * @param event - The initial button click event
+     * @internal
+     */
+    protected _onClickSubmenu(event: JQuery.ClickEvent): void;
 
-  /**
-   * @param event - (unused)
-   * @override
-   */
-  protected _updateObject(event: Event, formData: SettingsConfig.FormData): Promise<void>;
-}
+    /**
+     * Handle button click to reset default settings
+     * @param event - The initial button click event
+     * @internal
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): void;
 
-declare namespace SettingsConfig {
-  interface Data {
-    user: User;
-    canConfigure: boolean;
-    systemTitle: Game['system']['data']['title'];
-    data: Data.Data;
+    /** @override */
+    protected _updateObject(event: Event, formData: SettingsConfig.FormData): Promise<void>;
   }
 
-  namespace Data {
+  namespace SettingsConfig {
     interface Data {
-      core: {
-        version: Game['data']['version'];
-        menus: ClientSettings.CompleteMenuSetting[];
-        settings: Setting[];
-        none: boolean;
-      };
-      system: {
-        title: Game['system']['data']['title'];
-        menus: ClientSettings.CompleteMenuSetting[];
-        settings: Setting[];
-        none: boolean;
-      };
-      modules: Record<string, { title: string; menus: ClientSettings.CompleteMenuSetting[]; settings: Setting[] }>;
+      user: StoredDocument<InstanceType<ConfiguredDocumentClass<typeof User>>>;
+      canConfigure: boolean;
+      systemTitle: Game['system']['data']['title'];
+      data: Data.Data;
     }
 
-    interface Setting extends foundry.utils.Duplicated<ClientSettings.CompleteSetting> {
-      name: string;
-      hint: string;
-      value: ReturnType<ClientSettings['get']>;
-      type: string;
-      isCheckbox: boolean;
-      isSelect: boolean;
-      isRange: boolean;
+    namespace Data {
+      interface Data {
+        core: {
+          version: string;
+          menus: ClientSettings.CompleteMenuSetting[];
+          settings: Setting[];
+          none: boolean;
+        };
+        system: {
+          title: Game['system']['data']['title'];
+          menus: ClientSettings.CompleteMenuSetting[];
+          settings: Setting[];
+          none: boolean;
+        };
+        modules: { title: string; menus: ClientSettings.CompleteMenuSetting[]; settings: Setting[] }[];
+      }
+
+      interface Setting extends Omit<ClientSettings.CompleteSetting, 'type'> {
+        id: string;
+        name: string;
+        hint: string;
+        value: unknown;
+        type: string;
+        isCheckbox: boolean;
+        isSelect: boolean;
+        isRange: boolean;
+        filePickerType: FilePicker.Type | undefined;
+      }
     }
-  }
 
-  interface FormData {
-    'core.animateRollTable': boolean;
-    'core.chatBubbles': boolean;
-    'core.chatBubblesPan': boolean;
-    'core.coneTemplateType': 'round' | 'flat';
-    'core.language': string;
-    'core.leftClickRelease': boolean;
-    'core.lightAnimation': boolean;
-    'core.maxFPS': number;
-    'core.mipmap': boolean;
-    'core.softShadows': boolean;
-    'core.tokenDragPreview': boolean;
-    'core.visionAnimation': boolean;
-    [key: string]: unknown;
+    interface FormData {
+      'core.animateRollTable': boolean;
+      'core.chatBubbles': boolean;
+      'core.chatBubblesPan': boolean;
+      'core.coneTemplateType': 'round' | 'flat';
+      'core.language': string;
+      'core.leftClickRelease': boolean;
+      'core.lightAnimation': boolean;
+      'core.maxFPS': number;
+      'core.mipmap': boolean;
+      'core.noCanvas': boolean;
+      'core.softShadows': boolean;
+      'core.tokenDragPreview': boolean;
+      'core.visionAnimation': boolean;
+      [key: string]: unknown;
+    }
   }
 }

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

@@ -1,175 +1,163 @@
-// 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;
-
-  /**
-   * Convenience access for the Token object
-   */
-  get token(): this['object'];
-
-  /**
-   * 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[]>>;
-
-  /**
-   * 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;
+import type { ConfiguredDocumentClassForName, ConstructorDataType } from '../../../../types/helperTypes';
 
+declare global {
   /**
-   * Get an Object of image paths and filenames to display in the Token sheet
+   * 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.
    */
-  protected _getAlternateTokenImages(): Promise<Partial<Record<string, string>>>;
+  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;
 
-  /** @override */
-  activateListeners(html: JQuery): void;
+    /**
+     * @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;
 
-  /** @override */
-  protected _getSubmitData(
-    updateData?: TokenConfig.FormData
-  ): ReturnType<FormApplication['_getSubmitData']> & { lightAlpha: number };
+    /** @override */
+    get id(): string;
 
-  /** @override */
-  protected _updateObject(event: Event, formData: TokenConfig.FormData): Promise<void>;
+    /**
+     * A convenience accessor to test whether we are configuring the prototype Token for an Actor.
+     */
+    get isPrototype(): boolean;
 
-  /**
-   * 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;
+    /**
+     * Convenience access to the Actor document that this Token represents
+     */
+    get actor(): InstanceType<ConfiguredDocumentClassForName<'Actor'>>;
 
-  /**
-   * 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>;
+    /** @override */
+    get title(): 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 */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
 
-declare namespace TokenConfig {
-  interface Attributes {
-    bar: string[][];
-    value: string[][];
-  }
+    /** @override */
+    render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<this>;
 
-  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'];
-  }
+    /**
+     * Get an Object of image paths and filenames to display in the Token sheet
+     * @internal
+     */
+    protected _getAlternateTokenImages(): Promise<Record<string, string>>;
+
+    /** @override */
+    activateListeners(html: JQuery): void;
+
+    /** @override */
+    protected _getSubmitData(
+      updateData?: ConstructorDataType<foundry.data.TokenData>
+    ): Record<string, unknown> & { lightAlpha: number };
+
+    /** @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.TokenDisplayMode, string>;
+      actors: { _id: string; name: string }[];
+      dispositions: Record<foundry.CONST.TokenDisposition, 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.TokenDisplayMode;
+      displayName: foundry.CONST.TokenDisplayMode;
+      disposition: foundry.CONST.TokenDisposition;
+      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.WallDirection;
+      door: foundry.CONST.WallDoorType;
+      ds?: foundry.CONST.WallDoorState;
+      move: foundry.CONST.WallMovementType;
+      sense: foundry.CONST.WallSenseType;
+      sound: foundry.CONST.WallSenseType;
+    }
   }
 }