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

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

@@ -0,0 +1,257 @@
+/**
+ * Allows for viewing and editing of Keybinding Actions
+ */
+declare class KeybindingsConfig<
+  Options extends FormApplication.Options = FormApplication.Options,
+  Data extends KeybindingsConfig.Data = KeybindingsConfig.Data
+> extends FormApplication<Options, Data> {
+  /**
+   * A cached copy of the Categories
+   */
+  protected _cachedData: KeybindingsConfig.CategoryData | null;
+
+  /**
+   * The category being filtered for
+   */
+  protected _category: string;
+
+  /**
+   * A Map of pending Edits. The Keys are bindingIds
+   * @internal
+   */
+  protected _pendingEdits: Map<string, KeybindingsConfig.PendingBinding[]>;
+
+  /**
+   * @override
+   * @defaultValue
+   * ```typescript
+   * foundry.utils.mergeObject(super.defaultOptions, {
+   *   title: game.i18n.localize("SETTINGS.Keybindings"),
+   *   id: "keybindings",
+   *   template: "templates/sidebar/apps/keybindings-config.html",
+   *   width: 750,
+   *   height: 600,
+   *   resizable: true,
+   *   scrollY: [".filters", ".category-list"],
+   *   filters: [{inputSelector: 'input[name="filter"]', contentSelector: ".category-list"}]
+   * })
+   * ```
+   */
+  static get defaultOptions(): FormApplication.Options;
+
+  /**
+   * @param options - (unused)
+   * @override
+   */
+  getData(options?: Partial<Options>): Data;
+
+  /**
+   * Builds the set of Bindings into a form usable for display and configuration
+   * @internal
+   */
+  protected _getCategoryData(): KeybindingsConfig.CategoryData;
+
+  /**
+   * Add faux-keybind actions that represent the possible Mouse Controls
+   * @param categories - The current Map of Categories to add to
+   * @returns The number of Actions added
+   * @internal
+   */
+  protected _addMouseControlsReference(categories: Map<string, KeybindingsConfig.Category>): number;
+
+  /**
+   * Given an Binding and its parent Action, detects other Actions that might conflict with that binding
+   * @param actionId - The namespaced Action ID the Binding belongs to
+   * @param action   - The Action config
+   * @param binding  - The Binding
+   * @internal
+   */
+  protected _detectConflictingActions(
+    actionId: string,
+    action: KeybindingActionConfig,
+    binding: KeybindingActionBinding
+  ): KeybindingAction[];
+
+  /**
+   * Transforms a Binding into a human readable string representation
+   * @param binding - The Binding
+   * @returns A human readable string
+   * @internal
+   */
+  protected static _humanizeBinding(binding: KeybindingActionBinding): string;
+
+  /**
+   * Compares two Category Filters for rendering
+   * This method ignores cases of equality because we know our categories are unique
+   * @param a - The first Category
+   * @param b - The second Category
+   * @returns A number for usage in the Sort method
+   * @internal
+   */
+  protected static _sortCategories(a: KeybindingsConfig.Category, b: KeybindingsConfig.Category): number;
+
+  /**
+   * Classify what Category an Action belongs to
+   * @param action - The Action to classify
+   * @returns The category the Action belongs to
+   * @internal
+   */
+  protected _categorizeAction(action: KeybindingsConfig): KeybindingsConfig.BaseCategory;
+
+  /** @override */
+  activateListeners(html: JQuery): void;
+
+  /**
+   * Handle left-click events to filter to a certain category
+   * @internal
+   */
+  protected _onClickCategoryFilter(event: MouseEvent): void;
+
+  /**
+   * Handle left-click events to show / hide a certain category
+   * @internal
+   */
+  protected _onClickCategoryCollapse(event: MouseEvent): void;
+
+  /**
+   * Handle left-click events to reset all Actions to Default
+   * @internal
+   */
+  protected _onClickResetActions(event: MouseEvent): Promise<void>;
+
+  /**
+   * Handle Control clicks
+   * @internal
+   */
+  protected _onClickBindingControl(event: MouseEvent): void;
+
+  /**
+   * Handle left-click events to show / hide a certain category
+   * @internal
+   */
+  protected _onClickAdd(event: MouseEvent): Promise<void>;
+
+  /**
+   * Handle left-click events to show / hide a certain category
+   * @internal
+   */
+  protected _onClickDelete(event: MouseEvent): Promise<void>;
+
+  /**
+   * Inserts a Binding into the Pending Edits object, creating a new Map entry as needed
+   * @internal
+   */
+  protected _addPendingEdit(
+    namespace: string,
+    action: string,
+    bindingIndex: number,
+    binding: KeybindingsConfig.PendingBinding
+  ): void;
+
+  /**
+   * Toggle visibility of the Edit / Save UI
+   * @internal
+   */
+  protected _onClickEditableBinding(event: MouseEvent): void;
+
+  /**
+   * Toggle visibility of the Edit UI
+   * @internal
+   */
+  protected _onDoubleClickKey(event: MouseEvent): void;
+
+  /**
+   * Save the new Binding value and update the display of the UI
+   * @internal
+   */
+  protected _onClickSaveBinding(event: MouseEvent): Promise<void>;
+
+  /**
+   * Given a clicked Action element, finds the parent Action
+   * @internal
+   */
+  protected _getParentAction(event: KeyboardEvent | MouseEvent): {
+    namespace: string;
+    action: string;
+    actionHtml: HTMLElement;
+  };
+
+  /**
+   * Given a Clicked binding control element, finds the parent Binding
+   * @internal
+   */
+  protected _getParentBinding(event: KeyboardEvent | MouseEvent): { bindingHtml: HTMLElement; bindingId: string };
+
+  /**
+   * Iterates over all Pending edits, merging them in with unedited Bindings and then saving and resetting the UI
+   * @internal
+   */
+  protected _savePendingEdits(): Promise<void>;
+
+  /**
+   * Processes input from the keyboard to form a list of pending Binding edits
+   * @param event - The keyboard event
+   * @internal
+   */
+  protected _onKeydownBindingInput(event: KeyboardEvent): void;
+
+  /**
+   * @param event - (unused)
+   * @override
+   */
+  protected _onSearchFilter(event: KeyboardEvent, query: string, rgx: RegExp, html: HTMLElement): void;
+
+  /** @remarks KeybindingsConfig does not implement this method. */
+  protected _updateObject(event?: unknown, formData?: unknown): Promise<never>;
+}
+
+declare namespace KeybindingsConfig {
+  interface Data extends CategoryData {
+    categories: DataCategory[];
+    allActive: boolean;
+  }
+
+  interface DataCategory extends Category {
+    active: boolean;
+    hidden: boolean;
+  }
+
+  interface CategoryData {
+    categories: Category[];
+    totalActions: number;
+  }
+
+  interface BaseCategory {
+    id: string;
+    title: string;
+  }
+
+  interface Category extends BaseCategory {
+    actions: ActionData[];
+    count: number;
+  }
+
+  interface ActionData extends KeybindingActionConfig {
+    category: string;
+    bindings: DisplayBinding[];
+    id: string;
+    name: string;
+    hint?: string;
+    cssClass?: string;
+    notes: string;
+  }
+
+  interface DisplayBinding extends Partial<KeybindingActionBinding> {
+    id: string;
+    display: string;
+    cssClasses: string;
+    isEditable: boolean;
+    isFirst: boolean;
+    conflicts: string;
+    hasConflicts: boolean;
+  }
+
+  interface PendingBinding extends KeybindingActionBinding {
+    index: number;
+  }
+}

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