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

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

@@ -0,0 +1,66 @@
+import { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { TileDataConstructorData } from '../../../../common/data/data.mjs/tileData';
+
+declare global {
+  /**
+   * The Application responsible for configuring a single Tile 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 TileConfig<
+    Options extends TileConfig.Options = TileConfig.Options,
+    Data extends object = TileConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Tile'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * mergeObject(super.defaultOptions, {
+     *   id: "tile-config",
+     *   title: game.i18n.localize("TILE.ConfigTitle"),
+     *   template: "templates/scene/tile-config.html",
+     *   width: 420,
+     *   height: "auto",
+     *   submitOnChange: true,
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static get defaultOptions(): TileConfig.Options;
+
+    /** @override */
+    close(options: Application.CloseOptions): Promise<void>;
+
+    /** @override */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    protected _onChangeInput(event: JQuery.ChangeEvent): void;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: TileConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'Tile'>> | undefined>;
+  }
+
+  namespace TileConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'Tile'>>, Options> {
+      submitText: string;
+      occlusionModes: Record<foundry.CONST.TileOcclusionModes, string>;
+    }
+
+    type FormData = Pick<TileDataConstructorData, 'height' | 'img' | 'rotation' | 'width' | 'x' | 'y'>;
+
+    interface Options extends DocumentSheet.Options {
+      /**
+       * Configure a preview version of a tile which is not yet saved
+       */
+      preview?: boolean;
+    }
+  }
+}

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

