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

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

@@ -1,154 +1,170 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
-/**
- * Entity Sheet Configuration Application
- * @typeParam P - the type of the options object
- * @typeParam E - the type of the Entity, this sheet is used to configure
- */
-declare class EntitySheetConfig<
-  P extends FormApplication.Options = FormApplication.Options,
-  E extends Entity = Entity
-> extends FormApplication<P, EntitySheetConfig.Data, E> {
-  /**
-   * @param entity  - The Entity object for which the sheet is being configured
-   * @param options - Additional Application options
-   */
-  constructor(entity: E, options?: Partial<P>);
-
-  /**
-   * @defaultValue
-   * ```typescript
-   * const options = super.defaultOptions;
-   * options.id = "sheet-config";
-   * options.template = "templates/sheets/sheet-config.html";
-   * options.width = 400;
-   * ```
-   */
-  static get defaultOptions(): typeof FormApplication['defaultOptions'];
-
-  /**
-   * Add the Entity name into the window title
-   */
-  get title(): string;
-
-  /**
-   * Construct and return the data object used to render the HTML template for this form application.
-   * @param options - (unused)
-   */
-  getData(options?: Partial<P>): EntitySheetConfig.Data<E>;
-
-  /**
-   * 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: EntitySheetConfig.FormData): Promise<void>;
+import type { DocumentConstructor } from '../../../../types/helperTypes';
 
+declare global {
   /**
-   * Initialize the configured Sheet preferences for Entities which support dynamic Sheet assignment
-   * Create the configuration structure for supported entities
-   * Process any pending sheet registrations
-   * Update the default values from settings data
+   * Entity Sheet Configuration Application
+   * @typeParam Options          - The type of the options object
+   * @typeParam Data             - The data structure used to render the handlebars template.
+   * @typeParam ConcreteDocument - The type of the Document which is being managed
    */
-  static initializeSheets(): void;
-
-  /**
-   * Register a sheet class as a candidate which can be used to display entities of a given type
-   * @param entityClass - The Entity for which to register a new Sheet option
-   * @param scope       - Provide a unique namespace scope for this sheet
-   * @param sheetClass  - A defined Application class used to render the sheet
-   * @param label       - A human readable label for the sheet name, which will be localized
-   * @param types       - An array of entity types for which this sheet should be used
-   *                      (default: `[]`)
-   * @param makeDefault - Whether to make this sheet the default for provided types
-   *                      (default: `false`)
-   */
-  static registerSheet(
-    entityClass: ConstructorOf<Entity>,
-    scope: string,
-    sheetClass: ConstructorOf<FormApplication>,
-    { label, types, makeDefault }?: { label?: string; types?: string[]; makeDefault?: boolean }
-  ): void;
-
-  protected static _registerSheet({
-    entityClass,
-    id,
-    label,
-    sheetClass,
-    types,
-    makeDefault
-  }: Exclude<EntitySheetConfig.Config, 'action'>): void;
-
-  /**
-   * Unregister a sheet class, removing it from the list of available Applications to use for an Entity type
-   * @param entityClass - The Entity for which to register a new Sheet option
-   * @param scope       - Provide a unique namespace scope for this sheet
-   * @param sheetClass  - A defined Application class used to render the sheet
-   * @param types       - An Array of types for which this sheet should be removed
-   */
-  static unregisterSheet(
-    entityClass: ConstructorOf<Entity>,
-    scope: string,
-    sheetClass: ConstructorOf<FormApplication>,
-    { types }?: { types?: string[] }
-  ): void;
-
-  protected static _unregisterSheet({
-    entityClass,
-    id,
-    types
-  }: Pick<EntitySheetConfig.Config, 'entityClass' | 'id' | 'types'>): void;
-
-  /**
-   * @typeParam T - the string array, passed as the types parameter
-   */
-  protected static _getEntityTypes<T extends string[]>(entityClass: any, types: T): T;
-  protected static _getEntityTypes(entityClass: ConstructorOf<Entity>): string[];
-
-  /**
-   * Update the currently default Sheets using a new core world setting
-   */
-  protected static _updateDefaultSheets(setting?: Record<'Actor' | 'Item', Record<string, string>>): void;
-
-  protected _pending: EntitySheetConfig.Config[];
-}
-
-declare namespace EntitySheetConfig {
-  interface Config {
-    action: 'register' | 'unregister';
-    entityClass: ConstructorOf<Entity>;
-    id: string;
-    label: string;
-    sheetClass: ConstructorOf<FormApplication>;
-    types: string[];
-    makeDefault: boolean;
-  }
-
-  /**
-   * @typeParam P - the type of the options object
-   * @typeParam E - the type of the entity
-   */
-  interface Data<E extends Entity = Entity, P extends FormApplication.Options = FormApplication.Options> {
-    entityName: EntitySheetConfig<P, E>['object']['entity'];
-    isGM: User['isGM'];
-    object: foundry.utils.Duplicated<EntitySheetConfig<P, E>['object']['data']>;
-    options: EntitySheetConfig<P, E>['options'];
-    sheetClass: ReturnType<E['getFlag']> | '';
-    sheetClasses: Record<SheetClass['id'], SheetClass['label']>;
-    defaultClass: SheetClass['id'] | null;
-    blankLabel: ReturnType<Localization['localize']>;
+  class EntitySheetConfig<
+    Options extends FormApplication.Options = FormApplication.Options,
+    Data extends object = EntitySheetConfig.Data<foundry.abstract.Document<any, any>, Options>,
+    ConcreteDocument extends foundry.abstract.Document<any, any> = Data extends EntitySheetConfig.Data<infer T>
+      ? T
+      : foundry.abstract.Document<any, any>
+  > extends FormApplication<Options, Data, ConcreteDocument> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "sheet-config",
+     *   template: "templates/sheets/sheet-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static get defaultOptions(): FormApplication.Options;
+
+    /**
+     * An array of pending sheet assignments which are submitted before other elements of the framework are ready.
+     * @internal
+     */
+    static _pending: Array<EntitySheetConfig.SheetAssignment>;
+
+    /** @override */
+    get title(): string;
+
+    /** @override */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    protected _updateObject(event: Event, formData: EntitySheetConfig.FormData): Promise<void>;
+
+    /**
+     * Initialize the configured Sheet preferences for Entities which support dynamic Sheet assignment
+     * Create the configuration structure for supported entities
+     * Process any pending sheet registrations
+     * Update the default values from settings data
+     */
+    static initializeSheets(): void;
+
+    /**
+     * @internal
+     */
+    protected static _getDocumentTypes(cls: DocumentConstructor, types?: string[]): string[];
+
+    /**
+     * Register a sheet class as a candidate which can be used to display entities of a given type
+     * @param documentClass - The Document class for which to register a new Sheet option
+     * @param scope         - Provide a unique namespace scope for this sheet
+     * @param sheetClass    - A defined Application class used to render the sheet
+     * @param options       - Additional options used for sheet registration
+     */
+    static registerSheet(
+      documentClass: DocumentConstructor,
+      scope: string,
+      sheetClass: ConstructorOf<Application>,
+      { label, types, makeDefault }?: EntitySheetConfig.RegisterSheetOptions
+    ): void;
+
+    /**
+     * Perform the sheet registration
+     * @internal
+     */
+    protected static _registerSheet({
+      documentClass,
+      id,
+      label,
+      sheetClass,
+      types,
+      makeDefault
+    }: Omit<EntitySheetConfig.SheetRegistration, 'action'>): void;
+
+    /**
+     * Unregister a sheet class, removing it from the list of available Applications to use for a Document type
+     * @param documentClass - The Document class for which to register a new Sheet option
+     * @param scope         - Provide a unique namespace scope for this sheet
+     * @param sheetClass    - A defined Application class used to render the sheet
+     * @param types         - An Array of types for which this sheet should be removed
+     */
+    static unregisterSheet(
+      documentClass: DocumentConstructor,
+      scope: string,
+      sheetClass: ConstructorOf<Application>,
+      { types }?: { types?: string[] }
+    ): void;
+
+    /**
+     * Perform the sheet de-registration
+     * @internal
+     */
+    protected static _unregisterSheet({
+      documentClass,
+      id,
+      types
+    }: Omit<EntitySheetConfig.SheetUnregistration, 'action'>): void;
+
+    /**
+     * Update the currently default Sheets using a new core world setting
+     */
+    static updateDefaultSheets(setting?: Record<'Actor' | 'Item', Record<string, string>>): void;
   }
 
-  type FormData = Pick<Data, 'defaultClass' | 'sheetClass'>;
-
-  interface SheetClass {
-    id: string | number;
-    cls?: ConstructorOf<FormApplication>;
-    label: string;
-    default: boolean;
+  namespace EntitySheetConfig {
+    type SheetRegistration = {
+      action: 'register';
+      documentClass: DocumentConstructor;
+      id: string;
+      label: string;
+      sheetClass: ConstructorOf<Application>;
+      types: string[];
+      makeDefault: boolean;
+    };
+
+    type SheetUnregistration = {
+      action: 'unregister';
+      documentClass: DocumentConstructor;
+      id: string;
+      types: string[];
+    };
+
+    type SheetAssignment = SheetRegistration | SheetUnregistration;
+
+    /**
+     * @typeParam ConcreteDocument - The type of the Document which is being managed
+     * @typeParam Options          - The type of the options object
+     */
+    interface Data<
+      ConcreteDocument extends foundry.abstract.Document<any, any>,
+      Options extends FormApplication.Options = FormApplication.Options
+    > {
+      isGM: boolean;
+      object: foundry.utils.Duplicated<ConcreteDocument['data']>;
+      options: Options;
+      sheetClass: string;
+      sheetClasses: Record<string, string>;
+      defaultClass: string;
+      blankLabel: string;
+    }
+
+    interface FormData {
+      defaultClass: string;
+      sheetClass: string;
+    }
+
+    interface RegisterSheetOptions {
+      /** A human readable label for the sheet name, which will be localized */
+      label?: string;
+
+      /** An array of entity types for which this sheet should be used */
+      types?: string[];
+
+      /**
+       * Whether to make this sheet the default for provided types
+       * @defaultValue `false`
+       */
+      makeDefault?: boolean;
+    }
   }
-
-  type SheetClasses = Record<string, Record<string, SheetClass>>;
 }

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

@@ -1,15 +1,13 @@
 import './avConfig';
 import './combatTrackerConfig';
+import './defaultTokenConfig';
 import './documentSheet';
 import './documentSheets';
 import './drawingConfig';
 import './entitySheetConfig';
-import './folderConfig';
 import './gridConfig';
 import './imagePopout';
-import './measuredTemplateConfig';
 import './moduleManagement';
-import './noteConfig';
 import './permissionConfig';
 import './settingsConfig';
 import './tokenConfig';

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