@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.0

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

@@ -0,0 +1,78 @@
+/**
+ * Support Info and Report
+ * @typeParam Options - the type of the options object
+ * @typeParam Data    - The data structure used to render the handlebars template.
+ */
+declare class SupportDetails<
+  Options extends ApplicationOptions = ApplicationOptions,
+  Data extends object = SupportDetails.Data
+> extends Application<Options> {
+  /**
+   * @override
+   * @defaultValue
+   * ```typescript
+   * const options = super.defaultOptions;
+   * options.title = "SUPPORT.Title";
+   * options.id = "support-details";
+   * options.template = "templates/sidebar/apps/support-details.html";
+   * options.width = 620;
+   * options.height = "auto";
+   * return options;
+   * ```
+   */
+  static get defaultOptions(): ApplicationOptions;
+
+  /**
+   * Returns the support report data
+   */
+  getData(options?: Partial<Options> | undefined): Data | Promise<Data>;
+
+  /**
+   * @override
+   * Binds the Support Report copy button
+   */
+  activateListeners(html: JQuery): void;
+
+  /**
+   * Collects a number of metrics that is useful for Support
+   */
+  static generateSupportReport(): SupportReportData;
+
+  /**
+   * Get a WebGL renderer information string
+   * @param gl - The rendering context
+   * @returns The unmasked renderer string
+   */
+  static getWebGLRendererInfo(gl: WebGLRenderingContext): string;
+}
+
+interface SupportReportData {
+  coreVersion: number;
+  systemVersion: string;
+  activeModuleCount: number;
+  os: string;
+  client: string;
+  gpu: string;
+  maxTextureSize: number | string;
+  sceneDimensions: string;
+  grid: number;
+  padding: number;
+  walls: number;
+  lights: number;
+  sounds: number;
+  tiles: number;
+  tokens: number;
+  actors: number;
+  items: number;
+  journals: number;
+  tables: number;
+  playlists: number;
+  packs: number;
+  messages: number;
+}
+
+declare namespace SupportDetails {
+  interface Data {
+    report: SupportReportData;
+  }
+}

package/src/foundry/foundry.js/clientDocuments/cards.d.ts