@@ -1,112 +1,110 @@
-/**
- * Configuration sheet for the Drawing object
- * @typeParam P - the type of the options object
- */
-declare class DrawingConfig<P extends DrawingConfig.Options = DrawingConfig.Options> extends FormApplication<
-  P,
-  DrawingConfig.Data,
-  Drawing
-> {
-  /**
-   * @param drawing - The Drawing object being configured
-   * @param options - Additional application rendering options
-   */
-  constructor(drawing: Drawing, options?: Partial<P>);
+import type { ConfiguredDocumentClassForName } from '../../../../types/helperTypes';
 
+declare global {
   /**
-   * @defaultValue
-   * ```typescript
-   * mergeObject(super.defaultOptions, {
-   *   id: "drawing-config",
-   *   classes: ["sheet"],
-   *   template: "templates/scene/drawing-config.html",
-   *   width: 480,
-   *   height: 360,
-   *   configureDefault: false,
-   *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "position"}]
-   * });
-   * ```
+   * The Application responsible for configuring a single Drawing 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(): DrawingConfig.Options;
+  class DrawingConfig<
+    Options extends DrawingConfig.Options = DrawingConfig.Options,
+    Data extends object = DrawingConfig.Data<Options>
+  > extends FormApplication<Options, Data, InstanceType<ConfiguredDocumentClassForName<'Drawing'>>> {
+    /**
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "drawing-config",
+     *   classes: ["sheet"],
+     *   template: "templates/scene/drawing-config.html",
+     *   width: 480,
+     *   height: 360,
+     *   configureDefault: false,
+     *   tabs: [{ navSelector: ".tabs", contentSelector: "form", initial: "position" }],
+     * });
+     * ```
+     */
+    static get defaultOptions(): DrawingConfig.Options;
 
-  /** @override */
-  get title(): string;
+    /** @override */
+    get title(): string;
 
-  /**
-   * @param options - (unused)
-   * @override
-   */
-  getData(options?: Partial<P>): DrawingConfig.Data;
+    /** @override */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
 
-  /**
-   * Get the names and labels of fill type choices which can be applied
-   */
-  protected static _getFillTypes(): DrawingConfig.FillTypes;
-
-  /**
-   * @param event - (unused)
-   * @override
-   */
-  protected _updateObject<F extends DrawingConfig.FormData>(
-    event: Event,
-    formData: F
-  ): Promise<this['options']['configureDefault'] extends true ? F : Drawing>;
+    /**
+     * Get the names and labels of fill type choices which can be applied
+     * @internal
+     */
+    protected static _getFillTypes(): DrawingConfig.FillTypes;
 
-  /** @override */
-  close(options?: FormApplication.CloseOptions): Promise<void>;
+    /** @override */
+    protected _updateObject(
+      event: Event,
+      formData: DrawingConfig.FormData
+    ): Promise<foundry.data.DrawingData['_source'] | ConfiguredDocumentClassForName<'Drawing'> | undefined>;
 
-  /** @override */
-  activateListeners(html: JQuery): void;
+    /** @override */
+    close(options?: FormApplication.CloseOptions): Promise<void>;
 
-  /**
-   * Reset the user Drawing configuration settings to their default values
-   */
-  protected _onResetDefaults(event: JQuery.ClickEvent): void;
-}
+    /** @override */
+    activateListeners(html: JQuery): void;
 
-declare namespace DrawingConfig {
-  interface Data {
-    author: string;
-    isDefault: Options['configureDefault'];
-    fillTypes: ReturnType<typeof DrawingConfig['_getFillTypes']>;
-    fontFamilies: Record<typeof CONFIG['fontFamilies'][number], typeof CONFIG['fontFamilies'][number]>;
-    object: DrawingConfig['object']['data'];
-    options: DrawingConfig['options'];
-    submitText: string;
+    /**
+     * Reset the user Drawing configuration settings to their default values
+     * @param event - The originating mouse-click event
+     */
+    protected _onResetDefaults(event: JQuery.ClickEvent): void;
   }
 
-  type FillTypes = {
-    [Key in keyof typeof foundry.CONST['DRAWING_FILL_TYPES'] as typeof foundry.CONST['DRAWING_FILL_TYPES'][Key]]: `DRAWING.FillType${Titlecase<Key>}`;
-  };
+  namespace DrawingConfig {
+    interface Data<Options extends DrawingConfig.Options = DrawingConfig.Options> {
+      author: string;
+      isDefault: boolean;
+      fillTypes: DrawingConfig.FillTypes;
+      fontFamilies: Record<string, string>;
+      object: foundry.data.DrawingData['_source'];
+      options: Options;
+      submitText: string;
+    }
 
-  interface FormData {
-    bezierFactor: foundry.data.DrawingData['_source']['bezierFactor'];
-    fillAlpha: foundry.data.DrawingData['_source']['fillAlpha'];
-    fillColor: foundry.data.DrawingData['_source']['fillColor'];
-    fillType: foundry.data.DrawingData['_source']['fillType'];
-    fontFamily: foundry.data.DrawingData['_source']['fontFamily'];
-    fontSize: foundry.data.DrawingData['_source']['fontSize'] | null;
-    height: foundry.data.DrawingData['_source']['height'] | null;
-    rotation: foundry.data.DrawingData['_source']['rotation'] | null;
-    strokeAlpha: foundry.data.DrawingData['_source']['strokeAlpha'];
-    strokeColor: foundry.data.DrawingData['_source']['strokeColor'];
-    strokeWidth: foundry.data.DrawingData['_source']['strokeWidth'] | null;
-    text: string;
-    textAlpha: foundry.data.DrawingData['_source']['textAlpha'];
-    textColor: foundry.data.DrawingData['_source']['textColor'];
-    texture: string;
-    width: foundry.data.DrawingData['_source']['width'] | null;
-    x: foundry.data.DrawingData['_source']['x'] | null;
-    y: foundry.data.DrawingData['_source']['y'] | null;
-    z: foundry.data.DrawingData['_source']['z'] | null;
-  }
+    type FillTypes = {
+      [Key in keyof typeof foundry.CONST['DRAWING_FILL_TYPES'] as typeof foundry.CONST['DRAWING_FILL_TYPES'][Key]]: `DRAWING.FillType${Titlecase<Key>}`;
+    };
 
-  interface Options extends FormApplication.Options {
-    configureDefault: boolean;
+    interface FormData {
+      bezierFactor: number;
+      fillAlpha: number;
+      fillColor: string;
+      fillType: foundry.CONST.DrawingFillType;
+      fontFamily: string;
+      fontSize: number | null;
+      height: number | null;
+      rotation: number | null;
+      strokeAlpha: number;
+      strokeColor: string;
+      strokeWidth: number | null;
+      text: string;
+      textAlpha: number;
+      textColor: string;
+      texture: string;
+      width: number | null;
+      x: number | null;
+      y: number | null;
+      z: number | null;
+    }
 
-    /**
-     * Configure a preview version of the Drawing which is not yet saved
-     */
-    preview?: boolean;
+    interface Options extends FormApplication.Options {
+      /**
+       * Configure the default drawing settings, instead of a specific Drawing
+       * @defaultValue `false`
+       */
+      configureDefault: boolean;
+
+      /**
+       * Configure a preview version of the Drawing which is not yet saved
+       */
+      preview?: boolean;
+    }
   }
 }

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,21 +1,15 @@
-import './ambientSoundConfig';
 import './avConfig';
 import './combatTrackerConfig';
+import './defaultTokenConfig';
 import './documentSheet';
 import './documentSheets';
 import './drawingConfig';
 import './entitySheetConfig';
-import './folderConfig';
 import './gridConfig';
 import './imagePopout';
-import './lightConfig';
-import './measuredTemplateConfig';
 import './moduleManagement';
-import './noteConfig';
 import './permissionConfig';
-import './playlistSoundConfig';
 import './settingsConfig';
-import './tileConfig';
 import './tokenConfig';
 import './wallConfig';
 import './worldConfig';