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

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

@@ -56,7 +56,7 @@ declare global {
      * @override
      * @param updateData - (default: `{}`)
      */
-    _getSubmitData(updateData?: FormApplication.OnSubmitOptions['updateData']): object;
+    _getSubmitData(updateData?: FormApplication.OnSubmitOptions['updateData']): Record<string, unknown>;
     // TODO: Can we type this better?
   }
 
@@ -67,7 +67,7 @@ declare global {
       isActorEffect: boolean;
       isItemEffect: boolean;
       submitText: string;
-      modes: Record<keyof typeof foundry.CONST.ACTIVE_EFFECT_MODES, string>;
+      modes: Record<foundry.CONST.ActiveEffectMode, string>;
     }
 
     type Options = DocumentSheet.Options;

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

@@ -91,8 +91,11 @@ declare global {
     /** @override */
     protected _onDragStart(event: DragEvent): void;
 
-    /** @override */
-    protected _onDrop(event: DragEvent): Promise<boolean | undefined> | unknown;
+    /**
+     * @override
+     * @internal
+     */
+    protected _onDrop(event: DragEvent): void;
 
     /**
      * Handle the dropping of ActiveEffect data onto an Actor Sheet

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

@@ -0,0 +1,57 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { AmbientSoundDataConstructorData } from '../../../../common/data/data.mjs/ambientSoundData';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientSound document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class AmbientSoundConfig<
+    Options extends DocumentSheet.Options = AmbientSoundConfig.Options,
+    Data extends object = AmbientSoundConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'AmbientSound'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: "SOUND.ConfigTitle",
+     *   template: "templates/scene/sound-config.html",
+     *   width: 480
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /** @override */
+    get title(): string;
+
+    /** @override */
+    getData(options?: Partial<Options>): Promise<Data> | Data;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: AmbientSoundConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'AmbientSound'>>>;
+
+    /** @override */
+    close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace AmbientSoundConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientSound'>>, Options> {
+      submitText: string;
+    }
+
+    type FormData = Pick<foundry.data.AmbientSoundData, 'easing' | 'path' | 'type' | 'volume'> &
+      Pick<AmbientSoundDataConstructorData, 'radius' | 'x' | 'y'>;
+
+    type Options = DocumentSheet.Options;
+  }
+}

package/src/foundry/foundry.js/applications/formApplications/{folderConfig.d.ts → documentSheets/folderConfig.d.ts}

@@ -1,5 +1,5 @@
-import type { ConfiguredDocumentClass } from '../../../../types/helperTypes';
-import type { SortingModes } from '../../../common/data/data.mjs/folderData';
+import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+import type { SortingModes } from '../../../../common/data/data.mjs/folderData';
 
 declare global {
   /**

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

@@ -1,11 +1,18 @@
 import './activeEffectConfig';
 import './actorSheet';
+import './ambientSoundConfig';
 import './combatantConfig';
+import './folderConfig';
 import './itemSheet';
 import './journalSheet';
+import './lightConfig';
 import './macroConfig';
+import './measuredTemplateConfig';
+import './noteConfig';
 import './permissionControl';
 import './playlistConfig';
+import './playlistSoundConfig';
 import './rollTableConfig';
 import './sceneConfig';
+import './tileConfig';
 import './userConfig';

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

@@ -0,0 +1,84 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { AmbientLightDataConstructorData } from '../../../../common/data/data.mjs/ambientLightData';
+import type { AnimationDataConstructorData } from '../../../../common/data/data.mjs/animationData';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single AmbientLight document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class LightConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = LightConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: "LIGHT.ConfigTitle",
+     *   template: "templates/scene/light-config.html",
+     *   width: 480
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    close(options?: Application.CloseOptions): Promise<void>;
+
+    /**
+     * Preview the change caused by a change on the form by refreshing the display of the light source
+     */
+    protected _onChangeInput(event: JQuery.ChangeEvent): Promise<void>;
+
+    /** @override */
+    protected _getSubmitData(
+      updateData?: LightConfig.FormData
+    ): ReturnType<DocumentSheet['_getSubmitData']> & { tintAlpha: number };
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: LightConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>> | undefined>;
+
+    /**
+     * Refresh the display of the AmbientLight object
+     * @internal
+     */
+    protected _refresh(): void;
+  }
+
+  namespace LightConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>, Options> {
+      submitText: string;
+      lightTypes: Record<foundry.CONST.SourceType, string>;
+      lightAnimations: Record<string, string> & {
+        '': 'None';
+      };
+      colorIntensity: number;
+    }
+
+    interface FormData
+      extends Pick<
+        AmbientLightDataConstructorData,
+        'angle' | 'bright' | 'darknessThreshold' | 'dim' | 'rotation' | 't' | 'tintAlpha' | 'tintColor' | 'x' | 'y'
+      > {
+      'lightAnimation.intensity': AnimationDataConstructorData['intensity'];
+      'lightAnimation.speed': AnimationDataConstructorData['speed'];
+      'lightAnimation.type': AnimationDataConstructorData['type'];
+    }
+  }
+}

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