@@ -30,6 +30,11 @@ declare global {
      */
     get drawnCards(): InstanceType<ConfiguredDocumentClassForName<'Card'>>[];
 
+    /**
+     * Returns the localized Label for the type of Card Stack this is
+     */
+    get typeLabel(): string;
+
     /** @override */
     static createDocuments(
       data: Array<
@@ -182,6 +187,9 @@ declare global {
       userId: string
     ): void;
 
+    /** @override */
+    protected _preDelete(options: DocumentModificationOptions, user: foundry.documents.BaseUser): Promise<void>;
+
     // TODO: It's a bit weird that we have to do it in this generic way but otherwise there is an error overriding this. Investigate later.
     /** @override */
     static deleteDocuments<T extends DocumentConstructor>(

package/src/foundry/foundry.js/clientDocuments/chatMessage.d.ts

@@ -1,4 +1,4 @@
-import { ConfiguredDocumentClass } from '../../../types/helperTypes';
+import { ConfiguredDocumentClass, ConfiguredObjectClassForName, ToObjectFalseType } from '../../../types/helperTypes';
 import { DocumentModificationOptions } from '../../common/abstract/document.mjs';
 import type { ChatMessageDataConstructorData } from '../../common/data/data.mjs/chatMessageData';
 
@@ -13,17 +13,26 @@ declare global {
    * @param data - Initial data provided to construct the ChatMessage document
    */
   class ChatMessage extends ClientDocumentMixin(foundry.documents.BaseChatMessage) {
-    constructor(
-      data?: ConstructorParameters<ConstructorOf<foundry.documents.BaseChatMessage>>[0],
-      context?: ConstructorParameters<ConstructorOf<foundry.documents.BaseChatMessage>>[1]
-    );
-
     /**
-     * If the chat message contains a Roll instance, cache it here
+     * The cached Roll instance that this message contains, if any
      * @defaultValue `null`
+     * @internal
      */
     protected _roll: Roll | null;
 
+    /**
+     * Is the display of the roll in this message collapsed (false) or expanded (true)
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _rollExpanded: boolean;
+
+    /**
+     * Is this ChatMessage currently displayed in the sidebar ChatLog?
+     * @defaultValue `false`
+     */
+    logged: boolean;
+
     /**
      * Return the recommended String alias for this message.
      * The alias could be a Token name in the case of in-character messages or dice rolls.
@@ -61,7 +70,7 @@ declare global {
     /**
      * The User who created the chat message.
      */
-    get user(): User | undefined;
+    get user(): InstanceType<ConfiguredDocumentClass<typeof User>> | undefined;
 
     /** @override */
     prepareData(): void;
@@ -87,44 +96,32 @@ declare global {
      * Attempt to determine who is the speaking character (and token) for a certain Chat Message
      * First assume that the currently controlled Token is the speaker
      *
-     * @param scene - The Scene in which the speaker resides
-     * @param actor - The Actor whom is speaking
-     * @param token - The Token whom is speaking
-     * @param alias - The name of the speaker to display
+     * @param options - (default: `{}`)
      *
      * @returns The identified speaker data
      */
-    static getSpeaker({
-      scene,
-      actor,
-      token,
-      alias
-    }?: {
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
-      actor?: InstanceType<ConfiguredDocumentClass<typeof Actor>> | undefined;
-      token?: InstanceType<ConfiguredDocumentClass<typeof TokenDocument>> | undefined;
-      alias?: string | undefined;
-    }): foundry.data.ChatMessageData['speaker']['_source'];
+    static getSpeaker(
+      options?: ChatMessage.GetSpeakerOptions | undefined
+    ): foundry.data.ChatMessageData['speaker']['_source'];
 
     /**
      * A helper to prepare the speaker object based on a target TokenDocument
      *
-     * @param token - The TokenDocument of the speaker
-     * @param alias - The name of the speaker to display
      * @returns The identified speaker data
      */
     protected static _getSpeakerFromToken({
       token,
       alias
     }: {
-      token: InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseToken>>;
-      alias: string;
+      /** The TokenDocument of the speaker */
+      token: InstanceType<ConfiguredDocumentClass<typeof TokenDocument>>;
+
+      /** The name of the speaker to display */
+      alias?: string | undefined;
     }): foundry.data.ChatMessageData['speaker']['_source'];
     /**
      * A helper to prepare the speaker object based on a target TokenDocument
      *
-     * @param token - The TokenDocument of the speaker
-     * @param alias - The name of the speaker to display
      * @returns The identified speaker data
      * @deprecated Passing a Token is deprecated, a TokenDocument should be passed instead
      */
@@ -132,16 +129,16 @@ declare global {
       token,
       alias
     }: {
-      token: InstanceType<CONFIG['Token']['objectClass']>;
-      alias: string;
+      /** The TokenDocument of the speaker */
+      token: InstanceType<ConfiguredObjectClassForName<'Token'>>;
+
+      /** The name of the speaker to display */
+      alias?: string | undefined;
     }): foundry.data.ChatMessageData['speaker']['_source'];
 
     /**
      * A helper to prepare the speaker object based on a target Actor
      *
-     * @param scene - The Scene is which the speaker resides
-     * @param actor - The Actor that is speaking
-     * @param alias - The name of the speaker to display
      * @returns The identified speaker data
      */
     protected static _getSpeakerFromActor({
@@ -149,17 +146,19 @@ declare global {
       actor,
       alias
     }: {
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>>;
+      /** The Scene is which the speaker resides */
+      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
+
+      /** The Actor that is speaking */
       actor: InstanceType<ConfiguredDocumentClass<typeof Actor>>;
-      alias?: string;
+
+      /** The name of the speaker to display */
+      alias?: string | undefined;
     }): foundry.data.ChatMessageData['speaker']['_source'];
 
     /**
      * A helper to prepare the speaker object based on a target User
      *
-     * @param scene - The Scene in which the speaker resides
-     * @param user  - The User who is speaking
-     * @param alias - The name of the speaker to display
      * @returns The identified speaker data
      */
     protected static _getSpeakerFromUser({
@@ -167,21 +166,28 @@ declare global {
       user,
       alias
     }: {
-      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>>;
+      /** The Scene in which the speaker resides */
+      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
+
+      /** The User who is speaking */
       user: InstanceType<ConfiguredDocumentClass<typeof User>>;
-      alias?: string;
+
+      /** The name of the speaker to display */
+      alias?: string | undefined;
     }): foundry.data.ChatMessageData['speaker']['_source'];
 
     /**
      * Obtain an Actor instance which represents the speaker of this message (if any)
      * @param speaker - The speaker data object
      */
-    static getSpeakerActor(speaker: foundry.data.ChatMessageData['speaker']['_source']): Actor | null;
+    static getSpeakerActor(
+      speaker: foundry.data.ChatMessageData['speaker']['_source']
+    ): InstanceType<ConfiguredDocumentClass<typeof Actor>> | null;
 
     /**
      * Obtain a data object used to evaluate any dice rolls associated with this particular chat message
      */
-    getRollData(): InstanceType<ConfiguredDocumentClass<typeof Actor>>['getRollData'] | {};
+    getRollData(): object;
 
     /**
      * Given a string whisper target, return an Array of the user IDs which should be targeted for the whisper
@@ -196,35 +202,67 @@ declare global {
      */
     getHTML(): Promise<JQuery>;
 
+    /**
+     * Render the inner HTML content for ROLL type messages.
+     * @param messageData - The chat message data used to render the message HTML
+     * @internal
+     */
+    protected _renderRollContent(messageData: ChatMessage.MessageData): Promise<void>;
+
     /** @override */
-    _preCreate(
+    protected _preCreate(
       data: ChatMessageDataConstructorData,
       options: DocumentModificationOptions,
       user: foundry.documents.BaseUser
     ): Promise<void>;
 
     /** @override */
-    _onCreate(
+    protected _onCreate(
       data: foundry.data.ChatMessageData['_source'],
       options: DocumentModificationOptions,
       userId: string
     ): void;
 
     /** @override */
-    _onUpdate(
+    protected _onUpdate(
       data: DeepPartial<foundry.data.ChatMessageData['_source']>,
       options: DocumentModificationOptions,
       userId: string
     ): void;
 
     /** @override */
-    _onDelete(options: DocumentModificationOptions, userId: string): void;
+    protected _onDelete(options: DocumentModificationOptions, userId: string): void;
 
     /**
      * Export the content of the chat message into a standardized log format
      */
     export(): string;
   }
-}
 
-export {};
+  namespace ChatMessage {
+    interface GetSpeakerOptions {
+      /** The Scene in which the speaker resides */
+      scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>> | undefined;
+
+      /** The Actor whom is speaking */
+      actor?: InstanceType<ConfiguredDocumentClass<typeof Actor>> | undefined;
+
+      /** The Token whom is speaking */
+      token?: InstanceType<ConfiguredDocumentClass<typeof TokenDocument>> | undefined;
+
+      /** The name of the speaker to display */
+      alias?: string | undefined;
+    }
+
+    interface MessageData {
+      message: ToObjectFalseType<ChatMessage>;
+      user: StoredDocument<InstanceType<ConfiguredDocumentClass<typeof User>>>;
+      author: InstanceType<ConfiguredDocumentClass<typeof User>> | undefined;
+      alias: string;
+      cssClass: string;
+      isWhisper: boolean;
+      canDelete: boolean;
+      whisperTo: string;
+    }
+  }
+}

package/src/foundry/foundry.js/clientDocuments/folder.d.ts

@@ -60,11 +60,7 @@ declare global {
      *                  (default: `{}`)
      * @returns A Promise which resolves to the created Folder, or null if the dialog was closed.
      *
-     * @remarks
-     * For weird reasons, we need to make this generic.
-     *
-     * The type of `context` is actually `{options?: DocumentSheetOptions} | undefined` but that's incompatible with the
-     * base implementation. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6863.
+     * @remarks For weird reasons, we need to make this generic.
      */
     static createDialog<T extends DocumentConstructor>(
       this: T,
@@ -74,7 +70,7 @@ declare global {
             | (ConstructorDataType<InstanceType<T>['data']> & Record<string, unknown>)
           >
         | undefined,
-      context?: any
+      context?: Partial<Omit<FolderConfig.Options, 'resolve'>>
     ): Promise<InstanceType<ConfiguredDocumentClass<T>> | null | undefined>;
 
     /**

package/src/foundry/foundry.js/clientDocuments/playlistSound.d.ts

@@ -70,6 +70,12 @@ declare global {
      */
     sync(): void | Promise<void> | Promise<Sound>;
 
+    override _onCreate(
+      data: foundry.data.PlaylistSoundData['_source'],
+      options: DocumentModificationOptions,
+      userId: string
+    ): void;
+
     /** @override */
     protected _onUpdate(
       changed: DeepPartial<foundry.data.PlaylistSoundData['_source']>,

package/src/foundry/foundry.js/collections/documentCollections/worldCollection.d.ts

@@ -115,7 +115,7 @@ declare global {
      * Actors.registerSheet("dnd5e", ActorSheet5eCharacter, { types: ["character], makeDefault: true });
      * ```
      */
-    static registerSheet(...args: DropFirst<Parameters<typeof EntitySheetConfig.registerSheet>>): void;
+    static registerSheet(...args: DropFirst<Parameters<typeof DocumentSheetConfig.registerSheet>>): void;
 
     /**
      * Unregister a Document sheet class, removing it from the list of available sheet Applications to use.
@@ -125,7 +125,7 @@ declare global {
      * @example <caption>Deregister the default ActorSheet subclass to replace it with others.</caption>
      * Actors.unregisterSheet("core", ActorSheet);
      */
-    static unregisterSheet(...args: DropFirst<Parameters<typeof EntitySheetConfig.unregisterSheet>>): void;
+    static unregisterSheet(...args: DropFirst<Parameters<typeof DocumentSheetConfig.unregisterSheet>>): void;
 
     /**
      * Return an array of currently registered sheet classes for this Document type.

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

@@ -1238,7 +1238,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof AmbientLight>;
 
       /** @defaultValue `AmbientLightDocument` */
-      layerClass: ConstructorOf<LightingLayer>;
+      layerClass: typeof LightingLayer;
     };
 
     /**
@@ -1252,7 +1252,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof AmbientSound>;
 
       /** @defaultValue `SoundsLayer` */
-      layerClass: ConstructorOf<SoundsLayer>;
+      layerClass: typeof SoundsLayer;
     };
 
     /**
@@ -1274,7 +1274,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof Drawing>;
 
       /** @defaultValue `DrawingsLayer` */
-      layerClass: ConstructorOf<DrawingsLayer>;
+      layerClass: typeof DrawingsLayer;
     };
 
     /**
@@ -1310,7 +1310,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof MeasuredTemplate>;
 
       /** @defaultValue `TemplateLayer` */
-      layerClass: ConstructorOf<TemplateLayer>;
+      layerClass: typeof TemplateLayer;
     };
 
     /**
@@ -1324,7 +1324,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof Note>;
 
       /** @defaultValue `NotesLayer` */
-      layerClass: ConstructorOf<NotesLayer>;
+      layerClass: typeof NotesLayer;
     };
 
     /**
@@ -1338,7 +1338,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof Tile>;
 
       /** @defaultValue `BackgroundLayer` */
-      layerClass: ConstructorOf<BackgroundLayer>;
+      layerClass: typeof BackgroundLayer;
     };
 
     /**
@@ -1352,7 +1352,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof Token>;
 
       /** @defaultValue `TokenLayer` */
-      layerClass: ConstructorOf<TokenLayer>;
+      layerClass: typeof TokenLayer;
 
       /** @defaultValue `TokenConfig` */
       prototypeSheetClass: ConstructorOf<TokenConfig>;
@@ -1369,7 +1369,7 @@ declare global {
       objectClass: ConfiguredObjectClassOrDefault<typeof Wall>;
 
       /** @defaultValue `WallsLayer` */
-      layerClass: ConstructorOf<WallsLayer>;
+      layerClass: typeof WallsLayer;
     };
 
     /**
@@ -1491,43 +1491,43 @@ declare global {
 
       interface Layers {
         /** @defaultValue `{ layerClass: BackgroundLayer, group: "primary" }` */
-        background: LayerDefinition<ConstructorOf<BackgroundLayer>>;
+        background: LayerDefinition<typeof BackgroundLayer>;
 
         /** @defaultValue `{ layerClass: DrawingsLayer, group: "primary" }` */
-        drawings: LayerDefinition<ConstructorOf<DrawingsLayer>>;
+        drawings: LayerDefinition<typeof DrawingsLayer>;
 
         /** @defaultValue `{ layerClass: GridLayer, group: "primary" }` */
-        grid: LayerDefinition<ConstructorOf<GridLayer>>;
+        grid: LayerDefinition<typeof GridLayer>;
 
         /** @defaultValue `{ layerClass: TemplateLayer, group: "primary" }` */
-        templates: LayerDefinition<ConstructorOf<TemplateLayer>>;
+        templates: LayerDefinition<typeof TemplateLayer>;
 
         /** @defaultValue `{ layerClass: TokenLayer, group: "primary" }` */
-        tokens: LayerDefinition<ConstructorOf<TokenLayer>>;
+        tokens: LayerDefinition<typeof TokenLayer>;
 
         /** @defaultValue `{ layerClass: ForegroundLayer, group: "primary" }` */
-        foreground: LayerDefinition<ConstructorOf<ForegroundLayer>>;
+        foreground: LayerDefinition<typeof ForegroundLayer>;
 
         /** @defaultValue `{ layerClass: WallsLayer, group: "effects" }` */
-        walls: LayerDefinition<ConstructorOf<WallsLayer>>;
+        walls: LayerDefinition<typeof WallsLayer>;
 
         /** @defaultValue `{ layerClass: LightingLayer, group: "effects" }` */
-        lighting: LayerDefinition<ConstructorOf<LightingLayer>>;
+        lighting: LayerDefinition<typeof LightingLayer>;
 
         /** @defaultValue `{ layerClass: WeatherLayer, group: "effects" }` */
-        weather: LayerDefinition<ConstructorOf<WeatherLayer>>;
+        weather: LayerDefinition<typeof WeatherLayer>;
 
         /** @defaultValue `{ layerClass: SightLayer, group: "effects" }` */
-        sight: LayerDefinition<ConstructorOf<SightLayer>>;
+        sight: LayerDefinition<typeof SightLayer>;
 
         /** @defaultValue `{ layerClass: SoundsLayer, group: "interface" }` */
-        sounds: LayerDefinition<ConstructorOf<SoundsLayer>>;
+        sounds: LayerDefinition<typeof SoundsLayer>;
 
         /** @defaultValue `{ layerClass: NotesLayer, group: "interface" }` */
-        notes: LayerDefinition<ConstructorOf<NotesLayer>>;
+        notes: LayerDefinition<typeof NotesLayer>;
 
         /** @defaultValue `{ layerClass: ControlsLayer, group: "interface" }` */
-        controls: LayerDefinition<ConstructorOf<ControlsLayer>>;
+        controls: LayerDefinition<typeof ControlsLayer>;
 
         [key: string]: LayerDefinition;
       }

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

@@ -14,7 +14,7 @@ declare class ContextMenu {
   constructor(
     element: JQuery,
     selector: string | null | undefined,
-    menuItems: ContextMenu.Item[],
+    menuItems: ContextMenuEntry[],
     { eventName }?: { eventName?: string }
   );
 
@@ -37,7 +37,7 @@ declare class ContextMenu {
   /**
    * The array of menu items being rendered
    */
-  menuItems: ContextMenu.Item[];
+  menuItems: ContextMenuEntry[];
 
   /**
    * Track which direction the menu is expanded in
@@ -50,18 +50,41 @@ declare class ContextMenu {
    */
   get menu(): JQuery;
 
+  /**
+   * Create a ContextMenu for this Application and dispatch hooks.
+   * @param app       - The Application this ContextMenu belongs to.
+   * @param html      - The Application's rendered HTML.
+   * @param selector  - The target CSS selector which activates the menu.
+   * @param menuItems - The array of menu items being rendered.
+   * @param hookName  - The name of the hook to call.
+   *                    (default: `'EntryContext'`)
+   */
+  static create(
+    app: Application,
+    html: JQuery,
+    selector: string,
+    menuItems: ContextMenuEntry[],
+    hookName?: string
+  ): ContextMenu;
+
   /**
    * Attach a ContextMenu instance to an HTML selector
    */
   bind(): void;
 
   /**
-   * Animate closing the menu by sliding up and removing from the DOM
+   * Closes the menu and removes it from the DOM.
+   * @param options - Options to configure the closing behavior.
    */
-  close(): Promise<void>;
+  close(options?: ContextMenu.CloseOptions | undefined): Promise<void>;
+
+  /** @internal */
+  protected _close(): void;
 
+  /** @internal */
   protected _animateOpen(menu: JQuery): Promise<void>;
 
+  /** @internal */
   protected _animateClose(menu: JQuery): Promise<void>;
 
   /**
@@ -80,6 +103,16 @@ declare class ContextMenu {
   static eventListeners(): void;
 }
 
+declare namespace ContextMenu {
+  interface CloseOptions {
+    /**
+     * Animate the context menu closing.
+     * @defaultValue `true`
+     */
+    animate?: boolean;
+  }
+}
+
 interface ContextMenuEntry {
   /**
    * The context menu label. Can be localized.
@@ -101,27 +134,3 @@ interface ContextMenuEntry {
    */
   condition?: boolean | ((target: JQuery) => boolean);
 }
-
-declare namespace ContextMenu {
-  interface Item {
-    /**
-     * The displayed item name
-     */
-    name: string;
-
-    /**
-     * An icon glyph HTML string
-     */
-    icon: string;
-
-    /**
-     * A function which returns a Boolean for whether or not to display the item
-     */
-    condition?: boolean | ((target: JQuery) => boolean);
-
-    /**
-     * A callback function to trigger when the entry of the menu is clicked
-     */
-    callback: (target: JQuery) => void;
-  }
-}

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

@@ -587,8 +587,8 @@ declare global {
       activeUsers: string[];
       addresses: {
         local: string;
-        remote: string;
-        remoteIsAccessible: boolean;
+        remote?: string | undefined;
+        remoteIsAccessible: boolean | null;
       };
       coreUpdate: {
         channel: unknown | null;

package/src/foundry/foundry.js/pixi/containers/canvasLayer.d.ts

@@ -53,8 +53,9 @@ declare abstract class CanvasLayer<Options extends CanvasLayerOptions = CanvasLa
 
   /**
    * Deconstruct data used in the current layer in preparation to re-draw the canvas
+   * @remarks ControlsLayer returns void. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6939
    */
-  tearDown(): Promise<this>;
+  tearDown(): Promise<this | void>;
 
   /**
    * Activate the CanvasLayer, deactivating other layers and marking this layer's children as interactive.