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

package/src/foundry/foundry.js/applications/formApplications/documentSheets/rollTableConfig.d.ts

@@ -1,152 +1,194 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
-/**
- * The RollTable configuration sheet
- * @typeParam P - the type of the options object
- */
-declare class RollTableConfig<P extends DocumentSheet.Options = DocumentSheet.Options> extends DocumentSheet<
-  P,
-  RollTableConfig.Data,
-  RollTable
-> {
-  /**
-   * @param table   - The rollable table entity being configured
-   * @param options - Additional application rendering options
-   */
-  constructor(table: RollTable, options?: Partial<P>);
-
-  /**
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   classes: ["sheet", "roll-table-config"],
-   *   template: "templates/sheets/roll-table-config.html",
-   *   width: 720,
-   *   height: "auto",
-   *   closeOnSubmit: false,
-   *   viewPermission: ENTITY_PERMISSIONS.OBSERVER,
-   *   scrollY: ["ol.table-results"],
-   *   dragDrop: [{dragSelector: null, dropSelector: null}]
-   * })
-   * ```
-   */
-  static get defaultOptions(): typeof DocumentSheet['defaultOptions'];
-
-  /**
-   * @override
-   */
-  get title(): string;
-
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<P>): RollTableConfig.Data;
-
-  /**
-   * @override
-   */
-  activateListeners(html: JQuery): void;
-
-  /**
-   * Handle creating a TableResult in the RollTable entity
-   * @param event      - The originating mouse event
-   * @param resultData - An optional object of result data to use
-   */
-  protected _onCreateResult(event: JQuery.ClickEvent | DragEvent, resultData?: object): Promise<RollTable.Result>;
-
-  /**
-   * Submit the entire form when a table result type is changed, in case there are other active changes
-   */
-  protected _onChangeResultType(event: JQuery.ClickEvent): ReturnType<RollTableConfig['_onSubmit']>;
-
-  /**
-   * Handle deleting a TableResult from the RollTable entity
-   */
-  protected _onDeleteResult(event: JQuery.ClickEvent): Promise<RollTable.Result>;
-
-  /**
-   * @override
-   */
-  protected _onDrop(event: DragEvent): ReturnType<RollTableConfig['_onCreateResult']>;
-
-  /**
-   * Handle changing the actor profile image by opening a FilePicker
-   */
-  protected _onEditImage(event: JQuery.ClickEvent): ReturnType<FilePicker['browse']>;
-
-  /**
-   * Handle a button click to re-normalize dice result ranges across all RollTable results
-   */
-  protected _onNormalizeResults(event: JQuery.ClickEvent): Promise<RollTable>;
-
-  /**
-   * Handle toggling the drawn status of the result in the table
-   */
-  protected _onLockResult(event: JQuery.ClickEvent): Promise<RollTable.Result>;
-
-  /**
-   * Reset the Table to it's original composition with all options unlocked
-   */
-  protected _onResetTable(event: JQuery.ClickEvent): Promise<RollTable.Result>;
-
-  /**
-   * Handle drawing a result from the RollTable
-   */
-  protected _onRollTable(event: JQuery.ClickEvent): Promise<void>;
-
-  /**
-   * Configure the update object workflow for the Roll Table configuration sheet
-   * Additional logic is needed here to reconstruct the results array from the editable fields on the sheet
-   * @param event    - The form submission event
-   * @param formData - The validated FormData translated into an Object for submission
-   */
-  protected _updateObject(event: Event, formData: RollTableConfig.FormData): Promise<RollTable>;
-
-  /**
-   * Display a roulette style animation when a Roll Table result is drawn from the sheet
-   * @param results - An Array of drawn table results to highlight
-   */
-  protected _animateRoll(results: RollTable.Result[]): Promise<void>;
-
-  /**
-   * Animate a "roulette" through the table until arriving at the final loop and a drawn result
-   */
-  protected _animateRoulette(
-    ol: HTMLOListElement,
-    drawnIds: string[],
-    nLoops: number,
-    animTime: number,
-    animOffset: number
-  ): Promise<void>;
-
-  /**
-   * Display a flashing animation on the selected result to emphasize the draw
-   * @param item - The HTML <li> item of the winning result
-   */
-  protected _flashResult(item: HTMLElement): Promise<void>;
-}
-
-declare namespace RollTableConfig {
-  interface Data extends DocumentSheet.Data<RollTable> {
-    results: RollTable.Result;
-    resultTypes: {
-      [Key in keyof typeof foundry.CONST['TABLE_RESULT_TYPES'] as typeof foundry.CONST['TABLE_RESULT_TYPES'][Key]]: Key;
-    };
-    entityTypes: typeof foundry.CONST['COMPENDIUM_ENTITY_TYPES'];
-    compendiumPacks: string[];
+import type {
+  ConfiguredDocumentClassForName,
+  ConstructorDataType,
+  ToObjectFalseType
+} from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for displaying and editing a single RollTable document.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class RollTableConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = ActorSheet.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'RollTable'>>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   classes: ["sheet", "roll-table-config"],
+     *   template: "templates/sheets/roll-table-config.html",
+     *   width: 720,
+     *   height: "auto",
+     *   closeOnSubmit: false,
+     *   viewPermission: CONST.ENTITY_PERMISSIONS.OBSERVER,
+     *   scrollY: ["ol.table-results"],
+     *   dragDrop: [{ dragSelector: null, dropSelector: null }],
+     * })
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @override
+     */
+    get title(): string;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /**
+     * @override
+     */
+    activateListeners(html: JQuery): void;
+
+    /**
+     * Handle creating a TableResult in the RollTable entity
+     * @param event      - The originating mouse event
+     * @param resultData - An optional object of result data to use
+     * @internal
+     */
+    protected _onCreateResult(
+      event: JQuery.ClickEvent | DragEvent,
+      resultData?: ConstructorDataType<foundry.data.TableResultData>
+    ): Promise<ConfiguredDocumentClassForName<'TableResult'>[]>;
+
+    /**
+     * Submit the entire form when a table result type is changed, in case there are other active changes
+     * @internal
+     */
+    protected _onChangeResultType(event: JQuery.ChangeEvent): void;
+
+    /**
+     * Handle deleting a TableResult from the RollTable entity
+     * @param event - The originating click event
+     * @returns The deleted TableResult document
+     * @internal
+     */
+    protected _onDeleteResult(
+      event: JQuery.ClickEvent
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'TableResult'>> | undefined>;
+
+    /**
+     * @override
+     * @internal
+     */
+    protected _onDrop(event: DragEvent): void;
+
+    /**
+     * Handle changing the actor profile image by opening a FilePicker
+     * @internal
+     */
+    protected _onEditImage(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle a button click to re-normalize dice result ranges across all RollTable results
+     * @internal
+     */
+    protected _onNormalizeResults(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle toggling the drawn status of the result in the table
+     * @internal
+     */
+    protected _onLockResult(event: JQuery.ClickEvent): void;
+
+    /**
+     * Reset the Table to it's original composition with all options unlocked
+     * @internal
+     */
+    protected _onResetTable(event: JQuery.ClickEvent): void;
+
+    /**
+     * Handle drawing a result from the RollTable
+     * @internal
+     */
+    protected _onRollTable(event: JQuery.ClickEvent): void;
+
+    /**
+     * Configure the update object workflow for the Roll Table configuration sheet
+     * Additional logic is needed here to reconstruct the results array from the editable fields on the sheet
+     * @param event    - The form submission event
+     * @param formData - The validated FormData translated into an Object for submission
+     * @internal
+     */
+    protected _updateObject(
+      event: Event,
+      formData: RollTableConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'RollTable'>> | undefined>;
+
+    /**
+     * Display a roulette style animation when a Roll Table result is drawn from the sheet
+     * @param results - An Array of drawn table results to highlight
+     * @returns A Promise which resolves once the animation is complete
+     */
+    protected _animateRoll(results: InstanceType<ConfiguredDocumentClassForName<'TableResult'>>[]): Promise<void[]>;
+
+    /**
+     * Animate a "roulette" through the table until arriving at the final loop and a drawn result
+     */
+    protected _animateRoulette(
+      ol: HTMLOListElement,
+      drawnIds: Set<string>,
+      nLoops: number,
+      animTime: number,
+      animOffset: number
+    ): Promise<void>;
+
+    /**
+     * Display a flashing animation on the selected result to emphasize the draw
+     * @param item - The HTML \<li\> item of the winning result
+     * @returns A Promise that resolves once the animation is complete
+     */
+    protected _flashResult(item: HTMLElement): Promise<void>;
   }
 
-  interface FormData
-    extends Pick<RollTable.Data, 'description' | 'displayRoll' | 'formula' | 'img' | 'name' | 'replacement'> {
-    [index: number]: FormDataResult;
-  }
-
-  interface FormDataResult
-    extends Pick<RollTable.Result, '_id' | 'drawn' | 'img' | 'resultId' | 'text' | 'type' | 'weight'> {
-    rangeH: RollTable.Result['range'][1];
-    rangeL: RollTable.Result['range'][0];
+  namespace RollTableConfig {
+    interface Data extends DocumentSheet.Data<RollTable> {
+      results: ToObjectFalseType<foundry.data.TableResultData> & {
+        isText: boolean;
+        isEntity: boolean;
+        isCompendium: boolean;
+        img: string;
+        text: string;
+      };
+      resultTypes: {
+        [Key in keyof typeof foundry.CONST.TABLE_RESULT_TYPES as typeof foundry.CONST.TABLE_RESULT_TYPES[Key]]: Titlecase<Key>;
+      };
+      entityTypes: typeof foundry.CONST.COMPENDIUM_ENTITY_TYPES;
+      compendiumPacks: string[];
+    }
+
+    type FormData = {
+      description: string;
+      displayRoll: boolean;
+      formula: string;
+      img: string;
+      name: string;
+      replacement: boolean;
+    } & FormDataResults;
+
+    type FormDataResults = {
+      [Key in number as `results.${number}._id`]: string;
+    } & {
+      [Key in number as `results.${number}.drawn`]: boolean;
+    } & {
+      [Key in number as `results.${number}.img`]: string;
+    } & {
+      [Key in number as `results.${number}.rangeH`]: number;
+    } & {
+      [Key in number as `results.${number}.rangeL`]: number;
+    } & {
+      [Key in number as `results.${number}.text`]: string;
+    } & {
+      [Key in number as `results.${number}.type`]: foundry.CONST.TableResultType;
+    } & {
+      [Key in number as `results.${number}.weight`]: string;
+    };
   }
 }

package/src/foundry/foundry.js/applications/formApplications/documentSheets/sceneConfig.d.ts

@@ -1,129 +1,152 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
+import type { ConfiguredDocumentClassForName, DocumentConstructor } from '../../../../../types/helperTypes';
 
-/**
- * A Scene configuration sheet
- * @see {@link Scene} The Scene Entity which is being configured
- */
-declare class SceneConfig extends DocumentSheet<DocumentSheet.Options, SceneConfig.Data, Scene> {
+declare global {
   /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   classes: ["sheet", "scene-sheet"],
-   *   template: "templates/scene/config.html",
-   *   width: 680,
-   *   height: "auto"
-   * });
-   * ```
+   * The Application responsible for configuring a single Scene document.
+   * @see {@link Scene} The Scene Document which is being configured
+   *
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
    */
-  static get defaultOptions(): typeof DocumentSheet['defaultOptions'];
+  class SceneConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = SceneConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Scene'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "scene-config",
+     *   classes: ["sheet", "scene-sheet"],
+     *   template: "templates/scene/config.html",
+     *   width: 680,
+     *   height: "auto",
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
 
-  /**
-   * @override
-   */
-  get id(): string;
+    /**
+     * @override
+     */
+    get title(): string;
 
-  /**
-   * @override
-   */
-  get title(): string;
+    /**
+     * @override
+     * @remarks This incorrectly overrides `Application#render` by potentially returning `void`, see https://gitlab.com/foundrynet/foundryvtt/-/issues/6026.
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    render(force?: boolean, options?: Application.RenderOptions<Options>): this | void;
 
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<DocumentSheet.Options>): SceneConfig.Data;
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<DocumentSheet.Options>): Data | Promise<Data>;
 
-  /**
-   * Get an enumeration of the available grid types which can be applied to this Scene
-   */
-  protected static _getGridTypes(): Record<foundry.CONST.GridType, string>;
+    /**
+     * Get an enumeration of the available grid types which can be applied to this Scene
+     * @internal
+     */
+    protected static _getGridTypes(): Record<foundry.CONST.GridType, string>;
 
-  /**
-   * Get the available weather effect types which can be applied to this Scene
-   */
-  protected _getWeatherTypes(): Record<string, string>;
+    /**
+     * Get the available weather effect types which can be applied to this Scene
+     * @internal
+     */
+    protected _getWeatherTypes(): Record<string, string>;
 
-  /**
-   * Get the alphabetized entities which can be chosen as a configuration for the scene
-   */
-  protected _getEntities(collection: EntityCollection): { _id: string; name: string }[];
+    /**
+     * Get the alphabetized Documents which can be chosen as a configuration for the Scene
+     * @internal
+     */
+    protected _getDocuments(collection: WorldCollection<DocumentConstructor, string>): { _id: string; name: string }[];
 
-  /**
-   * @override
-   */
-  activateListeners(html: JQuery): void;
+    /** @override */
+    activateListeners(html: JQuery): void;
 
-  /**
-   * Capture the current Scene position and zoom level as the initial view in the Scene config
-   * @param event - The originating click event
-   */
-  protected _onCapturePosition(event: JQuery.ClickEvent): void;
+    /**
+     * Capture the current Scene position and zoom level as the initial view in the Scene config
+     * @param event - The originating click event
+     * @internal
+     */
+    protected _onCapturePosition(event: JQuery.ClickEvent): void;
 
-  /**
-   * @override
-   */
-  protected _onChangeRange(event: JQuery.ChangeEvent): void;
+    /** @override */
+    protected _onChangeRange(event: JQuery.ChangeEvent): void;
 
-  /**
-   * Handle click events to open the grid configuration application
-   * @param event - The originating click event
-   */
-  protected _onGridConfig(event: JQuery.ClickEvent): SceneConfig['minimize'];
+    /**
+     * Handle updating the select menu of PlaylistSound options when the Playlist is changed
+     * @param event - The initiating select change event
+     * @internal
+     */
+    _onChangePlaylist(event: JQuery.ChangeEvent): void;
 
-  /**
-   * @override
-   */
-  protected _updateObject(event: Event, formData: SceneConfig.FormData): Promise<Scene>;
-}
+    /**
+     * Handle click events to open the grid configuration application
+     * @param event - The originating click event
+     */
+    protected _onGridConfig(event: JQuery.ClickEvent): void;
+
+    /**
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: SceneConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Scene'>> | undefined>;
+  }
+
+  namespace SceneConfig {
+    interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'Scene'>>, Options> {
+      gridTypes: ReturnType<typeof SceneConfig['_getGridTypes']>;
+      weatherTypes: ReturnType<SceneConfig['_getWeatherTypes']>;
+      playlists: ReturnType<SceneConfig['_getDocuments']>;
+      sounds: ReturnType<SceneConfig['_getDocuments']>;
+      journals: ReturnType<SceneConfig['_getDocuments']>;
+      hasGlobalThreshold: boolean;
+      data: DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'Scene'>>, Options>['data'] & {
+        /**
+         * @defaultValue `0`
+         */
+        globalLightThreshold: number;
+      };
+    }
 
