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

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

@@ -1,27 +1,37 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
 /**
  * The Module Management Application.
  * This application provides a view of which modules are available to be used and allows for configuration of the
  * set of modules which are active within the World.
+ * @typeParam Options - The type of the options object
+ * @typeParam Data    - The data structure used to render the handlebars template.
  */
-declare class ModuleManagement extends FormApplication<FormApplication.Options, ModuleManagement.Data, any> {
+
+declare class ModuleManagement<
+  Options extends FormApplication.Options = FormApplication.Options,
+  Data extends object = ModuleManagement.Data
+> extends FormApplication<Options, Data, undefined> {
   /**
    * @defaultValue `'all'`
+   * @internal
    */
   protected _filter: ModuleManagement.FilterName;
 
   /**
    * @defaultValue `false`
+   * @internal
    */
   protected _expanded: boolean;
 
   /**
    * @defaultValue `{}`
+   * @internal
    */
-  protected _checked: Partial<Record<string, boolean>>;
+  protected _checked: Record<string, boolean>;
+
+  /**
+   * The named game setting which persists module configuration.
+   */
+  static CONFIG_SETTING: 'moduleConfiguration';
 
   /**
    * @override
@@ -40,57 +50,63 @@ declare class ModuleManagement extends FormApplication<FormApplication.Options,
    * });
    * ```
    */
-  static get defaultOptions(): typeof FormApplication['defaultOptions'];
+  static get defaultOptions(): FormApplication.Options;
 
   /** @override */
   get isEditable(): boolean;
 
   /** @override */
-  getData(options?: Partial<FormApplication.Options>): ModuleManagement.Data;
+  getData(options?: Partial<Options>): Data | Promise<Data>;
 
   /** @override */
   activateListeners(html: JQuery): void;
 
   /**
-   * @param event - (unused)
    * @override
+   * @param event - (unused)
    */
-  // TODO: type return value when the class' config setting is typed
-  protected _updateObject(event: Event, formData: ModuleManagement.FormData): Promise<unknown>;
+  protected _updateObject(event: Event, formData: ModuleManagement.FormData): Promise<Record<string, boolean>>;
+
+  /**
+   * Restores the Form UI to the internal checked state
+   * @internal
+   */
+  protected _restoreCheckboxState(): void;
 
   /**
    * Handle changes to a module checkbox to prompt for whether or not to enable dependencies
+   * @internal
    */
-  protected _onChangeCheckbox(event: JQuery.ChangeEvent): void;
+  protected _onChangeCheckbox(event: JQuery.ChangeEvent): unknown;
 
   /**
    * Handle a button-click to deactivate all modules
+   * @internal
    */
   protected _onDeactivateAll(event: JQuery.ClickEvent): void;
 
   /**
    * Handle expanding or collapsing the display of descriptive elements
+   * @internal
    */
   protected _onExpandCollapse(event: JQuery.ClickEvent): void;
 
   /**
    * Handle a button-click to deactivate all modules
+   * @internal
    */
   protected _onFilterList(event: JQuery.ClickEvent): void;
 
   /** @override */
   protected _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
-
-  static readonly CONFIG_SETTING: 'moduleConfiguration';
 }
 
 declare namespace ModuleManagement {
   interface Data {
-    editable: ModuleManagement['isEditable'];
+    editable: boolean;
     filters: [Data.Filter<'all'>, Data.Filter<'active'>, Data.Filter<'inactive'>];
     modules: Data.Module[];
-    query: undefined; // TODO: this seems to reference an undefined value (`this._query`)
-    expanded: ModuleManagement['_expanded'];
+    expanded: boolean;
   }
 
   namespace Data {
@@ -101,23 +117,25 @@ declare namespace ModuleManagement {
       count: number;
     }
 
-    interface Module extends foundry.utils.Duplicated<Game.Module> {
+    type Module = foundry.packages.ModuleData['_source'] & {
       active: boolean;
+      availability: number;
+      data: foundry.packages.ModuleData;
       css: ' active' | '';
       hasPacks: boolean;
       hasScripts: boolean;
       hasStyles: boolean;
       systemOnly: boolean;
       systemTag: Game['system']['id'];
-      incompatible: any; // TODO
-      unavailable: any; // TODO
       dependencies: string[] | null;
-    }
+      unavailable?: string;
+      incompatible?: string;
+    };
   }
 
   type FilterName = 'all' | 'active' | 'inactive';
 
-  interface FormData {
+  type FormData = Record<string, boolean> & {
     search: string;
-  }
+  };
 }

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;
+    }
   }
 }