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

package/src/foundry/client/pixi/placeables/drawing.d.mts

@@ -0,0 +1,292 @@
+import type { ValueOf } from "../../../../types/utils.d.mts";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace Drawing {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Drawing>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshShape: boolean;
+
+      refreshFrame: boolean;
+
+      refreshText: boolean;
+
+      refreshMesh: boolean;
+    }
+
+    interface TextEditingOptions {
+      forceTextEditing?: boolean;
+
+      isNew?: boolean;
+    }
+
+    interface AdjustableShape {
+      shape: {
+        width: number;
+        height: number;
+        points: Point[];
+      };
+      x: number;
+      y: number;
+    }
+  }
+
+  /**
+   * The Drawing object is an implementation of the PlaceableObject container.
+   * Each Drawing is a placeable object in the DrawingsLayer.
+   */
+  class Drawing extends PlaceableObject<DrawingDocument.ConfiguredInstance> {
+    constructor(document: DrawingDocument.ConfiguredInstance);
+
+    /**
+     * Each Drawing object belongs to the DrawingsLayer
+     * @remarks it's possible this shouldn't be here and is some data model thing
+     */
+    get layer(): DrawingsLayer;
+
+    /**
+     * Each Drawing object provides an interface for a DrawingDocument
+     */
+    document: DrawingDocument;
+
+    /**
+     * The border frame and resizing handles for the drawing.
+     */
+    frame: PIXI.Container;
+
+    /**
+     * A text label that may be displayed as part of the interface layer for the Drawing.
+     * @defaultValue `null`
+     */
+    text: PreciseText | null;
+
+    /**
+     * The primary drawing shape
+     * @defaultValue `null`
+     */
+    shape: DrawingShape;
+
+    static override embeddedName: "Drawing";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshShape"], alias: true }` */
+      refresh: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshFrame"] }` */
+      refreshState: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshFrame", "refreshText", "refreshMesh"] }` */
+      refreshShape: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshFrame: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshText: RenderFlag<Partial<Drawing.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshMesh: RenderFlag<Partial<Drawing.RenderFlags>>;
+    };
+
+    /**
+     * The rate at which points are sampled (in milliseconds) during a freehand drawing workflow
+     * @defaultValue `75`
+     */
+    static FREEHAND_SAMPLE_RATE: number;
+
+    /**
+     * A convenience reference to the possible shape types.
+     */
+    static readonly SHAPE_TYPES: (typeof foundry.data.ShapeData)["TYPES"];
+
+    override get bounds(): Rectangle;
+
+    override get center(): PIXI.Point;
+
+    /**
+     * A Boolean flag for whether the Drawing utilizes a tiled texture background
+     */
+    get isTiled(): boolean;
+
+    /**
+     * A Boolean flag for whether the Drawing is a Polygon type (either linear or freehand)?
+     */
+    get isPolygon(): boolean;
+
+    /**
+     * Does the Drawing have text that is displayed?
+     */
+    get hasText(): boolean;
+
+    /**
+     * The shape type that this Drawing represents. A value in Drawing.SHAPE_TYPES.
+     */
+    get type(): ValueOf<(typeof foundry.data.ShapeData)["TYPES"]>;
+
+    override clear(): this;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Prepare the text style used to instantiate a PIXI.Text or PreciseText instance for this Drawing document.
+     */
+    protected _getTextStyle(): PIXI.TextStyle;
+
+    protected override _applyRenderFlags(flags: Drawing.RenderFlags): void;
+
+    /**
+     * Draw ellipsoid shapes
+     * @internal
+     */
+    protected _drawEllipse(): void;
+
+    /**
+     * Add a new polygon point to the drawing, ensuring it differs from the last one
+     * @param position - The drawing point to add
+     * @param options  - Options which configure how the point is added
+     * @internal
+     */
+    protected _addPoint(
+      position: Point,
+      options?: {
+        /**
+         * Should the point be rounded to integer coordinates?
+         * @defaultValue `false`
+         */
+        round?: boolean;
+
+        /**
+         * Should the point be snapped to grid precision?
+         * @defaultValue `false`
+         */
+        snap?: boolean;
+
+        /**
+         * Is this a temporary control point?
+         * @defaultValue `false`
+         */
+        temporary?: boolean;
+      },
+    ): void;
+
+    /**
+     * Remove the last fixed point from the polygon
+     * @internal
+     */
+    protected _removePoint(): void;
+
+    protected override _onControl(options: PlaceableObject.ControlOptions & Drawing.TextEditingOptions): void;
+
+    protected override _onRelease(options: PlaceableObject.ReleaseOptions): void;
+
+    /**
+     * @privateRemarks _onDelete and _onUpdate are overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    override activateListeners(): void;
+
+    /**
+     * @param event - unused
+     */
+    protected override _canControl(user: User.ConfiguredInstance, event?: any): boolean;
+
+    /**
+     * @param user  - unused
+     * @param event - unused
+     */
+    protected override _canConfigure(user: User.ConfiguredInstance, event?: any): boolean;
+
+    /**
+     * Handle mouse movement which modifies the dimensions of the drawn shape
+     * @internal
+     */
+    protected _onMouseDraw(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
+
+    protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouse-over event on a control handle
+     * @param event - The mouseover event
+     * @internal
+     */
+    protected _onHandleHoverIn(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouse-out event on a control handle
+     * @param event - The mouseout event
+     * @internal
+     */
+    protected _onHandleHoverOut(event: PIXI.FederatedEvent): void;
+
+    /**
+     * When clicking the resize handle, initialize the drag property.
+     * @param event - The mousedown event
+     * @internal
+     */
+    protected _onHandleMouseDown(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Starting the resize handle drag event, initialize the original data.
+     * @internal
+     */
+    protected _onHandleDragStart(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mousemove while dragging a tile scale handler
+     * @param event - The mousemove event
+     * @internal
+     */
+    protected _onHandleDragMove(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Handle mouseup after dragging a tile scale handler
+     * @param event - The mouseup event
+     * @internal
+     */
+    protected _onHandleDragDrop(event: PIXI.FederatedEvent): ReturnType<DrawingDocument.ConfiguredInstance["update"]>;
+
+    /**
+     * Handle cancellation of a drag event for one of the resizing handles
+     * @internal
+     */
+    protected _onHandleDragCancel(event: PIXI.FederatedEvent): void;
+
+    /**
+     * Get a vectorized rescaling transformation for drawing data and dimensions passed in parameter
+     * @param original - The original drawing data
+     * @param dx       - The pixel distance dragged in the horizontal direction
+     * @param dy       - The pixel distance dragged in the vertical direction
+     * @returns The adjusted shape data
+     * @internal
+     */
+    static rescaleDimensions(original: Drawing.AdjustableShape, dx: number, dy: number): Drawing.AdjustableShape;
+
+    /**
+     * Adjust the location, dimensions, and points of the Drawing before committing the change
+     * @param data - The DrawingData pending update
+     * @returns The adjusted data
+     * @remarks This is intentionally public because it is called by the DrawingsLayer
+     * @internal
+     */
+    static normalizeShape(data: Drawing.AdjustableShape): Drawing.AdjustableShape;
+
+    /**
+     * @remarks Not used
+     */
+    controlIcon: null;
+  }
+}

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

@@ -0,0 +1,9 @@
+import "./drawing.d.mts";
+import "./light.d.mts";
+import "./note.d.mts";
+import "./primary-canvas-objects/index.d.mts";
+import "./sound.d.mts";
+import "./template.d.mts";
+import "./tile.d.mts";
+import "./token.d.mts";
+import "./wall.d.mts";

package/src/foundry/client/pixi/placeables/light.d.mts

@@ -0,0 +1,140 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+// TODO: Remove when the whole class is updated
+type LightSource = unknown;
+
+declare global {
+  namespace AmbientLight {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof AmbientLight>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshField: boolean;
+
+      refreshPosition: boolean;
+    }
+  }
+
+  /**
+   * An AmbientLight is an implementation of PlaceableObject which represents a dynamic light source within the Scene.
+   * @see {@link AmbientLightDocument}
+   * @see {@link LightingLayer}
+   */
+  class AmbientLight extends PlaceableObject<AmbientLightDocument.ConfiguredInstance> {
+    constructor(document: AmbientLightDocument.ConfiguredInstance);
+
+    /**
+     * A reference to the PointSource object which defines this light source area of effect
+     */
+    source: LightSource;
+
+    /**
+     * A reference to the ControlIcon used to configure this light
+     * @defaultValue `undefined`
+     */
+    controlIcon: ControlIcon | undefined;
+
+    static override embeddedName: "AmbientLight";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshField"], alias: true }` */
+      refresh: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshPosition", "refreshState"] }` */
+      refreshField: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshPosition: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshState: RenderFlag<Partial<AmbientLight.RenderFlags>>;
+    };
+
+    override get bounds(): PIXI.Rectangle;
+
+    /**
+     * A convenience accessor to the LightData configuration object
+     */
+    get config(): foundry.data.LightData;
+
+    /**
+     * Test whether a specific AmbientLight source provides global illumination
+     */
+    get global(): boolean;
+
+    /**
+     * The maximum radius in pixels of the light field
+     */
+    get radius(): number;
+
+    /**
+     * Get the pixel radius of dim light emitted by this light source
+     */
+    get dimRadius(): number;
+
+    /**
+     * Get the pixel radius of bright light emitted by this light source
+     */
+    get brightRadius(): number;
+
+    /**
+     * Is this Ambient Light currently visible? By default, true only if the source actively emits light.
+     * @remarks Backwards-compatible wrapper for this.emitsLight
+     */
+    get isVisible(): boolean;
+
+    /**
+     * Does this Ambient Light actively emit light given its properties and the current darkness level of the Scene?
+     */
+    get emitsLight(): boolean;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _applyRenderFlags(flags: AmbientLight.RenderFlags): void;
+
+    /**
+     * Refresh the display of the ControlIcon for this AmbientLight source
+     */
+    refreshControl(): void;
+
+    /**
+     * Update the source object associated with this light
+     * @param options - Options which modify how the source is updated
+     */
+    updateSource(options?: {
+      /**
+       * Defer updating perception to manually update it later
+       * @defaultValue `false`
+       */
+      defer?: boolean;
+
+      /**
+       * Indicate that this light source has been deleted
+       * @defaultValue `false`
+       */
+      deleted?: boolean;
+    }): void;
+
+    /**
+     * @privateRemarks _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    protected override _canHUD(user: User.ConfiguredInstance, event?: any): boolean;
+
+    protected override _canConfigure(user: User.ConfiguredInstance, event?: any): boolean;
+
+    protected override _onClickRight(event: PIXI.FederatedEvent): Promise<this>;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftCancel(event: PIXI.FederatedEvent): void;
+  }
+}

package/src/foundry/client/pixi/placeables/note.d.mts

@@ -0,0 +1,114 @@
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace Note {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Note>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshPosition: boolean;
+
+      refreshVisibility: boolean;
+
+      refreshText: boolean;
+    }
+  }
+
+  /**
+   * A Note is an implementation of PlaceableObject which represents an annotated location within the Scene.
+   * Each Note links to a JournalEntry document and represents its location on the map.
+   * @see {@link NoteDocument}
+   * @see {@link NotesLayer}
+   */
+  class Note extends PlaceableObject<NoteDocument.ConfiguredInstance> {
+    static override embeddedName: "Note";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<Note.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshPosition", "refreshText"], alias: true }` */
+      refresh: RenderFlag<Partial<Note.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
+      refreshPosition: RenderFlag<Partial<Note.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshVisibility"] }` */
+      refreshState: RenderFlag<Partial<Note.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshVisibility: RenderFlag<Partial<Note.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshText: RenderFlag<Partial<Note.RenderFlags>>;
+    };
+
+    override get bounds(): Rectangle;
+
+    /**
+     * The associated JournalEntry which is described by this note
+     */
+    get entry(): JournalEntry.ConfiguredInstance;
+
+    /**
+     * The specific JournalEntryPage within the associated JournalEntry referenced by this Note.
+     */
+    get page(): JournalEntryPage;
+
+    /**
+     * The text label used to annotate this Note
+     */
+    get text(): string;
+
+    /**
+     * The Map Note icon size
+     */
+    get size(): number;
+
+    /**
+     * Determine whether the Note is visible to the current user based on their perspective of the Scene.
+     * Visibility depends on permission to the underlying journal entry, as well as the perspective of controlled Tokens.
+     * If Token Vision is required, the user must have a token with vision over the note to see it.
+     */
+    get isVisible(): boolean;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Draw the ControlIcon for the Map Note.
+     * This method replaces any prior controlIcon with the new one.
+     */
+    protected _drawControlIcon(): ControlIcon;
+
+    /**
+     * Draw the map note Tooltip as a Text object.
+     * This method replaces any prior text with the new one.
+     */
+    protected _drawTooltip(): PIXI.Text;
+
+    /**
+     * Define a PIXI TextStyle object which is used for the tooltip displayed for this Note
+     */
+    protected _getTextStyle(): PIXI.TextStyle;
+
+    protected override _applyRenderFlags(flags: Note.RenderFlags): void;
+
+    /**
+     * Refresh the visibility.
+     */
+    protected _refreshVisibility(): void;
+
+    /**
+     * @privateRemarks _onUpdate is overridden but with no signature changes.
+     * For type simplicity it is left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    protected override _canHover(user: User.ConfiguredInstance): true;
+
+    protected override _canView(user: User.ConfiguredInstance): boolean;
+
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+
+    protected override _onClickLeft2(event: PIXI.FederatedEvent): void;
+  }
+}

package/src/foundry/client/pixi/placeables/primary-canvas-objects/drawing-shape.d.mts

@@ -0,0 +1,143 @@
+import type { Document } from "../../../../common/abstract/module.d.mts";
+
+declare global {
+  /**
+   * A special subclass of PIXI.Container used to represent a Drawing in the PrimaryCanvasGroup.
+   */
+  class DrawingShape extends PrimaryCanvasObjectMixin(PIXI.Graphics) {
+    /**
+     * Sorting values to deal with ties.
+     */
+    static PRIMARY_SORT_ORDER: number;
+
+    /**
+     * @defaultValue
+     * ```js
+     * return foundry.utils.mergeObject(super.defaultData, {
+     *      shape: {
+     *          type: "",
+     *          width: 0,
+     *          height: 0,
+     *          radius: null,
+     *          points: []
+     *      },
+     *      bezierFactor: 0,
+     *      fillType: 0,
+     *      fillColor: 0x7C7C7C,
+     *      fillAlpha: 0.5,
+     *      strokeWidth: 8,
+     *      strokeColor: 0xFFFFFF,
+     *      strokeAlpha: 1,
+     *      text: "New Text",
+     *      fontFamily: "Signika",
+     *      fontSize: 48,
+     *      textColor: 0xFFFFFF,
+     *      textAlpha: 1
+     * })
+     * ```
+     */
+    static override get defaultData(): DrawingShape.PrimaryCanvasObjectDrawingShapeData;
+
+    override refresh(): void;
+
+    override setPosition(): void;
+
+    protected override _getCanvasDocumentData(data: Document.Any): unknown;
+
+    /**
+     * Draw rectangular shapes.
+     */
+    protected _drawRectangle(): void;
+
+    /**
+     * Draw ellipsoid shapes.
+     */
+    protected _drawEllipse(): void;
+
+    /**
+     * Draw polygonal shapes.
+     */
+    protected _drawPolygon(): void;
+
+    /**
+     * Draw freehand shapes with bezier spline smoothing.
+     */
+    protected _drawFreehand(): void;
+  }
+
+  namespace DrawingShape {
+    interface PrimaryCanvasObjectDrawingShapeData extends PrimaryCanvasObjectData {
+      /** The shape */
+      shape: object;
+
+      /** The x-coordinate of the PCO location */
+      x: number;
+
+      /** The y-coordinate of the PCO location */
+      y: number;
+
+      /** The z-index of the PCO */
+      z: number;
+
+      /** The bezier factor */
+      bezierFactor: number;
+
+      /** The fill type */
+      fillType: number;
+
+      /** The fill color */
+      fillColor: number;
+
+      /** The fill alpha */
+      fillAlpha: number;
+
+      /** The stroke width */
+      strokeWidth: number;
+
+      /** The stroke color */
+      strokeColor: number;
+
+      /** The stroke alpha */
+      strokeAlpha: number;
+
+      /** The text */
+      text: string;
+
+      /** The text font family */
+      fontFamily: string;
+
+      /** The font size */
+      fontSize: number;
+
+      /** The text color */
+      textColor: number;
+
+      /** The text alpha */
+      textAlpha: number;
+
+      /** The rotation of this PCO */
+      rotation: number;
+
+      /** The PCO is hidden? */
+      hidden: boolean;
+
+      /** The elevation of the PCO */
+      elevation: number;
+
+      /** The sort key that resolves ties among the same elevation */
+      sort: number;
+
+      /** The PCO is considered as a roof? */
+      roof: boolean;
+
+      /** The PCO is considered as overhead? */
+      overhead: boolean;
+
+      /** The occlusion object for this PCO */
+      occlusion: object;
+
+      /** The data texture values */
+      texture: PIXI.RenderTexture;
+    }
+  }
+}

package/src/foundry/client/pixi/placeables/primary-canvas-objects/index.d.mts

@@ -0,0 +1,5 @@
+import "./drawing-shape.d.mts";
+import "./occludable-object.d.mts";
+import "./primary-canvas-object.d.mts";
+import "./tile-mesh.d.mts";
+import "./token-mesh.d.mts";