@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 12.331.5

package/src/foundry/client/pixi/layers/masks/vision.d.mts

@@ -1,4 +1,4 @@
-export {};
+import type { Identity } from "#utils";
 
 declare global {
   /**
@@ -15,16 +15,12 @@ declare global {
      * }
      * ```
      */
-    static override textureConfiguration: {
-      scaleMode: PIXI.SCALE_MODES;
-      format: PIXI.FORMATS;
-      multisample: PIXI.MSAA_QUALITY;
-    };
+    static override textureConfiguration: CachedContainer.TextureConfiguration;
 
     /**
      * @defaultValue `[0, 0, 0, 0]`
      */
-    override clearColor: [r: number, g: number, b: number, a: number];
+    override clearColor: Color.RGBAColorVector;
 
     /**
      * @defaultValue `false`
@@ -41,6 +37,9 @@ declare global {
      * The BlurFilter which applies to the vision mask texture.
      * This filter applies a NORMAL blend mode to the container.
      * @defaultValue `undefined`
+     * @remarks Only `undefined` prior to first draw
+     *
+     * Could be overridden if anything ever set `canvas.blurOptions.blurClass`, but nothing in core does
      */
     blurFilter: AlphaBlurFilter | undefined;
 
@@ -50,7 +49,7 @@ declare global {
      * Initialize the vision mask with the los and the fov graphics objects.
      * @param vision - The vision container to attach
      */
-    attachVision(vision: PIXI.Container): CanvasVisionMask.CanvasVisionContainer;
+    attachVision(vision: CanvasVisionMask.CanvasVisionContainer): CanvasVisionMask.CanvasVisionContainer;
 
     /**
      * Detach the vision mask from the cached container.
@@ -60,7 +59,7 @@ declare global {
 
     /**
      * @deprecated since v11, will be removed in v13
-     * @remarks `"CanvasVisionMask#filter has been renamed to blurFilter."`
+     * @remarks "CanvasVisionMask#filter has been renamed to blurFilter."
      */
     get filter(): this["blurFilter"];
 
@@ -68,32 +67,84 @@ declare global {
   }
 
   namespace CanvasVisionMask {
+    interface Any extends AnyCanvasVisionMask {}
+    interface AnyConstructor extends Identity<typeof AnyCanvasVisionMask> {}
+
     /**
-     * The sight part of {@link CanvasVisionContainer}.
+     * The sight part of {@link CanvasVisionContainer | `CanvasVisionContainer`}.
      * The blend mode is MAX_COLOR.
      */
     interface CanvasVisionContainerSight extends PIXI.LegacyGraphics {
-      /** FOV that should not be committed to fog exploration. */
+      /**
+       * FOV that should not be committed to fog exploration.
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
+      preview: PIXI.LegacyGraphics;
+    }
+
+    interface GlobalLightContainer extends PIXI.Container {
+      /** @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR` */
+      source: PIXI.LegacyGraphics;
+
+      meshes: PIXI.Container;
+    }
+
+    interface LightMaskGraphics extends PIXI.LegacyGraphics {
       preview: PIXI.LegacyGraphics;
     }
 
     /**
-     * The light part of {@link CanvasVisionContainer}.
+     * The light part of {@link CanvasVisionContainer | `CanvasVisionContainer`}.
      * The blend mode is MAX_COLOR.
      */
     interface CanvasVisionContainerLight extends PIXI.LegacyGraphics {
-      /** FOV that should not be committed to fog exploration. */
+      /**
+       * FOV that should not be committed to fog exploration.
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
       preview: PIXI.LegacyGraphics;
 
-      /** The sprite with the texture of FOV of cached light sources. */
+      /**
+       * The sprite with the texture of FOV of cached light sources.
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
       cached: SpriteMesh;
 
       /** The light perception polygons of vision sources and the FOV of vision sources that provide vision. */
-      mask: PIXI.LegacyGraphics & { preview: PIXI.LegacyGraphics };
+      mask: LightMaskGraphics;
+
+      /**
+       * The global light container, which hold darkness level meshes for dynamic illumination
+       */
+      global: GlobalLightContainer;
+
+      /**
+       * The light sources
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
+      sources: PIXI.LegacyGraphics;
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#fov#lights is deprecated without replacement."
+       */
+      readonly lights: PIXI.LegacyGraphics;
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#fov#lightsSprite is deprecated in favor of CanvasVisibility#vision#light#cached."
+       */
+      readonly lightsSprite: SpriteMesh;
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#fov#tokens is deprecated in favor of CanvasVisibility#vision#light."d
+       */
+      readonly tokens: this;
     }
 
     /**
-     * The sight part of {@link CanvasVisionContainer}.
+     * The sight part of {@link CanvasVisionContainer | `CanvasVisionContainer`}.
      * The blend mode is ERASE.
      */
     interface CanvasVisionContainerDarkness extends PIXI.LegacyGraphics {
@@ -103,14 +154,49 @@ declare global {
 
     /** The currently visible areas. */
     interface CanvasVisionContainer extends PIXI.Container {
+      /**
+       * @remarks A void filter necessary when commiting fog on a texture for dynamic illumination; disabled by default
+       *
+       * `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
+      containmentFilter: VoidFilter;
+
       /** Areas visible because of light sources and light perception. */
       light: CanvasVisionContainerLight;
 
-      /** Areas visible because of FOV of vision sources. */
+      /**
+       * Areas visible because of FOV of vision sources.
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.MAX_COLOR`
+       */
       sight: CanvasVisionContainerSight;
 
-      /** Areas erased by darkness sources. */
+      /**
+       * Areas erased by darkness sources.
+       * @remarks `blendMode` set to `PIXI.BLEND_MODES.ERASE`
+       */
       darkness: CanvasVisionContainerDarkness;
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#base is deprecated in favor of CanvasVisibility#vision#light#preview."
+       */
+      readonly base: CanvasVisionContainerLight["preview"];
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#fov is deprecated in favor of CanvasVisibility#vision#light."
+       */
+      readonly fov: CanvasVisionContainerLight;
+
+      /**
+       * @deprecated since v12, until 14
+       * @remarks "CanvasVisibility#vision#los is deprecated in favor of CanvasVisibility#vision#light#mask."
+       */
+      readonly los: CanvasVisionContainerLight["mask"];
     }
   }
 }
+
+declare abstract class AnyCanvasVisionMask extends CanvasVisionMask {
+  constructor(...args: never);
+}

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

@@ -1,13 +1,10 @@
-export {};
+import type { HandleEmptyObject, Identity } from "#utils";
 
 declare global {
   /**
    * The DrawingsLayer subclass of PlaceablesLayer.
    */
-  class DrawingsLayer<
-    DrawOptions extends DrawingsLayer.DrawOptions = DrawingsLayer.DrawOptions,
-    TearDownOptions extends CanvasLayer.TearDownOptions = CanvasLayer.TearDownOptions,
-  > extends PlaceablesLayer<"Drawing", DrawOptions, TearDownOptions> {
+  class DrawingsLayer extends PlaceablesLayer<"Drawing"> {
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -38,11 +35,14 @@ declare global {
      */
     static DEFAULT_CONFIG_SETTING: "defaultDrawingConfig";
 
-    graphics: Collection<Drawing>;
+    /**
+     * The collection of drawing objects which are rendered in the interface.
+     */
+    graphics: Collection<Drawing.Object>;
 
-    override get hud(): Exclude<Canvas["hud"], undefined>["drawing"];
+    override get hud(): NonNullable<Canvas["hud"]>["drawing"];
 
-    override get hookName(): string;
+    override get hookName(): "DrawingsLayer";
 
     override getSnappedPoint(point: Canvas.Point): Canvas.Point;
 
@@ -51,18 +51,18 @@ declare global {
      */
     configureDefault(): void;
 
-    override _deactivate(): void;
+    protected override _deactivate(): void;
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<DrawingsLayer.DrawOptions>): Promise<void>;
 
     /**
      * Get initial data for a new drawing.
      * Start with some global defaults, apply user default config, then apply mandatory overrides per tool.
      * @param origin - The initial coordinate
      * @returns The new drawing data
-     * @remarks This is used from DrawingConfig and hence public on purpose.
+     * @privateRemarks This isn't called externally (anymore?) but seems too useful to make protected without any indication on Foundry's side of such intent
      */
-    _getNewDrawingData(origin: Canvas.Point): foundry.documents.BaseDrawing.ConstructorData;
+    _getNewDrawingData(origin: Canvas.Point): DrawingDocument.CreateData;
 
     protected override _onClickLeft(event: PIXI.FederatedEvent): void;
 
@@ -93,11 +93,12 @@ declare global {
   }
 
   namespace DrawingsLayer {
-    type AnyConstructor = typeof AnyDrawingsLayer;
+    interface Any extends AnyDrawingsLayer {}
+    interface AnyConstructor extends Identity<typeof AnyDrawingsLayer> {}
 
     interface DrawOptions extends CanvasLayer.DrawOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Drawing"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Drawing.ObjectClass> {
       name: "drawings";
       controllableObjects: true;
       rotatableObjects: true;
@@ -107,5 +108,5 @@ declare global {
 }
 
 declare abstract class AnyDrawingsLayer extends DrawingsLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,6 +1,7 @@
 import "./drawings.d.mts";
 import "./lighting.d.mts";
 import "./notes.d.mts";
+import "./regions.d.mts";
 import "./sounds.d.mts";
 import "./templates.d.mts";
 import "./tiles.d.mts";

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

@@ -1,13 +1,10 @@
-export {};
+import type { HandleEmptyObject, Identity } from "#utils";
 
 /**
  * The Lighting Layer which ambient light sources as part of the CanvasEffectsGroup.
  */
 declare global {
-  class LightingLayer<
-    DrawOptions extends LightingLayer.DrawOptions = LightingLayer.DrawOptions,
-    TearDownOptions extends LightingLayer.TearDownOptions = LightingLayer.TearDownOptions,
-  > extends PlaceablesLayer<"AmbientLight", DrawOptions, TearDownOptions> {
+  class LightingLayer extends PlaceablesLayer<"AmbientLight"> {
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -32,20 +29,20 @@ declare global {
      */
     static override get layerOptions(): LightingLayer.LayerOptions;
 
-    override get hookName(): string;
+    override get hookName(): "LightingLayer";
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<LightingLayer.DrawOptions>): Promise<void>;
 
-    override _tearDown(options?: TearDownOptions): Promise<void>;
+    protected override _tearDown(options: HandleEmptyObject<LightingLayer.TearDownOptions>): Promise<void>;
 
     /**
      * Refresh the fields of all the ambient lights on this scene.
      */
     refreshFields(): void;
 
-    override _activate(): void;
+    protected override _activate(): void;
 
-    protected override _canDragLeftStart(user: User.ConfiguredInstance, event: PIXI.FederatedEvent): boolean;
+    protected override _canDragLeftStart(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
 
     protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
 
@@ -54,7 +51,7 @@ declare global {
     protected override _onDragLeftCancel(event: PointerEvent): void;
 
     // @ts-expect-error Foundry is changing the return type here from Promise<PlaceableObject[]> to just Promise<AmbientLight>
-    protected _onMouseWheel(event: WheelEvent): ReturnType<AmbientLight.ConfiguredInstance["rotate"]>;
+    protected _onMouseWheel(event: WheelEvent): Promise<AmbientLight.Object>;
 
     /**
      * Actions to take when the darkness level of the Scene is changed
@@ -64,13 +61,14 @@ declare global {
   }
 
   namespace LightingLayer {
-    type AnyConstructor = typeof AnyLightingLayer;
+    interface Any extends AnyLightingLayer {}
+    interface AnyConstructor extends Identity<typeof AnyLightingLayer> {}
 
     interface DrawOptions extends PlaceablesLayer.DrawOptions {}
 
     interface TearDownOptions extends PlaceablesLayer.TearDownOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"AmbientLight"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<AmbientLight.ObjectClass> {
       name: "lighting";
       rotatableObjects: true;
       zIndex: 900;
@@ -79,5 +77,5 @@ declare global {
 }
 
 declare abstract class AnyLightingLayer extends LightingLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -1,13 +1,10 @@
-import type { InexactPartial } from "../../../../../types/utils.d.mts";
+import type { HandleEmptyObject, Identity, InexactPartial, NullishProps } from "#utils";
 
 declare global {
   /**
    * The Notes Layer which contains Note canvas objects
    */
-  class NotesLayer<
-    DrawOptions extends NotesLayer.DrawOptions = NotesLayer.DrawOptions,
-    TearDownOptions extends PlaceablesLayer.TearDownOptions = PlaceablesLayer.TearDownOptions,
-  > extends PlaceablesLayer<"Note", DrawOptions, TearDownOptions> {
+  class NotesLayer extends PlaceablesLayer<"Note"> {
     /**
      * @privateRemarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -36,13 +33,14 @@ declare global {
      */
     static TOGGLE_SETTING: "notesDisplayToggle";
 
-    override get hookName(): string;
+    override get hookName(): "NotesLayer";
 
+    /** @defaultValue `game.settings.get("core", "notesDisplayToggle")` */
     override interactiveChildren: boolean;
 
-    override _deactivate(): void;
+    protected override _deactivate(): void;
 
-    override _draw(options?: DrawOptions): Promise<void>;
+    protected override _draw(options: HandleEmptyObject<NotesLayer.DrawOptions>): Promise<void>;
 
     /**
      * Register game settings used by the NotesLayer
@@ -61,50 +59,69 @@ declare global {
      * @returns A Promise which resolves once the pan animation has concluded.
      */
     panToNote(
-      note: Note,
-      /** @remarks Can't be NullishProps because `duration` is passed to `canvas.animatePan` which only provides a default for `undefined` with `{ duration=250 }`, and must be numeric */
-      options?: InexactPartial<{
-        /**
-         * The resulting zoom level.
-         * @defaultValue `1.5`
-         */
-        scale: number;
-
-        /**
-         * The speed of the pan animation in milliseconds.
-         * @defaultValue `250`
-         */
-        duration: number;
-      }>,
+      note: Note.Object,
+      options?: NotesLayer.PanToNoteOptions, // not:null (destructured)
     ): Promise<void>;
 
-    protected override _onClickLeft(event: PIXI.FederatedEvent): Promise<Note | void>;
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    protected override _onClickLeft(event: PIXI.FederatedEvent): Promise<Note.Object | void>;
 
     /**
      * Handle JournalEntry document drop data
      */
-    protected _onDropData(event: DragEvent, data: NotesLayer.DropData): Promise<false | Note>;
+    protected _onDropData(event: DragEvent, data: NotesLayer.DropData): Promise<false | Note.Object>;
   }
 
   namespace NotesLayer {
-    type AnyConstructor = typeof AnyNotesLayer;
+    interface Any extends AnyNotesLayer {}
+    interface AnyConstructor extends Identity<typeof AnyNotesLayer> {}
 
     interface DrawOptions extends PlaceablesLayer.DrawOptions {}
 
-    interface LayerOptions extends PlaceablesLayer.LayerOptions<"Note"> {
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Note.ObjectClass> {
       name: "notes";
       zIndex: 800;
     }
 
-    interface DropData<DocType extends "JournalEntry" | "JournalEntryPage" = "JournalEntry" | "JournalEntryPage">
-      extends Canvas.DropPosition {
-      type: DocType;
+    /** @internal */
+    interface _DropDataCommon {
       uuid: string;
-      anchor: DocType extends "JournalEntryPage" ? { name: string } : undefined;
     }
+
+    interface DropDataJournalEntry extends _DropDataCommon, Canvas.DropPosition {
+      type: "JournalEntry";
+    }
+
+    interface DropDataJournalEntryPage extends _DropDataCommon, Canvas.DropPosition {
+      type: "JournalEntryPage";
+      anchor: { name: string };
+    }
+
+    type DropData = DropDataJournalEntry | DropDataJournalEntryPage;
+
+    /** @internal */
+    type _PanToNoteOptions = NullishProps<{
+      /**
+       * The resulting zoom level.
+       * @defaultValue `1.5`
+       * @remarks The above is a parameter default only; `null` will be eventually be handled by
+       * {@link Canvas#_constrainView}, where it will be replaced with `canvas.stage.scale.x`
+       */
+      scale: number;
+    }> &
+      InexactPartial<{
+        /**
+         * The speed of the pan animation in milliseconds.
+         * @defaultValue `250`
+         * @remarks Can't be `null` as it only has a parameter default
+         */
+        duration: number;
+      }>;
+
+    interface PanToNoteOptions extends _PanToNoteOptions {}
   }
 }
 
 declare abstract class AnyNotesLayer extends NotesLayer {
-  constructor(arg0: never, ...args: never[]);
+  constructor(...args: never);
 }

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

@@ -0,0 +1,113 @@
+import type { HandleEmptyObject, Identity } from "#utils";
+import type Document from "../../../../common/abstract/document.d.mts";
+import type DataModel from "../../../../common/abstract/data.d.mts";
+
+declare global {
+  /**
+   * The Region Container.
+   */
+  class RegionLayer extends PlaceablesLayer<"Region"> {
+    #regionLayer: true;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["regions"];
+
+    /**
+     * @defaultValue
+     * ```
+     * foundry.utils.mergeObject(super.layerOptions, {
+     *  name: "regions",
+     *  controllableObjects: true,
+     *  confirmDeleteKey: true,
+     *  quadtree: false,
+     *  zIndex: 100,
+     *  zIndexActive: 600
+     * })
+     * ```
+     */
+    static override get layerOptions(): RegionLayer.LayerOptions;
+
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    override options: RegionLayer.LayerOptions;
+
+    static override documentName: "Region";
+
+    override get hookName(): "RegionLayer";
+
+    /** The RegionLegend application of this RegionLayer */
+    get legend(): foundry.applications.ui.RegionLegend;
+
+    /**
+     * Draw shapes as holes?
+     * @defaultValue `false`
+     * @remarks Foundry marked `@internal` but gets *and* sets it via the "hole" layer control toggle.
+     * Leaving public as this seems to be the source of truth for that.
+     */
+    _holeMode: boolean;
+
+    protected override _activate(): void;
+
+    protected override _deactivate(): void;
+
+    override storeHistory<Operation extends Document.Database.Operation>(
+      type: Operation,
+      data: PlaceablesLayer.HistoryDataFor<Operation, "Region">,
+    ): void;
+
+    /** @remarks Core overrides this returning an empty array to prevent copy & paste behavior. */
+    override copyObjects(): [];
+
+    override getSnappedPoint(point: Canvas.Point): Canvas.Point;
+
+    override getZIndex(): number;
+
+    protected override _draw(options: HandleEmptyObject<RegionLayer.DrawOptions>): Promise<void>;
+
+    /**
+     * Highlight the shape or clear the highlight.
+     * @param data - The shape to highlight, or null to clear the highlight
+     * @remarks Foundry marked `@internal`. If `data` is falsey, clears the current highly and returns early
+     */
+    protected _highlightShape(data?: DataModel.ConstructorDataFor<foundry.data.BaseShapeData> | null): void;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): void;
+
+    protected override _onClickLeft2(event: PIXI.FederatedEvent): void;
+
+    protected override _canDragLeftStart(user: User.Implementation, event: PIXI.FederatedEvent): boolean;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftCancel(event: PointerEvent): void;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): void;
+  }
+
+  namespace RegionLayer {
+    interface Any extends AnyRegionLayer {}
+    interface AnyConstructor extends Identity<typeof AnyRegionLayer> {}
+
+    interface DrawOptions extends PlaceablesLayer.DrawOptions {}
+
+    interface LayerOptions extends PlaceablesLayer.LayerOptions<Region.ObjectClass> {
+      name: "regions";
+      controllableObjects: true;
+      confirmDeleteKey: true;
+      quadtree: false;
+      zIndex: 100;
+      zIndexActive: 600;
+    }
+  }
+}
+
+declare abstract class AnyRegionLayer extends RegionLayer {
+  constructor(...args: never);
+}