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

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

@@ -4,9 +4,9 @@
  */
 declare class CameraPopoutAppWrapper {
   /**
-   * @param view- The CameraViews application that this popout belongs to
-   * @param userId- ID of the user this popout belongs to
-   * @param element- The div element of this specific popout window
+   * @param view    - The CameraViews application that this popout belongs to
+   * @param userId  - ID of the user this popout belongs to
+   * @param element - The div element of this specific popout window
    */
   constructor(view: CameraViews, userId: string, element: JQuery);
 
@@ -25,16 +25,21 @@ declare class CameraPopoutAppWrapper {
    */
   userId: string;
 
+  /** @defaultValue `true` */
+  popOut: boolean;
+
+  /** @defaultValue `{}` */
+  options: Record<string, unknown>;
+
   /**
    * Get the current position of this popout window
    */
   get position(): Application.Position;
 
-  /** @override */
-  setPosition({ left, top, width, height, scale }?: Partial<Application.Position>): void;
+  setPosition(options?: Partial<Application.Position>): (Application.Position & { height: number }) | void;
 
-  private _onResize(event: Event): void;
+  /** @internal */
+  protected _onResize(event: Event): void;
 
-  /** @override */
   bringToTop(): void;
 }

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

@@ -13,7 +13,7 @@ import { BaseScene } from '../common/documents.mjs';
  * @example <caption>Example Canvas commands</caption>
  * ```typescript
  * canvas.ready; // Is the canvas ready for use?
- * canvas.scene; // The currently viewed Scene entity.
+ * canvas.scene; // The currently viewed Scene document.
  * canvas.dimensions; // The dimensions of the current Scene.
  * canvas.draw(); // Completely re-draw the game canvas (this is usually unnecessary).
  * canvas.pan(x, y, zoom); // Pan the canvas to new coordinates and scale.
@@ -107,16 +107,44 @@ declare global {
      */
     blurFilters: PIXI.filters.BlurFilter[];
 
+    /**
+     * A reference to the MouseInteractionManager that is currently controlling pointer-based interaction, or null.
+     */
+    currentMouseManager: MouseInteractionManager<PIXI.Container> | null;
+
+    /**
+     * Record framerate performance data
+     */
+    fps: {
+      /** @defaultValue `[]` */
+      values: number[];
+
+      /** @defaultValue `0` */
+      last: number;
+
+      /** @defaultValue `0` */
+      average: number;
+
+      /** @defaultValue `0` */
+      render: number;
+
+      /** @defaultValue `document.getElementById("fps")` */
+      element: HTMLElement;
+
+      /** @defaultValue `undefined` */
+      fn: TickerCallback<void> | undefined;
+    };
+
     /**
      * The singleton interaction manager instance which handles mouse interaction on the Canvas.
      */
     mouseInteractionManager: MouseInteractionManager<PIXI.Container> | undefined;
 
     /**
-     * A reference to the MouseInteractionManager that is currently controlling pointer-based interaction, or null.
-     * @defaultValue `null`
+     * The renderer screen dimensions.
+     * @defaultValue `[0, 0]`
      */
-    currentMouseManager: MouseInteractionManager<PIXI.Container> | null;
+    screenDimensions: [x: number, y: number];
 
     /**
      * Initialize the Canvas by creating the HTML element and PIXI application.
@@ -125,39 +153,53 @@ declare global {
      */
     initialize(): void;
 
-    app: PIXI.Application | undefined;
+    app?: PIXI.Application;
+
+    stage?: PIXI.Container;
+
+    protected _dragDrop?: DragDrop;
+
+    outline?: PIXI.Graphics;
+
+    msk?: PIXI.Graphics;
+
+    readonly primary?: PrimaryCanvasGroup;
 
-    stage: PIXI.Container | undefined;
+    readonly effects?: EffectsCanvasGroup;
 
-    protected _dragDrop: DragDrop | undefined;
+    readonly interface?: InterfaceCanvasGroup;
 
-    background: BackgroundLayer | undefined;
+    readonly background?: BackgroundLayer;
 
-    drawings: DrawingsLayer | undefined;
+    readonly drawings?: DrawingsLayer;
 
-    grid: GridLayer | undefined;
+    readonly grid?: GridLayer;
 
-    walls: WallsLayer | undefined;
+    readonly walls?: WallsLayer;
 
-    templates: TemplateLayer | undefined;
+    readonly templates?: TemplateLayer;
 
-    notes: NotesLayer | undefined;
+    readonly notes?: NotesLayer;
 
-    tokens: TokenLayer | undefined;
+    readonly tokens?: TokenLayer;
 
-    foreground: ForegroundLayer | undefined;
+    readonly foreground?: ForegroundLayer;
 
-    sounds: SoundsLayer | undefined;
+    readonly sounds?: SoundsLayer;
 
-    lighting: LightingLayer | undefined;
+    readonly lighting?: LightingLayer;
 
-    sight: SightLayer | undefined;
+    readonly sight?: SightLayer;
 
-    effects: EffectsLayer | undefined;
+    readonly weather?: WeatherLayer;
 
-    controls: ControlsLayer | undefined;
+    readonly controls?: ControlsLayer;
 
-    msk: PIXI.Graphics | undefined;
+    /**
+     * Display warnings for known performance issues which may occur due to the user's hardware or browser configuration
+     * @internal
+     */
+    protected _displayPerformanceWarnings(): void;
 
     /**
      * The id of the currently displayed Scene.
@@ -180,10 +222,10 @@ declare global {
     get activeLayer(): CanvasLayer | null;
 
     /**
-     * Create the layers of the game Canvas.
-     * @param stage - The primary canvas stage
+     * Initialize the group containers of the game Canvas.
+     * @internal
      */
-    protected _createLayers(stage: PIXI.Container): void;
+    protected _createGroups(): void;
 
     /**
      * When re-drawing the canvas, first tear down or discontinue some existing processes
@@ -197,6 +239,15 @@ declare global {
      */
     draw(scene?: InstanceType<ConfiguredDocumentClass<typeof Scene>>): Promise<this>;
 
+    performance?: PerformanceSettings;
+
+    /**
+     * Get the value of a GL parameter
+     * @param parameter - The GL parameter to retrieve
+     * @returns The returned value type depends of the parameter to retrieve
+     */
+    getGLParameter(parameter: string): unknown;
+
     /**
      * Get the canvas active dimensions based on the size of the scene's map.
      * We expand the image size by a factor of 1.5 and round to the nearest 2x grid size.
@@ -206,6 +257,12 @@ declare global {
      */
     static getDimensions(data: Canvas.DimensionsData): Canvas.Dimensions;
 
+    /**
+     * Configure performance settings for hte canvas application based on the selected performance mode
+     * @internal
+     */
+    protected _configurePerformanceMode(): PerformanceSettings;
+
     /**
      * Once the canvas is drawn, initialize control, visibility, and audio states
      */
@@ -229,25 +286,6 @@ declare global {
      */
     protected _initializeTokenControl(): void;
 
-    /**
-     * Get a reference to the a specific CanvasLayer by it's name
-     * @param layerName - The name of the canvas layer to get
-     */
-    getLayer(layerName: 'BackgroundLayer'): BackgroundLayer | null;
-    getLayer(layerName: 'DrawingsLayer'): DrawingsLayer | null;
-    getLayer(layerName: 'GridLayer'): GridLayer | null;
-    getLayer(layerName: 'WallsLayer'): WallsLayer | null;
-    getLayer(layerName: 'TemplateLayer'): TemplateLayer | null;
-    getLayer(layerName: 'NotesLayer'): NotesLayer | null;
-    getLayer(layerName: 'TokenLayer'): TokenLayer | null;
-    getLayer(layerName: 'ForegroundLayer'): ForegroundLayer | null;
-    getLayer(layerName: 'SoundsLayer'): SoundsLayer | null;
-    getLayer(layerName: 'LightingLayer'): LightingLayer | null;
-    getLayer(layerName: 'SightLayer'): SightLayer | null;
-    getLayer(layerName: 'EffectsLayer'): EffectsLayer | null;
-    getLayer(layerName: 'ControlsLayer'): ControlsLayer | null;
-    getLayer(layerName: string): CanvasLayer | null;
-
     /**
      * Given an embedded object name, get the canvas layer for that object
      */
@@ -261,6 +299,22 @@ declare global {
      */
     activateLayer(layerName: LayerName): void;
 
+    /**
+     * Activate framerate tracking by adding an HTML element to the display and refreshing it every frame.
+     */
+    activateFPSMeter(): void;
+
+    /**
+     * Deactivate framerate tracking by canceling ticker updates and removing the HTML element.
+     */
+    deactivateFPSMeter(): void;
+
+    /**
+     * Measure average framerate per second over the past 30 frames
+     * @internal
+     */
+    protected _measureFPS(): void;
+
     /**
      * Pan the canvas to a certain \{x,y\} coordinate and a certain zoom level
      * @param options - (default: `{}`)
@@ -285,6 +339,11 @@ declare global {
      */
     recenter(coordinates?: PanView): ReturnType<this['animatePan']>;
 
+    /**
+     * Highlight objects on any layers which are visible
+     */
+    highlightObjects(active: boolean): void;
+
     /**
      * Get the constrained zoom scale parameter which is allowed by the maxZoom parameter
      * @param x     - The requested x-coordinate
@@ -305,6 +364,12 @@ declare global {
      */
     protected updateBlur(scale?: number): void;
 
+    /**
+     * Sets the background color.
+     * @param color - The color to set the canvas background to.
+     */
+    setBackgroundColor(color: string): void;
+
     /**
      * Attach event listeners to the game canvas to handle click and interaction events
      */
@@ -399,8 +464,9 @@ declare global {
 
     /**
      * Event handler for the drop portion of a drag-and-drop event.
+     * @internal
      */
-    protected _onDrop(event: DragEvent): unknown;
+    protected _onDrop(event: DragEvent): void;
 
     /**
      * Add a pending canvas operation that should fire once the socket handling workflow concludes.
@@ -419,9 +485,25 @@ declare global {
     triggerPendingOperations(): void;
 
     /**
-     * @deprecated since 0.8.2
-     */
-    initializeSources(): void;
+     * Get a reference to the a specific CanvasLayer by it's name
+     * @param layerName - The name of the canvas layer to get
+     *                    (unused)
+     * @deprecated since v9, will be deleted in v10
+     */
+    getLayer(layerName: any): {
+      BackgroundLayer: Canvas['background'];
+      DrawingsLayer: Canvas['drawings'];
+      GridLayer: Canvas['grid'];
+      TemplateLayer: Canvas['templates'];
+      TokenLayer: Canvas['tokens'];
+      WallsLayer: Canvas['walls'];
+      LightingLayer: Canvas['lighting'];
+      WeatherLayer: Canvas['weather'];
+      SightLayer: Canvas['sight'];
+      SoundsLayer: Canvas['sounds'];
+      NotesLayer: Canvas['notes'];
+      ControlsLayer: Canvas['controls'];
+    };
   }
 
   namespace Canvas {
@@ -454,6 +536,27 @@ declare global {
   }
 }
 
+type TickerCallback<T> = (this: T, dt: number) => any;
+
+interface PerformanceSettings {
+  mode: foundry.CONST.CANVAS_PERFORMANCE_MODES;
+  blur: {
+    enabled: boolean;
+    illumination: boolean;
+  };
+  mipmap: 'ON' | 'OFF';
+  msaa: boolean;
+  fps: number;
+  tokenAnimation: boolean;
+  lightAnimation: boolean;
+  textures: {
+    enabled: boolean;
+    maxSize: number;
+    p2Steps: number;
+    p2StepsMax: number;
+  };
+}
+
 interface PanView {
   /**
    * The x-coordinate of the pan destination

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

@@ -39,7 +39,7 @@ declare class CanvasAnimation {
    */
   static animateLinear(
     attributes: CanvasAnimation.Attribute[],
-    options?: Partial<LinearAnimationOptions>
+    options?: InexactPartial<LinearAnimationOptions>
   ): Promise<boolean>;
 
   /**

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

@@ -27,6 +27,13 @@ declare class CanvasDocumentMixin<T extends foundry.abstract.Document<any, any>>
    */
   protected _object: PlaceableObject | null; // TODO: Replace with InstanceType<ObjectClass<T>> | null once the circular reference problem has been solved
 
+  /**
+   * Has this object been deliberately destroyed as part of the deletion workflow?
+   * @internal
+   * @defaultValue `false`
+   */
+  protected _destroyed: boolean;
+
   /**
    * A lazily constructed PlaceableObject instance which can represent this Document on the game canvas.
    */

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

@@ -0,0 +1,210 @@
+import type { ConfiguredDocumentClassForName } from '../../types/helperTypes';
+import type { Request } from '../common/abstract/backend.mjs';
+import type Document from '../common/abstract/document.mjs';
+
+declare global {
+  /**
+   * The client-side database backend implementation which handles Document modification operations.
+   */
+  class ClientDatabaseBackend extends foundry.abstract.DatabaseBackend {
+    /**
+     * Activate the Socket event listeners used to receive responses from events which modify database documents
+     * @param socket - The active game socket
+     */
+    activateSocketListeners(socket: io.Socket): void;
+
+    /** @override */
+    protected _getDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * @override
+     * @remarks
+     * Get operations for embedded Documents are currently un-supported.
+     * The returned promise always rejects.
+     */
+    protected _getEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<never>;
+
+    /** @override */
+    protected _createDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _createEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-creation workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preCreateDocumentArray<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      {
+        data,
+        options,
+        pack,
+        parent,
+        user
+      }: Pick<Request, 'data' | 'pack' | 'parent' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were created
+     * @param response - The provided Socket response
+     * @returns An Array of created Document instances
+     */
+    protected _handleCreateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-creation workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform once every Document is created
+     * @internal
+     */
+    protected _postCreateDocumentCallbacks(
+      type: string,
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId, parent, pack }: Pick<Request, 'options' | 'parent' | 'pack'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    protected _updateDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _updateEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-update workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preUpdateDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        updates,
+        options,
+        user
+      }: Pick<Request, 'updates' | 'options'> & {
+        user: InstanceType<ConfiguredDocumentClassForName<'User'>>;
+      }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server when one or multiple documents were updated
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are updated in a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of updated Document instances
+     */
+    protected _handleUpdateEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-update workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is updated
+     * @internal
+     */
+    protected _postUpdateDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): () => void;
+
+    /** @override */
+    protected _deleteDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /** @override */
+    protected _deleteEmbeddedDocuments<T extends Document<any, any>>(
+      documentClass: ConstructorOf<T>,
+      parent: T extends Document<any, infer U> ? U : never,
+      request: Request,
+      user: InstanceType<ConfiguredDocumentClassForName<'User'>>
+    ): Promise<T[]>;
+
+    /**
+     * Perform a standardized pre-delete workflow for all Document types. For internal use only.
+     * @internal
+     */
+    protected _preDeleteDocumentArray<T extends Document<any, any>>(
+      collection: Collection<T>,
+      {
+        ids,
+        options,
+        user
+      }: Pick<Request, 'ids' | 'options'> & { user: InstanceType<ConfiguredDocumentClassForName<'User'>> }
+    ): Promise<T[]>;
+
+    /**
+     * Handle a SocketResponse from the server where Documents are deleted.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Handle a SocketResponse from the server when embedded Documents are deleted from a parent Document.
+     * @param response - The provided Socket response
+     * @returns An Array of deleted Document instances
+     */
+    protected _handleDeleteEmbeddedDocuments(response: SocketResponse): foundry.abstract.Document<any, any>[];
+
+    /**
+     * Perform a standardized post-deletion workflow for all Document types. For internal use only.
+     * @returns An array of callback operations to perform after every Document is deleted
+     * @internal
+     */
+    protected _postDeleteDocumentCallbacks(
+      collection: Collection<foundry.abstract.Document<any, any>>,
+      result: object[],
+      { options, userId }: Pick<Request, 'options'> & { userId?: string }
+    ): (() => void)[];
+
+    /** @override */
+    getFlagScopes(): string[];
+
+    /** @override */
+    getCompendiumScopes(): string[];
+  }
+}
+
+export {};