@league-of-foundry-developers/foundry-vtt-types 0.8.9-6 → 9.238.0

package/src/foundry/common/packages.mjs/worldData.d.ts

@@ -3,13 +3,13 @@ import * as fields from '../data/fields.mjs';
 import { PackageData, PackageDataConstructorData, PackageDataProperties, PackageDataSchema } from './packageData';
 
 interface WorldDataSchema extends Omit<PackageDataSchema, 'system'> {
-  system: typeof fields.REQUIRED_STRING;
-  background: typeof fields.STRING_FIELD;
-  coreVersion: typeof fields.REQUIRED_STRING;
-  nextSession: typeof fields.STRING_FIELD;
-  resetKeys: typeof fields.BOOLEAN_FIELD;
-  safeMode: typeof fields.BOOLEAN_FIELD;
-  systemVersion: FieldReturnType<typeof fields.REQUIRED_STRING, { default: () => string }>;
+  system: fields.RequiredString;
+  background: fields.StringField;
+  coreVersion: fields.RequiredString;
+  nextSession: fields.StringField;
+  resetKeys: fields.BooleanField;
+  safeMode: fields.BooleanField;
+  systemVersion: FieldReturnType<fields.RequiredString, { default: () => string }>;
 }
 
 interface WorldDataProperties extends Omit<PackageDataProperties, 'system'> {
@@ -17,19 +17,24 @@ interface WorldDataProperties extends Omit<PackageDataProperties, 'system'> {
   system: string;
 
   /** A web URL or local file path which provides a background banner image */
-  background?: string;
+  background: string | undefined;
 
   /** The version of the core software for which this world has been migrated */
   coreVersion: string;
 
   /** An ISO datetime string when the next game session is scheduled to occur */
-  nextSession?: string;
+  nextSession: string | undefined;
 
+  /** @defaultValue `false` */
   resetKeys: boolean;
 
+  /** @defaultValue `false` */
   safeMode: boolean;
 
-  /** The version of the game system for which this world has been migrated */
+  /**
+   * The version of the game system for which this world has been migrated
+   * @defaultValue `"0"`
+   */
   systemVersion: string;
 }
 
@@ -38,29 +43,35 @@ interface WorldDataConstructorData extends Omit<PackageDataConstructorData, 'sys
   system: string;
 
   /** A web URL or local file path which provides a background banner image */
-  background?: string | null;
+  background?: string | null | undefined;
 
   /** The version of the core software for which this world has been migrated */
   coreVersion: string;
 
   /** An ISO datetime string when the next game session is scheduled to occur */
-  nextSession?: string | null;
+  nextSession?: string | null | undefined;
 
-  resetKeys?: boolean | null;
+  /** @defaultValue `false` */
+  resetKeys?: boolean | null | undefined;
 
-  safeMode?: boolean | null;
+  /** @defaultValue `false` */
+  safeMode?: boolean | null | undefined;
 
-  /** The version of the game system for which this world has been migrated */
-  systemVersion?: string | null;
+  /**
+   * The version of the game system for which this world has been migrated
+   * @defaultValue `"0"`
+   */
+  systemVersion?: string | null | undefined;
 }
 
 /**
  * The data schema used to define World manifest files.
  * Extends the basic PackageData schema with some additional world-specific fields.
  */