-declare namespace SceneConfig {
-  interface Data extends DocumentSheet.Data {
-    gridTypes: ReturnType<typeof SceneConfig['_getGridTypes']>;
-    weatherTypes: ReturnType<SceneConfig['_getWeatherTypes']>;
-    playlists: ReturnType<SceneConfig['_getEntities']>;
-    journals: ReturnType<SceneConfig['_getEntities']>;
-    hasGlobalThreshold: boolean;
-    document: DocumentSheet.Data['document'] & {
-      /**
-       * @defaultValue `0`
-       */
+    type FormData = {
+      backgroundColor: string;
+      darkness: number;
+      fogExploration: boolean;
+      foreground: string;
+      globalLight: boolean;
       globalLightThreshold: number;
+      grid: number | null;
+      gridAlpha: number;
+      gridColor: string;
+      gridDistance: number | null;
+      gridType: foundry.CONST.GridType;
+      gridUnits: string;
+      hasGlobalThreshold: boolean;
+      height: number | null;
+      img: string;
+      'initial.scale': number | null;
+      'initial.x': number | null;
+      'initial.y': number | null;
+      journal: string;
+      name: string;
+      navName: string;
+      navigation: boolean;
+      padding: number;
+      'permission.default': foundry.CONST.EntityPermission;
+      playlist: string;
+      shiftX: number | null;
+      shiftY: number | null;
+      tokenVision: boolean;
+      weather: string;
+      width: number | null;
     };
   }
-
-  type FormData = {
-    backgroundColor: Scene.Data['backgroundColor'];
-    darkness: Scene.Data['darkness'];
-    fogExploration: Scene.Data['fogExploration'];
-    globalLight: Scene.Data['globalLight'];
-    globalLightThreshold: Scene.Data['globalLightThreshold'];
-    grid: GridConfig.FormData['grid'];
-    gridAlpha: Scene.Data['gridAlpha'];
-    gridColor: Scene.Data['gridColor'];
-    gridDistance: Scene.Data['gridDistance'] | null;
-    gridType: foundry.CONST.GridType;
-    gridUnits: Scene.Data['gridUnits'];
-    hasGlobalThreshold: boolean;
-    height: Scene.Data['height'] | null;
-    img: Scene.Data['img'];
-    'initial.scale': number | null;
-    'initial.x': number | null;
-    'initial.y': number | null;
-    journal: Scene.Data['journal'];
-    name: string;
-    navName: Scene.Data['navName'];
-    navigation: Scene.Data['navigation'];
-    padding: Scene.Data['padding'];
-    'permission.default': Scene.Data['permission'];
-    playlist: Scene.Data['playlist'];
-    shiftX: GridConfig.FormData['shiftX'];
-    shiftY: GridConfig.FormData['shiftY'];
-    tokenVision: Scene.Data['tokenVision'];
-    weather: Scene.Data['weather'];
-    width: Scene.Data['width'] | null;
-  };
 }