@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/foundry/client/pixi/layers/placeables/notes.d.mts

@@ -0,0 +1,99 @@
+export {};
+
+declare global {
+  /**
+   * The Notes Layer which contains Note canvas objects
+   */
+  class NotesLayer extends PlaceablesLayer<"Note"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["notes"];
+
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "notes",
+     *  canDragCreate: false,
+     *  sortActiveTop: true, // TODO this needs to be removed
+     *  zIndex: 200
+     * })
+     * ```
+     * @remarks The TODO is foundry internal
+     */
+    static override get layerOptions(): NotesLayer.LayerOptions;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: NotesLayer.LayerOptions;
+
+    static override documentName: "Note";
+
+    /**
+     * The named core setting which tracks the toggled visibility state of map notes
+     */
+    static TOGGLE_SETTING: "notesDisplayToggle";
+
+    override get hookName(): string;
+
+    override _deactivate(): void;
+
+    /**
+     * Register game settings used by the NotesLayer
+     */
+    static registerSettings(): void;
+
+    /**
+     * Visually indicate in the Scene Controls that there are visible map notes present in the Scene.
+     */
+    hintMapNotes(): void;
+
+    /**
+     * Pan to a given note on the layer.
+     * @param note    - The note to pan to.
+     * @param options - Options which modify the pan operation.
+     * @returns A Promise which resolves once the pan animation has concluded.
+     */
+    panToNote(
+      note: Note,
+      options?: {
+        /**
+         * The resulting zoom level.
+         * @defaultValue `1.5`
+         */
+        scale: number;
+
+        /**
+         * The speed of the pan animation in milliseconds.
+         * @defaultValue `250`
+         */
+        duration: number;
+      },
+    ): Promise<void>;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle JournalEntry document drop data
+     */
+    protected _onDropData(event: DragEvent, data: NotesLayer.DropData): Promise<false | void>;
+  }
+
+  namespace NotesLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Note"> {
+      name: "notes";
+      canDragCreate: false;
+      sortActiveTop: true;
+      zIndex: 60;
+    }
+
+    interface DropData<DocType extends "JournalEntry" | "JournalEntryPage" = "JournalEntry" | "JournalEntryPage">
+      extends Canvas.DropPosition {
+      type: DocType;
+      uuid: string;
+      anchor: DocType extends "JournalEntryPage" ? { name: string } : undefined;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/placeables/sounds.d.mts

@@ -0,0 +1,129 @@
+export {};
+
+declare global {
+  /**
+   * This Canvas Layer provides a container for AmbientSound objects.
+   */
+  class SoundsLayer extends PlaceablesLayer<"AmbientSound"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["sounds"];
+
+    /**
+     * Track whether to actively preview ambient sounds with mouse cursor movements
+     * @defaultValue `false`
+     */
+    livePreview: boolean;
+
+    /**
+     * A mapping of ambient audio sources which are active within the rendered Scene
+     * @defaultValue `new foundry.utils.Collection()`
+     */
+    sources: foundry.utils.Collection<foundry.canvas.sources.PointSoundSource>;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: SoundsLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "sounds",
+     *  zIndex: 300
+     * })
+     * ```
+     * */
+
+    static override get layerOptions(): SoundsLayer.LayerOptions;
+
+    static override documentName: "AmbientSound";
+
+    override get hookName(): string;
+
+    override _activate(): void;
+
+    override _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Initialize all AmbientSound sources which are present on this layer
+     */
+    initializeSources(): void;
+
+    /**
+     * Update all AmbientSound effects in the layer by toggling their playback status.
+     * Sync audio for the positions of tokens which are capable of hearing.
+     * @param options - Additional options forwarded to AmbientSound synchronization
+     *                  (defaultValue: `{}`)
+     */
+    refresh(options?: { fade?: number }): number | void;
+
+    /**
+     * Preview ambient audio for a given mouse cursor position
+     * @param position - The cursor position to preview
+     */
+    previewSound(position: Point): void;
+
+    /**
+     * Terminate playback of all ambient audio sources
+     */
+    stopAll(): void;
+
+    /**
+     * Sync the playing state and volume of all AmbientSound objects based on the position of listener points
+     * @param listeners - Locations of listeners which have the capability to hear
+     * @param options   - Additional options forwarded to AmbientSound synchronization
+     *                    (defaultValue: `{}`)
+     */
+    protected _syncPositions(listeners: Point[], options?: { fade?: number }): void;
+
+    /**
+     * Define the easing function used to map radial distance to volume.
+     * Uses cosine easing which graduates from volume 1 at distance 0 to volume 0 at distance 1
+     * @returns The target volume level
+     */
+    protected _getEasingVolume(distance: number, radius: number): number;
+
+    /**
+     * Actions to take when the darkness level of the Scene is changed
+     * @param darkness - The new darkness level
+     * @param prior    - The prior darkness level
+     */
+    protected _onDarknessChange(darkness: number, prior: number): void;
+
+    /**
+     * Handle mouse cursor movements which may cause ambient audio previews to occur
+     * @param event - The initiating mouse move interaction event
+     */
+    protected _onMouseMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): ReturnType<AmbientSound["draw"]>;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<void>;
+
+    protected override _onDragLeftCancel(event: PointerEvent): void;
+
+    /**
+     * Handle PlaylistSound document drop data.
+     * @param event - The drag drop event
+     * @param data  - The dropped transfer data.
+     */
+    protected _onDropData(event: DragEvent, data: SoundsLayer.DropData): Promise<void>;
+  }
+
+  namespace SoundsLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"AmbientSound"> {
+      name: "sounds";
+      zIndex: 300;
+    }
+
+    interface DropData extends Canvas.DropPosition {
+      type: "PlaylistSound";
+      uuid: string;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/placeables/templates.d.mts

@@ -0,0 +1,60 @@
+export {};
+
+/**
+ * This Canvas Layer provides a container for MeasuredTemplate objects.
+ * @see {@link MeasuredTemplate}
+ */
+declare global {
+  class TemplateLayer extends PlaceablesLayer<"MeasuredTemplate"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["templates"];
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: TemplateLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```
+     * mergeObject(super.layerOptions, {
+     *   name: "templates",
+     *   canDragCreate: true,
+     *   rotatableObjects: true,
+     *   sortActiveTop: true,
+     *   zIndex: 50
+     * })
+     * ```
+     */
+    static override get layerOptions(): TemplateLayer.LayerOptions;
+
+    static override documentName: "MeasuredTemplate";
+
+    override get hookName(): string;
+
+    override _deactivate(): void;
+
+    /**
+     * Register game settings used by the TemplatesLayer
+     */
+    static registerSettings(): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): Promise<MeasuredTemplate>;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onMouseWheel(event: WheelEvent): void | ReturnType<MeasuredTemplate["rotate"]>;
+  }
+
+  namespace TemplateLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"MeasuredTemplate"> {
+      name: "templates";
+      canDragCreate: true;
+      rotatableObjects: true;
+      sortActiveTop: true;
+      zIndex: 50;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/placeables/tiles.d.mts

@@ -0,0 +1,114 @@
+import type { DropData } from "../../../data/abstract/client-document.d.mts";
+
+declare global {
+  /**
+   * A PlaceablesLayer designed for rendering the visual Scene for a specific vertical cross-section.
+   */
+  class TilesLayer extends PlaceablesLayer<"Tile"> {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["tiles"];
+
+    static override documentName: "Tile";
+
+    override options: TilesLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *    name: "tiles",
+     *    zIndex: 0,
+     *    controllableObjects: true,
+     *    rotatableObjects: true,
+     *    elevationSorting: true
+     * })
+     * ```
+     */
+    static override get layerOptions(): TilesLayer.LayerOptions;
+
+    override get hookName(): string;
+
+    override get hud(): TileHUD;
+
+    /**
+     * An array of Tile objects which are rendered within the objects container
+     */
+    get tiles(): Tile[];
+
+    /**
+     * Get an array of overhead Tile objects which are roofs
+     */
+    get roofs(): Tile[];
+
+    /**
+     * Determine whether to display roofs
+     */
+    get displayRoofs(): boolean;
+
+    /**
+     * A convenience reference to the tile occlusion mask on the primary canvas group.
+     */
+    get depthMask(): CachedContainer;
+
+    override controllableObjects(): Generator<Tile>;
+
+    override _activate(): void;
+
+    override _deactivate(): void;
+
+    /**
+     * Activate a sublayer of the tiles layer, which controls interactivity of placeables and release controlled objects.
+     * @param foreground - Which sublayer need to be activated? Foreground or background?
+     *                     (default: `false`)
+     */
+    protected _activateSubLayer(foreground?: boolean): void;
+
+    _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    protected _onDragLeftStart(event: PIXI.FederatedEvent): Promise<unknown>;
+
+    protected _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<void>;
+
+    protected _onDragLeftCancel(event: PointerEvent): void;
+
+    /**
+     * Handle drop events for Tile data on the Tiles Layer
+     * @param event - The concluding drag event
+     * @param data  - The extracted Tile data
+     */
+    protected _onDropData(event: DragEvent, data: DropData.Any): Promise<void>;
+
+    /**
+     * Prepare the data object when a new Tile is dropped onto the canvas
+     * @param event - The concluding drag event
+     * @param data  - The extracted Tile data
+     * @returns The prepared data to create
+     */
+    _getDropData(event: DragEvent, data: TilesLayer.DropData): Promise<DropData.Any>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "TilesLayer#textureDataMap has moved to TextureLoader.textureBufferDataMap"
+     */
+    get textureDataMap(): (typeof TextureLoader)["textureBufferDataMap"];
+  }
+
+  namespace TilesLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Tile"> {
+      name: "tiles";
+      zIndex: 0;
+      controllableObjects: true;
+      rotatableObjects: true;
+      elevationSorting: true;
+    }
+
+    interface DropData extends Canvas.DropPosition {
+      type: "Tile";
+      uuid: string;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/placeables/tokens.d.mts

@@ -0,0 +1,180 @@
+export {};
+
+declare global {
+  /**
+   * The Tokens Container
+   */
+  class TokenLayer extends PlaceablesLayer<"Token"> {
+    /**
+     * The current index position in the tab cycle
+     * @defaultValue `null`
+     */
+    protected _tabIndex: number | null;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["tokens"];
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: TokenLayer.LayerOptions;
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "tokens",
+     *  canDragCreate: false,
+     *  controllableObjects: true,
+     *  rotatableObjects: true,
+     *  elevationSorting: true,
+     *  zIndex: 100
+     * })
+     * ```
+     */
+    static override get layerOptions(): TokenLayer.LayerOptions;
+
+    static override documentName: "Token";
+
+    override get hookName(): string;
+
+    override get gridPrecision(): 1;
+
+    /**
+     * Token objects on this layer utilize the TokenHUD
+     */
+    get hud(): TokenHUD;
+
+    /**
+     * An Array of tokens which belong to actors which are owned
+     */
+    get ownedTokens(): ReturnType<this["placeables"]["filter"]>;
+
+    override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    override _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    override _activate(): void;
+
+    override _deactivate(): void;
+
+    /**
+     * Target all Token instances which fall within a coordinate rectangle.
+     * @param rectangle - The selection rectangle.
+     * @param options   - Additional options to configure targeting behaviour.
+     * @returns The number of Token instances which were targeted.
+     */
+    targetObjects(
+      rectangle: {
+        /** The top-left x-coordinate of the selection rectangle */
+        x: number;
+
+        /** The top-left y-coordinate of the selection rectangle */
+        y: number;
+
+        /** The width of the selection rectangle */
+        width: number;
+
+        /** The height of the selection rectangle */
+        height: number;
+      },
+      options?: {
+        /**
+         * Whether or not to release other targeted tokens
+         * @defaultValue `true`
+         */
+        releaseOthers?: boolean;
+      },
+    ): number;
+
+    /**
+     * Cycle the controlled token by rotating through the list of Owned Tokens that are available within the Scene
+     * Tokens are currently sorted in order of their TokenID
+     *
+     * @param forwards - Which direction to cycle. A truthy value cycles forward, while a false value cycles backwards.
+     * @param reset    - Restart the cycle order back at the beginning?
+     * @returns The Token object which was cycled to, or null
+     */
+    cycleTokens(forwards: boolean, reset: boolean): ConfiguredTokenDocument | null;
+
+    /**
+     * Add or remove the set of currently controlled Tokens from the active combat encounter
+     * @param  state  - The desired combat state which determines if each Token is added (true) or removed (false)
+     *                  (default: `true`)
+     * @param  combat - A Combat encounter from which to add or remove the Token
+     *                  (default: `null`)
+     * @returns The Combatants added or removed
+     */
+    toggleCombat(
+      state?: boolean,
+      combat?: Combat.ConfiguredInstance | null,
+      {
+        token,
+      }?: {
+        /**
+         * A specific Token which is the origin of the group toggle request
+         * @defaultValue `null`
+         */
+        token?: ConfiguredTokenDocument | null;
+      },
+    ): Promise<Combatant.ConfiguredInstance[]>;
+
+    /**
+     * Get the tab cycle order for tokens by sorting observable tokens based on their distance from top-left.
+     */
+    protected _getCycleOrder(): ConfiguredTokenDocument[];
+
+    /**
+     * Immediately conclude the animation of any/all tokens
+     */
+    concludeAnimation(): void;
+
+    /**
+     * Animate targeting arrows on targeted tokens.
+     */
+    protected _animateTargets(): void;
+
+    /**
+     * Provide an array of Tokens which are eligible subjects for overhead tile occlusion.
+     * By default, only tokens which are currently controlled or owned by a player are included as subjects.
+     */
+    _getOccludableTokens(): Token[];
+
+    override storeHistory(type: PlaceablesLayer.HistoryEventType, data: ConfiguredTokenDocument["_source"]): void;
+
+    /**
+     * Handle dropping of Actor data onto the Scene canvas
+     */
+    protected _onDropActorData(
+      event: DragEvent,
+      data: TokenLayer.DropData,
+    ): Promise<void | false | ConfiguredTokenDocument>;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Reset canvas and tokens mouse manager.
+     */
+    onClickTokenTools(): void;
+  }
+
+  namespace TokenLayer {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Token"> {
+      name: "tokens";
+      canDragCreate: false;
+      controllableObjects: true;
+      rotatableObjects: true;
+      elevationSorting: true;
+      zIndex: 100;
+    }
+
+    interface DropData extends Canvas.DropPosition {
+      type: "Actor";
+      uuid: string;
+    }
+  }
+}
+
+type ConfiguredTokenDocument = TokenDocument.ConfiguredInstance;