-export declare class WorldData extends PackageData<WorldDataSchema, WorldDataProperties, WorldDataConstructorData> {
+export class WorldData extends PackageData<WorldDataSchema, WorldDataProperties, WorldDataConstructorData> {
+  /** @override */
   static defineSchema(): WorldDataSchema;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export declare interface WorldData extends WorldDataProperties {}
+export interface WorldData extends WorldDataProperties {}

package/src/foundry/common/types.mjs.d.ts

@@ -20,6 +20,101 @@ declare type Rectangle =
       height: number;
     };
 
+/** A Client Keybinding Action Configuration */
+declare interface KeybindingActionConfig {
+  /** The namespace within which the action was registered */
+  namespace?: string;
+
+  /** The human readable name */
+  name: string;
+
+  /** An additional human readable hint */
+  hint?: string;
+
+  /** The default bindings that can never be changed nor removed. */
+  uneditable?: KeybindingActionBinding[];
+
+  /** The default bindings that can be changed by the user. */
+  editable?: KeybindingActionBinding[];
+
+  /** A function to execute when a key down event occurs. If True is returned, the event is consumed and no further keybinds execute. */
+  onDown?: () => boolean | void;
+
+  /** A function to execute when a key up event occurs. If True is returned, the event is consumed and no further keybinds execute. */
+  onUp?: () => boolean | void;
+
+  /** If True, allows Repeat events to execute the Action's onDown. Defaults to false. */
+  repeat?: boolean;
+
+  /** If true, only a GM can edit and execute this Action */
+  restricted?: boolean;
+
+  /** Modifiers such as [ "CONTROL" ] that can be also pressed when executing this Action. Prevents using one of these modifiers as a Binding. */
+  reservedModifiers?: string[];
+
+  /** The preferred precedence of running this Keybinding Action */
+  precedence?: number; // TODO: KEYBINDING_PRECEDENCE?
+
+  /** The recorded registration order of the action */
+  order?: number;
+}
+
+/** A Client Keybinding Action Binding */
+declare interface KeybindingActionBinding {
+  /** The KeyboardEvent#code value from https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code/code_values */
+  key: string;
+
+  /** An array of modifiers keys from KeyboardManager.MODIFIER_KEYS which are required for this binding to be activated */
+  modifiers?: string[];
+}
+
+declare interface KeybindingAction {
+  action: string;
+  key: string;
+  name: string;
+  requiredModifiers: string[];
+  optionalModifiers: string[];
+  onDown: Function;
+  onUp: Function;
+  repeat: boolean;
+  restricted: boolean;
+  precedence: number;
+  order: number;
+}
+
+/** Keyboard event context */
+declare interface KeyboardEventContext {
+  /** The normalized string key, such as "A" */
+  key: string;
+
+  /** The originating keypress event */
+  event: KeyboardEvent;
+
+  /** Is the Shift modifier being pressed */
+  isShift: boolean;
+
+  /** Is the Control or Meta modifier being processed */
+  isControl: boolean;
+
+  /** Is the Alt modifier being pressed */
+  isAlt: boolean;
+
+  /** Are any of the modifiers being pressed */
+  hasModifier: boolean;
+
+  /** A list of string modifiers applied to this context, such as [ "CONTROL" ] */
+  modifiers: string[];
+
+  /** True if the Key is Up, else False if down */
+  up: boolean;
+
+  /** True if the given key is being held down such that it is automatically repeating. */
+  repeat: boolean;
+
+  /** The executing Keybinding Action. May be undefined until the action is known. */
+  action: string | undefined;
+}
+
 type RequestData = object | object[] | string | string[];
 
 interface SocketRequest {
@@ -84,4 +179,9 @@ interface SocketResponse {
    * Data returned as a result of the request
    */
   data?: RequestData;
+
+  /**
+   * An Array of created data objects
+   */
+  result?: object[];
 }

package/src/foundry/common/utils/helpers.mjs.d.ts

@@ -2,8 +2,13 @@
  * Benchmark the performance of a function, calling it a requested number of iterations.
  * @param func       - The function to benchmark
  * @param iterations - The number of iterations to test
+ * @param args       - Additional arguments passed to the benchmarked function
  */
-export declare function benchmark(func: () => unknown, iterations: number): void;
+export declare function benchmark<F extends (...args: any[]) => unknown>(
+  func: F,
+  iterations: number,
+  ...args: Parameters<F>
+): Promise<void>;
 
 /**
  * Wrap a callback in a debounced timeout.
@@ -22,9 +27,18 @@ export declare function debounce<T extends (...args: any[]) => unknown>(
  * This method DOES support recursive data structures containing inner objects or arrays.
  * This method DOES NOT support advanced object types like Set, Map, or other specialized classes.
  * @param original - Some sort of data
+ * @param options  - Options to configure the behaviour of deepClone
  * @returns The clone of that data
  */
-export declare function deepClone<T>(original: T): T;
+export declare function deepClone<T>(original: T, options?: DeepCloneOptions): T;
+
+interface DeepCloneOptions {
+  /**
+   * Throw an Error if deepClone is unable to clone something instead of returning the original
+   * @defaultValue `false`
+   */
+  strict?: boolean;
+}
 
 /**
  * Deeply difference an object against some other, returning the update keys and values
@@ -101,6 +115,17 @@ type InnerDuplicated<T> = T extends { toJSON(): infer U }
  */
 export type Duplicated<T> = T extends NonStringifiable ? never : InnerDuplicated<T>;
 
+/**
+ * Test whether some class is a subclass of a parent.
+ * @param cls    - The class to test
+ * @param parent - Some other class which may be a parent
+ * @returns Is the class a subclass of the parent?
+ */
+export declare function isSubclass(
+  cls: new (...args: any[]) => unknown,
+  parent: new (...args: any[]) => unknown
+): boolean;
+
 /**
  * Encode a url-like string by replacing any characters which need encoding
  * @param path - A fully-qualified URL or url component (like a relative path)

package/src/foundry/common/utils/primitives.mjs.d.ts

@@ -1,4 +1,4 @@
-declare interface Math {
+interface Math {
   /**
    * Bound a number between some minimum and maximum value, inclusively
    * @param num - The current value
@@ -44,7 +44,7 @@ declare interface Math {
   toRadians(angle: number): number;
 }
 
-declare interface Set<T> {
+interface Set<T> {
   /**
    * Test whether this set is equal to some other set.
    * Sets are equal if they share the same members, independent of order
@@ -53,6 +53,26 @@ declare interface Set<T> {
    */
   equals(other: Set<T>): boolean;
 
+  /**
+   * Return the first value from the set.
+   * @returns The first element in the set, or undefined
+   */
+  first(): T | undefined;
+
+  /**
+   * Return the intersection of two sets.
+   * @param other - Some other set to compare against
+   * @returns The intersection of both sets
+   */
+  intersection(other: Set<T>): Set<T>;
+
+  /**
+   * Test whether this set has an intersection with another set.
+   * @param other - Another set to compare against
+   * @returns Do the sets intersect?
+   */
+  intersects(other: Set<T>): boolean;
+
   /**
    * Test whether this set is a subset of some other set.
    * A set is a subset if all its members are also present in the other set.
@@ -62,9 +82,15 @@ declare interface Set<T> {
   isSubset(other: Set<T>): boolean;
 }
 
-declare interface String {
+interface String {
+  /**
+   * Capitalize a string, transforming it's first character to a capital letter
+   */
   capitalize<S extends string>(this: S): Capitalize<S>;
 
+  /**
+   * Convert a string to Title Case where the first letter of each word is capitalized
+   */
   titleCase<S extends string>(this: S): Titlecase<S>;
 
   /**
@@ -74,20 +100,59 @@ declare interface String {
 
   /**
    * Transform any string into a url-viable slug string
-   * @param replacement - The replacement character to separate terms
-   *                      (default: `'-'`)
-   * @param strict      - Replace all non-alphanumeric characters, or allow them?
-   *                      (default: `false`)
+   * @param options - Optional arguments which customize how the slugify operation is performed
    * @returns The cleaned slug string
    */
-  slugify({ replacement, strict }?: { replacement?: string; strict?: boolean }): string;
+  slugify(options?: String.SlugifyOptions): string;
+}
+
+declare namespace String {
+  interface SlugifyOptions {
+    /**
+     * The replacement character to separate terms
+     * @defaultValue `'-'`
+     */
+    replacement?: string;
+
+    /**
+     * Replace all non-alphanumeric characters, or allow them?
+     * @defaultValue `false`
+     */
+    strict?: boolean;
+  }
 }
 
-declare interface Number {
+interface Number {
+  /**
+   * Test for near-equivalence of two numbers within some permitted epsilon
+   * @param n - Some other number
+   * @param e - Some permitted epsilon, by default 1e-8
+                (default: `1e-8`)
+   * @returns Are the numbers almost equal?
+   */
+  almostEqual(n: number, e?: number): boolean;
+
+  /**
+   * Transform a number to an ordinal string representation. i.e.
+   * ```
+   * 1 => 1st
+   * 2 => 2nd
+   * 3 => 3rd
+   * ```
+   */
   ordinalString(): string;
 
+  /**
+   * Return a string front-padded by zeroes to reach a certain number of numeral characters
+   * @param digits - The number of characters desired
+   * @returns The zero-padded number
+   */
   paddedString(digits: number): string;
 
+  /**
+   * Return a string prefaced by the sign of the number (+) or (-)
+   * @returns The signed number as a string
+   */
   signedString(): string;
 
   /**
@@ -110,10 +175,15 @@ declare interface Number {
    */
   toNearest(interval?: number, method?: 'round' | 'ceil' | 'floor'): number;
 
+  /**
+   * A faster numeric between check which avoids type coercion to the Number object
+   * Since this avoids coercion, if non-numbers are passed in unpredictable results will occur. Use with caution.
+   * @param inclusive - (default: `true`)
+   */
   between(a: number, b: number, inclusive?: boolean): boolean;
 }
 
-declare interface NumberConstructor {
+interface NumberConstructor {
   /**
    * A faster numeric between check which avoids type coercion to the Number object
    * Since this avoids coercion, if non-numbers are passed in unpredictable results will occur. Use with caution.
@@ -123,19 +193,27 @@ declare interface NumberConstructor {
 
   /**
    * Test whether a value is numeric
-   * This is the highest performing algorithm currently available
-   * https://jsperf.com/isnan-vs-typeof/5
+   * This is the highest performing algorithm currently available, per https://jsperf.com/isnan-vs-typeof/5
    * @param n - A value to test
    * @returns Is it a number?
    */
   isNumeric(n: unknown): n is number;
 }
 
-declare interface ArrayConstructor {
+interface ArrayConstructor {
+  /**
+   * Create and initialize an array of length n with integers from 0 to n-1
+   * @param n - The desired array length
+   * @returns An array of integers from 0 to n
+   */
   fromRange(n: number): number[];
 }
 
-declare interface Array<T> {
+interface Array<T> {
+  /**
+   * Flatten nested arrays by concatenating their contents
+   * @returns An array containing the concatenated inner values
+   */
   deepFlatten(): Array<Array.Flattened<T>>;
 
   /**
@@ -171,7 +249,7 @@ declare namespace Array {
   type Flattened<T> = T extends Array<infer U> ? Flattened<U> : T;
 }
 
-declare interface Date {
+interface Date {
   /**
    * Test whether a Date instance is valid.
    * A valid date returns a number for its timestamp, and NaN otherwise.
@@ -192,6 +270,11 @@ declare interface Date {
   toTimeInputString(): string;
 }
 
-declare interface RegExpConstructor {
+interface RegExpConstructor {
+  /**
+   * Escape a given input string, prefacing special characters with backslashes for use in a regular expression
+   * @param string - The un-escaped input string
+   * @returns  The escaped string, suitable for use in regular expression
+   */
   escape(string: string): string;
 }

package/src/foundry/foundry.js/application.d.ts

@@ -312,12 +312,9 @@ declare abstract class Application<Options extends Application.Options = Applica
    * Callback actions which occur when a dragged element is dropped on a target.
    * @param event - The originating DragEvent
    *                (unused)
-   * @remarks
-   * The implementation in {@link Application} actually returns `void` but it is
-   * typed as `unknown` to allow deriving methods to return whatever they want.
-   * The returned value is not meant to be used.
+   * @internal
    */
-  protected _onDrop(event: DragEvent): unknown;
+  protected _onDrop(event: DragEvent): void;
 
   /**
    * Bring the application to the top of the rendering stack
@@ -443,7 +440,7 @@ declare namespace Application {
 
     /**
      * The default CSS id to assign to the rendered HTML
-     * @defaultValue `''`
+     * @defaultValue `""`
      */
     id: string;
 
@@ -455,7 +452,7 @@ declare namespace Application {
 
     /**
      * A default window title string (popOut only)
-     * @defaultValue `''`
+     * @defaultValue `""`
      */
     title: string;
 

package/src/foundry/foundry.js/applications/cameraViews.d.ts

@@ -1,30 +1,24 @@
-// TODO: Remove when updating this class!!!
-// eslint-disable-next-line
-// @ts-nocheck
-
 /**
  * The Camera UI View that displays all the camera feeds as individual video elements.
- * @typeParam P - the type of the options object
+ * @typeParam Options - the type of the options object
+ * @typeParam Data    - The data structure used to render the handlebars template.
  */
-declare class CameraViews<P extends Application.Options = Application.Options> extends Application<P> {
-  /**
-   * @param webrtc - The WebRTC Implementation to display
-   *                 (unused)
-   */
-  constructor(webrtc?: any, options?: Partial<P>);
-
+declare class CameraViews<
+  Options extends Application.Options = Application.Options,
+  Data extends object = CameraViews.Data
+> extends Application<Options> {
   /**
    * @override
    * @defaultValue
    * ```typescript
-   * mergeObject(super.defaultOptions, {
+   * return foundry.utils.mergeObject(super.defaultOptions, {
    *   id: "camera-views",
    *   template: "templates/hud/camera-views.html",
-   *   popOut: false
-   * });
+   *   popOut: false,
+   * })
    * ```
    */
-  static get defaultOptions(): typeof Application['defaultOptions'];
+  static get defaultOptions(): Application.Options;
 
   /**
    * A reference to the master AV orchestrator instance
@@ -56,26 +50,29 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
    * Extend the render logic to first check whether a render is necessary based on the context
    * If a specific context was provided, make sure an update to the navigation is necessary before rendering
    */
-  render(force?: boolean, context?: Application.RenderOptions<P>): Application['render'];
+  render(force?: boolean, context?: Application.RenderOptions<Options>): this | void;
 
   /** @override */
-  protected _render(force?: boolean, options?: Application.RenderOptions<P>): Promise<void>;
+  protected _render(force?: boolean, options?: Application.RenderOptions<Options>): Promise<void>;
 
   /**
    * @param options - (unused)
    * @override
    */
-  getData(options?: Partial<P>): CameraViews.Data;
+  getData(options?: Partial<Options>): Data | Promise<Data>;
 
-  maxZ: number;
+  /** @defaultValue `undefined` */
+  maxZ?: number;
 
   /**
    * Prepare rendering data for a single user
+   * @internal
    */
   protected _getDataForUser(userId: string, settings: AVSettings.UserSettings): CameraViews.Data.User | null;
 
   /**
    * A custom sorting function that orders/arranges the user display frames
+   * @internal
    */
   protected static _sortUsers(a: CameraViews.Data.User, b: CameraViews.Data.User): number;
 
@@ -85,30 +82,35 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
   /**
    * On hover in a camera container, show/hide the controls.
    * @param event - The original mouseover or mouseout hover event
+   * @internal
    */
   protected _onCameraViewHover(event: JQuery.MouseEnterEvent | JQuery.MouseLeaveEvent): void;
 
   /**
    * On clicking on a toggle, disable/enable the audio or video stream.
    * @param event - The originating click event
+   * @internal
    */
   protected _onClickControl(event: JQuery.ClickEvent): Promise<void>;
 
   /**
    * Change volume control for a stream
    * @param event - The originating change event from interaction with the range input
+   * @internal
    */
   protected _onVolumeChange(event: JQuery.ChangeEvent): void;
 
   /**
    * Dynamically refresh the state of a single camera view
    * @param view - The view container div
+   * @internal
    */
   protected _refreshView(view: HTMLElement): void;
 
   /**
    * Render changes needed to the PlayerList ui.
    * Show/Hide players depending on option.
+   * @internal
    */
   protected _setPlayerListVisibility(): void;
 
@@ -119,8 +121,9 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
    * @param action - The named av-control button action
    * @param state  - The CURRENT action state.
    * @returns The icon that represents the NEXT action state.
+   * @internal
    */
-  protected _getToggleIcon(action: string, state?: boolean): null;
+  protected _getToggleIcon(action: string, state: boolean): string | null;
 
   /**
    * Get the text title that should be used for various action buttons with different toggled states.
@@ -129,6 +132,7 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
    * @param action - The named av-control button action
    * @param state - The CURRENT action state.
    * @returns The icon that represents the NEXT action state.
+   * @internal
    */
   protected _getToggleTooltip(action: string, state: boolean): string;
 
@@ -142,6 +146,7 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
    * @param show      - Whether to show or hide the controls
    * @param selector  - Override selector to specify which controls to show or hide
    *                    (default: `'.control-bar'`)
+   * @internal
    */
   protected _toggleControlVisibility(container: HTMLElement, show: boolean, selector?: string): void;
 }
@@ -149,24 +154,24 @@ declare class CameraViews<P extends Application.Options = Application.Options> e
 declare namespace CameraViews {
   interface Data {
     self: Game['user'];
-    users: CameraViews.Data.User[];
+    users: Data.User[];
     dockClass: string;
     muteAll: boolean;
   }
 
   namespace Data {
     interface User {
-      user: globalThis.User;
-      id: globalThis.User['id'];
-      local: globalThis.User['isSelf'];
-      name: globalThis.User['name'];
-      color: globalThis.User['data']['color'];
-      colorAlpha: ReturnType<typeof foundry.utils.hexToRGBAString>;
+      user: StoredDocument<globalThis.User>;
+      id: StoredDocument<globalThis.User>['id'];
+      local: StoredDocument<globalThis.User>['isSelf'];
+      name: StoredDocument<globalThis.User>['name'];
+      color: StoredDocument<globalThis.User>['data']['color'];
+      colorAlpha: `rgba(${number}, ${number}, ${number})`;
       charname: string;
-      avatar: globalThis.User['avatar'];
+      avatar: StoredDocument<globalThis.User>['avatar'];
       settings: AVSettings.UserSettings;
-      volume: ReturnType<typeof AudioHelper['volumeToInput']>;
-      cameraViewClass: ReturnType<Array<string>['filterJoin']>;
+      volume: number;
+      cameraViewClass: string;
     }
   }
 }

package/src/foundry/foundry.js/applications/compendium.d.ts

@@ -67,8 +67,11 @@ declare class Compendium<
   /** @override */
   protected _onDragStart(event: DragEvent): void;
 
-  /** @override */
-  protected _onDrop(event: DragEvent): ReturnType<this['collection']['importDocument']> | false;
+  /**
+   * @override
+   * @internal
+   */
+  protected _onDrop(event: DragEvent): void;
 
   /**
    * Render the ContextMenu which applies to each compendium Document