@league-of-foundry-developers/foundry-vtt-types 0.8.9-9 → 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 {

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

@@ -440,7 +440,7 @@ declare namespace Application {
 
     /**
      * The default CSS id to assign to the rendered HTML
-     * @defaultValue `''`
+     * @defaultValue `""`
      */
     id: string;
 
@@ -452,7 +452,7 @@ declare namespace Application {
 
     /**
      * A default window title string (popOut only)
-     * @defaultValue `''`
+     * @defaultValue `""`
      */
     title: string;
 

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

@@ -70,7 +70,7 @@ declare class FilePicker<
 
   /**
    * Record the last-browsed directory path so that re-opening a different FilePicker instance uses the same target
-   * @defaultValue `''`
+   * @defaultValue `""`
    */
   static LAST_BROWSED_DIRECTORY: string;
 

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

@@ -171,7 +171,7 @@ declare abstract class FormApplication<
    * @param options        - TinyMCE initialization options passed to TextEditor.create
    *                         (default: `{}`)
    * @param initialContent - Initial text content for the editor area.
-   *                         (default: `''`)
+   *                         (default: `""`)
    */
   activateEditor(name: string, options?: TextEditor.Options, initialContent?: string): void;
 

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

@@ -120,7 +120,7 @@ declare global {
       /**
        * @defaultValue {@link ENTITY_PERMISSIONS.LIMITED}
        */
-      viewPermission: foundry.CONST.EntityPermission;
+      viewPermission: foundry.CONST.DOCUMENT_PERMISSION_LEVELS;
     }
   }
 }

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

@@ -67,7 +67,7 @@ declare global {
       isActorEffect: boolean;
       isItemEffect: boolean;
       submitText: string;
-      modes: Record<foundry.CONST.ActiveEffectMode, string>;
+      modes: Record<foundry.CONST.ACTIVE_EFFECT_MODES, string>;
     }
 
     type Options = DocumentSheet.Options;

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

@@ -194,7 +194,7 @@ declare global {
 
       interface Folder {
         type: 'Folder';
-        documentName: foundry.CONST.FolderEntityTypes;
+        documentName: foundry.CONST.FOLDER_DOCUMENT_TYPES;
         id: string;
       }
     }

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

@@ -0,0 +1,104 @@
+import type { ConfiguredDocumentClassForName } from '../../../../../types/helperTypes';
+import type { AmbientLightDataConstructorData } from '../../../../common/data/data.mjs/ambientLightData';
+import type { AnimationDataConstructorData } from '../../../../common/data/data.mjs/animationData';
+import type { DarknessActivationConstructorData } from '../../../../common/data/data.mjs/darknessActivation.js';
+import type { LightDataConstructorData } from '../../../../common/data/data.mjs/lightData.js';
+
+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 AmbientLightConfig<
+    Options extends DocumentSheet.Options = DocumentSheet.Options,
+    Data extends object = AmbientLightConfig.Data<Options>
+  > extends DocumentSheet<Options, Data, InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>> {
+    /**
+     * @override
+     * @defaultValue
+     * ```typescript
+     * foundry.utils.mergeObject(super.defaultOptions, {
+     *   id: "ambient-light-config",
+     *   classes: ["sheet", "ambient-light-config"],
+     *   title: "LIGHT.ConfigTitle",
+     *   template: "templates/scene/ambient-light-config.html",
+     *   width: 480,
+     *   height: "auto",
+     *   tabs: [{navSelector: ".tabs", contentSelector: "form", initial: "basic"}]
+     * });
+     * ```
+     */
+    static get defaultOptions(): DocumentSheet.Options;
+
+    /**
+     * @param options - (unused)
+     * @override
+     */
+    getData(options?: Partial<Options>): Data | Promise<Data>;
+
+    /** @override */
+    close(options?: Application.CloseOptions): Promise<void>;
+
+    /** @override */
+    activateListeners(html: JQuery): 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 _onResetForm(event: PointerEvent): void;
+
+    /** @override */
+    protected _onChangeTab(event: MouseEvent | null, tabs: Tabs, active: string): void;
+
+    /**
+     * @param event - (unused)
+     * @override
+     */
+    protected _updateObject(
+      event: Event,
+      formData: AmbientLightConfig.FormData
+    ): Promise<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>> | undefined>;
+
+    /**
+     * Refresh the display of the AmbientLight object
+     * @internal
+     */
+    protected _refresh(): void;
+  }
+
+  namespace AmbientLightConfig {
+    interface Data<Options extends DocumentSheet.Options>
+      extends DocumentSheet.Data<InstanceType<ConfiguredDocumentClassForName<'AmbientLight'>>, Options> {
+      isAdvanced: boolean;
+      colorationTechniques: unknown; // FIXME: typeof AdaptiveLightingShader.COLORATION_TECHNIQUES
+      lightAnimations: Record<string, string> & {
+        '': 'None';
+      };
+      submitText: string;
+    }
+
+    interface FormData extends Pick<AmbientLightDataConstructorData, 'x' | 'y' | 'rotation' | 'walls' | 'vision'> {
+      'config.dim': LightDataConstructorData['dim'];
+      'config.bright': LightDataConstructorData['bright'];
+      'config.angle': LightDataConstructorData['angle'];
+      'config.color': LightDataConstructorData['color'];
+      'config.alpha': LightDataConstructorData['alpha'];
+      'config.darkness.min': DarknessActivationConstructorData['min'];
+      'config.darkness.max': DarknessActivationConstructorData['max'];
+      'config.animation.type': AnimationDataConstructorData['type'];
+      'config.animation.speed': AnimationDataConstructorData['speed'];
+      'config.animation.reverse': AnimationDataConstructorData['reverse'];
+      'config.animation.intensity': AnimationDataConstructorData['intensity'];
+      'config.coloration': LightDataConstructorData['coloration'];
+      'config.luminosity': LightDataConstructorData['luminosity'];
+      'config.gradual': LightDataConstructorData['gradual'];
+      'config.saturation': LightDataConstructorData['saturation'];
+      'config.contrast': LightDataConstructorData['contrast'];
+      'config.shadows': LightDataConstructorData['shadows'];
+    }
+  }
+}

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

@@ -49,7 +49,7 @@ declare global {
       submitText: string;
     }
 
-    type FormData = Pick<foundry.data.AmbientSoundData, 'easing' | 'path' | 'type' | 'volume'> &
+    type FormData = Pick<foundry.data.AmbientSoundData, 'easing' | 'path' | 'volume'> &
       Pick<AmbientSoundDataConstructorData, 'radius' | 'x' | 'y'>;
 
     type Options = DocumentSheet.Options;

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

@@ -64,7 +64,7 @@ declare global {
       name: string;
       parent: string;
       sorting: SortingModes;
-      type: foundry.CONST.FolderEntityTypes;
+      type: foundry.CONST.FOLDER_DOCUMENT_TYPES;
     }
   }
 }

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

@@ -1,5 +1,6 @@
 import './activeEffectConfig';
 import './actorSheet';
+import './ambientLightConfig';
 import './ambientSoundConfig';
 import './combatantConfig';
 import './folderConfig';