@@ -0,0 +1,60 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single MeasuredTemplate document within a parent Scene.
+   * @see {@link MeasuredTemplate}
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class MeasuredTemplateConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = MeasuredTemplateConfig.Data
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "template-config",
+     *   classes: ["sheet", "template-sheet"],
+     *   title: "Measurement Template Configuration",
+     *   template: "templates/scene/template-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /** @override */
+    getData(): Data | Promise<Data>;
+
+    /** @override */
+    protected _updateObject(
+      event: Event,
+      formData: MeasuredTemplateConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>> | undefined>;
+  }
+
+  namespace MeasuredTemplateConfig {
+    interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'MeasuredTemplate'>>, Options> {
+      templateTypes: typeof CONFIG.MeasuredTemplate.types;
+      gridUnits: string;
+      submitText: string;
+    }
+
+    type FormData = {
+      angle: number | null;
+      borderColor: string;
+      direction: number | null;
+      distance: number | null;
+      fillColor: string;
+      t: ValueOf<foundry.CONST.MeasuredTemplateTypes>;
+      texture: string;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+    };
+  }
+}

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

@@ -0,0 +1,72 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Note document within a parent Scene.
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class NoteConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = NoteConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Note'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   title: game.i18n.localize("NOTE.ConfigTitle"),
+     *   template: "templates/scene/note-config.html",
+     *   width: 400,
+     * })
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: NoteConfig.FormData
+    ): Promise<ConfiguredDocumentClassForName<'Note'> | undefined>;
+
+    /**
+     * @override
+     */
+    close(options?: Application.CloseOptions): Promise<void>;
+  }
+
+  namespace NoteConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'Note'>>, Options> {
+      entry: ConfiguredDocumentClassForName<'JournalEntry'> | {};
+      entries: Journal['contents'];
+      icons: CONFIG['JournalEntry']['noteIcons'];
+      fontFamilies: Record<string, string>;
+      textAnchors: Record<foundry.CONST.TextAnchorPoint, string>;
+      submitText: string;
+    }
+
+    interface FormData {
+      entryId: string;
+      fontFamily: string;
+      fontSize: number | null;
+      icon: string;
+      iconSize: number | null;
+      iconTint: string;
+      text: string;
+      textAnchor: foundry.CONST.TextAnchorPoint;
+      textColor: string;
+      x: number | null;
+      y: number | null;
+    }
+  }
+}

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

@@ -1,72 +1,66 @@
-/**
- * A generic application for configuring permissions for various Entity types
- * @typeParam P - the type of the options object
- * @typeParam E - the type of the entity
- */
-declare class PermissionControl<
-  P extends DocumentSheet.Options = DocumentSheet.Options,
-  E extends foundry.abstract.Document<any, any> = foundry.abstract.Document<any, any>
-> extends DocumentSheet<P, PermissionControl.Data<E>, E> {
-  /**
-   * @param entity  - The Entity instance for which permissions are being configured.
-   * @param options - Application options.
-   */
-  constructor(entity: E, options?: Partial<P>);
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
 
+declare global {
   /**
-   * @override
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   id: "permission",
-   *   template: "templates/apps/permission.html",
-   *   width: 400
-   * });
-   * ```
+   * A generic application for configuring permissions for various Entity types
+   * @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 should be managed by this form sheet
    */
-  static get defaultOptions(): typeof DocumentSheet['defaultOptions'];
-
-  /** @override */
-  get title(): string;
+  class PermissionControl<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = DocumentSheet.Data,
+    ConcreteDocument extends foundry.abstract.Document<any, any> = Data extends DocumentSheet.Data<infer T>
+      ? T
+      : foundry.abstract.Document<any, any>
+  > extends DocumentSheet<Options, PermissionControl.Data<ConcreteDocument>, ConcreteDocument> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * mergeObject(super.defaultOptions, {
+     *   id: "permission",
+     *   template: "templates/apps/permission.html",
+     *   width: 400
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
 
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<P>): PermissionControl.Data<E>;
+    /** @override */
+    get title(): string;
 
-  /** @override */
-  protected _updateObject(event: Event, formData: PermissionControl.FormData): Promise<E>;
-}
+    /**
+     * @override
+     * @param options - (unused)
+     */
+    getData(options?: Partial<Options>): PermissionControl.Data<ConcreteDocument>;
 
-declare namespace PermissionControl {
-  interface Data<E extends foundry.abstract.Document<any, any>> extends DocumentSheet.Data {
-    entity: E;
-    currentDefault: number | '-1';
-    instructions: string;
-    defaultLevels: E extends Folder ? Data.FolderDefaultLevels : Data.EntityDefaultLevels;
-    playerLevels: E extends Folder ? Data.FolderPlayerLevels : Data.EntityPlayerLevels;
-    isFolder: E extends Folder ? true : false;
-    users: { user: User; level: number | '-1' }[];
+    /** @override */
+    protected _updateObject(event: Event, formData: PermissionControl.FormData): Promise<unknown>;
   }
 
-  namespace Data {
-    type EntityDefaultLevels = Omit<EntityPlayerLevels, '-1'>;
+  namespace PermissionControl {
+    interface Data<ConcreteDocument extends foundry.abstract.Document<any, any>> extends DocumentSheet.Data {
+      entity: ConcreteDocument;
+      currentDefault: foundry.CONST.EntityPermission | '-1';
+      instructions: string;
+      defaultLevels: Record<foundry.CONST.EntityPermission, string> & { '-1'?: string };
+      playerLevels: Record<foundry.CONST.EntityPermission | '-1', string> & { '-2'?: string };
+      isFolder: boolean;
+      users: {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+        level: foundry.CONST.EntityPermission | '-1';
+      }[];
+    }
 
-    type EntityPlayerLevels = Record<foundry.CONST.EntityPermission, string> & { '-1': string };
-
-    type FolderDefaultLevels = Omit<FolderPlayerLevels, '-2'>;
-
-    type FolderPlayerLevels = Record<foundry.CONST.EntityPermission, string> & { '-2': string; '-1': string };
-  }
-
-  interface FormData {
-    [userId: string]: FormData.InputPermissionLevel;
-    default: FormData.InputPermissionLevel;
-  }
+    interface FormData {
+      [userId: string]: FormData.InputPermissionLevel;
+      default: FormData.InputPermissionLevel;
+    }
 
-  namespace FormData {
-    // TODO: find a way to get this dynamically from ENTITY_PERMISSIONS
-    type InputPermissionLevel = '-1' | '0' | '1' | '2' | '3';
+    namespace FormData {
+      type InputPermissionLevel = foundry.CONST.EntityPermission | -1 | -2;
+    }
   }
 }

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

@@ -1,36 +1,49 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
+import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
 
-/**
- * Playlist Configuration Sheet
- */
-declare class PlaylistConfig extends DocumentSheet<DocumentSheet.Options, PlaylistConfig.Data, Playlist> {
+declare global {
   /**
-   * @defaultValue
-   * ```typescript
-   * const options = super.defaultOptions;
-   * options.id = "playlist-config";
-   * options.template = "templates/playlist/edit-playlist.html";
-   * options.width = 360;
-   * ```
+   * The Application responsible for configuring a single Playlist document.
+   * @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 PlaylistConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = PlaylistConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClass<typeof Playlist>>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * const options = super.defaultOptions;
+     * options.id = "playlist-config";
+     * options.template = "templates/playlist/edit-playlist.html";
+     * options.width = 360;
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
 
-  /**
-   * @override
-   */
-  get title(): string;
+    /** @override */
+    get title(): string;
 
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<DocumentSheet.Options>): PlaylistConfig.Data;
-}
+    /**
+     * @override
+     * @param options - (unused)
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    protected _getFilePickerOptions(event: PointerEvent): FilePicker.Options;
+
+    /**
+     * @override
+     * @remarks The return type could be given more concretely but it is not supposed to be used.
+     */
+    protected _onSelectFile(selection: string, filePicker: FilePicker): unknown;
+  }
 
-declare namespace PlaylistConfig {
-  interface Data extends foundry.utils.Duplicated<PlaylistConfig['object']['data']> {
-    modes: Record<string, ValueOf<typeof foundry.CONST['PLAYLIST_MODES']>>;
+  namespace PlaylistConfig {
+    interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClass<typeof Playlist>>, Options> {
+      modes: Record<foundry.CONST.PlaylistMode, string>;
+    }
   }
 }

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

@@ -0,0 +1,75 @@
+import type { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single PlaylistSound document within a parent Playlist.
+   *
+   * @param sound   - The PlaylistSound document being configured
+   * @param options - Additional application rendering options
+   * @typeParam Options - the type of the options object
+   * @typeParam Data    - The data structure used to render the handlebars template.
+   */
+  class PlaylistSoundConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = PlaylistSoundConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "track-config",
+     *   template: "templates/playlist/edit-track.html",
+     *   width: 360
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /** @override */
+    get title(): string;
+
+    /**
+     * @override
+     * @param options - (unused)
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    activateListeners(html: JQuery): void;
+
+    /**
+     * Auto-populate the track name using the provided filename, if a name is not already set
+     * @internal
+     */
+    protected _onSourceChange(event: JQuery.ChangeEvent): void;
+
+    /**
+     * @override
+     * @param event - (unused)
+     */
+    protected _updateObject(
+      event: Event,
+      formData: PlaylistSoundConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>> | undefined>;
+  }
+
+  namespace PlaylistSoundConfig {
+    /**
+     * @typeParam Options - the type of the options object
+     */
+    interface Data<Options extends DocumentSheet.Options = DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClass<typeof PlaylistSound>>, Options> {
+      lvolume: number;
+    }
+
+    interface FormData {
+      description: string;
+      fade: number | null;
+      lvolume: number;
+      name: string;
+      path: string;
+      repeat: boolean;
+    }
+  }
+}