@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1-beta.20250704.94554

package/src/foundry/client/pixi/perception/perception-manager.d.mts

@@ -1,167 +0,0 @@
-import type { InterfaceToObject, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * @deprecated {@link PerceptionManager.RenderFlags | `PerceptionManager.RenderFlags`}
-   */
-  type PerceptionManagerFlags = PerceptionManager.RenderFlags;
-
-  /**
-   * A helper class which manages the refresh workflow for perception layers on the canvas.
-   * This controls the logic which batches multiple requested updates to minimize the amount of work required.
-   * A singleton instance is available as {@link Canvas.perception | `Canvas#perception`}.
-   */
-  class PerceptionManager extends RenderFlagsMixin() {
-    static RENDER_FLAGS: InterfaceToObject<PerceptionManager.RENDER_FLAGS>;
-
-    static RENDER_FLAG_PRIORITY: "PERCEPTION";
-
-    // Note: This isn't a "real" override but `renderFlags` is set corresponding to the
-    // `RENDER_FLAGS` and so it has to be adjusted here.
-    renderFlags: RenderFlags<PerceptionManager.RENDER_FLAGS>;
-
-    applyRenderFlags(): void;
-
-    /**
-     * Update perception manager flags which configure which behaviors occur on the next frame render.
-     * @param flags - Flag values (true) to assign where the keys belong to PerceptionManager.FLAGS
-     */
-    update(flags: PerceptionManager.PassableFlags): void;
-
-    /**
-     * A helper function to perform an immediate initialization plus incremental refresh.
-     */
-    initialize(): void;
-
-    /**
-     * @deprecated since v12, will be removed in v14
-     * @remarks "PerceptionManager#refresh is deprecated in favor of assigning granular \"refresh flags\""
-     */
-    refresh(): void;
-  }
-
-  namespace PerceptionManager {
-    interface Any extends AnyPerceptionManager {}
-    type AnyConstructor = typeof AnyPerceptionManager;
-
-    type PassableFlags = NullishProps<RenderFlags>;
-
-    type RenderFlags = RenderFlagsMixin.ToBooleanFlags<RENDER_FLAGS>;
-
-    interface RENDER_FLAGS {
-      /**
-       * Recompute intersections between all registered edges. See {@link CanvasEdges#refresh}.
-       * @defaultValue `{}`
-       */
-      refreshEdges: RenderFlag<this, "refreshEdges">;
-
-      /**
-       * Re-initialize the entire lighting configuration. An aggregate behavior
-       * which does no work directly but propagates to set several other flags.
-       * @defaultValue `{ propagate: ["initializeDarknessSources", "initializeLightSources"] }`
-       */
-      initializeLighting: RenderFlag<this, "initializeLighting">;
-
-      /** @defaultValue `{ propagate: ["refreshLighting", "refreshVision", "refreshEdges"] }` */
-      initializeDarknessSources: RenderFlag<this, "initializeDarknessSources">;
-
-      /** @defaultValue `{ propagate: ["refreshLighting", "refreshVision"] }` */
-      initializeLightSources: RenderFlag<this, "initializeLightSources">;
-
-      /**
-       * Refresh the rendered appearance of lighting
-       * @defaultValue `{ propagate: ["refreshLightSources"] }`
-       */
-      refreshLighting: RenderFlag<this, "refreshLighting">;
-
-      /**
-       * Update the configuration of light sources
-       * @defaultValue `{}`
-       */
-      refreshLightSources: RenderFlag<this, "refreshLightSources">;
-
-      /**
-       * Re-initialize the entire vision modes. See {@link CanvasVisibility#initializeVisionMode}.
-       * @defaultValue `{ propagate: ["refreshVisionSources", "refreshLighting", "refreshPrimary"] }`
-       */
-      initializeVisionModes: RenderFlag<this, "initializeVisionModes">;
-
-      /**
-       * Re-initialize the entire vision configuration. See {@link CanvasVisibility#initializeSources}.
-       * @defaultValue `{ propagate: ["initializeVisionModes", "refreshVision"] }`
-       */
-      initializeVision: RenderFlag<this, "initializeVision">;
-
-      /**
-       * Refresh the rendered appearance of vision
-       * @defaultValue `{ propagate: ["refreshVisionSources", "refreshOcclusionMask"] }`
-       */
-      refreshVision: RenderFlag<this, "refreshVision">;
-
-      /**
-       * Update the configuration of vision sources
-       * @defaultValue `{}`
-       */
-      refreshVisionSources: RenderFlag<this, "refreshVisionSources">;
-
-      /**
-       * Refresh the contents of the PrimaryCanvasGroup mesh
-       * @defaultValue `{}`
-       */
-      refreshPrimary: RenderFlag<this, "refreshPrimary">;
-
-      /**
-       * Refresh occlusion
-       * @defaultValue `{propagate: ["refreshOcclusionStates", "refreshOcclusionMask"] }`
-       */
-      refreshOcclusion: RenderFlag<this, "refreshOcclusion">;
-
-      /** @defaultValue `{}` */
-      refreshOcclusionStates: RenderFlag<this, "refreshOcclusionStates">;
-
-      /** @defaultValue `{}` */
-      refreshOcclusionMask: RenderFlag<this, "refreshOcclusionMask">;
-
-      /**
-       * Re-initialize the entire ambient sound configuration. See {@link SoundsLayer#initializeSources}.
-       * @defaultValue `{ propagate: ["refreshSounds"] }`
-       */
-      initializeSounds: RenderFlag<this, "initializeSounds">;
-
-      /**
-       * Refresh the audio state of ambient sounds
-       * @defaultValue `{}`
-       */
-      refreshSounds: RenderFlag<this, "refreshSounds">;
-
-      /**
-       * Apply a fade duration to sound refresh workflow
-       * @defaultValue `{}`
-       */
-      soundFadeDuration: RenderFlag<this, "soundFadeDuration">;
-
-      /**
-       * @defaultValue `{ propagate: ["refreshOcclusion"] }`
-       * @deprecated since v12, will be removed in v14
-       */
-      refreshTiles: RenderFlag<this, "refreshTiles">;
-
-      /**
-       * @defaultValue `{ propagate: ["initializeLighting", "initializeVision"] }`
-       * @deprecated since v12, will be removed in v14
-       */
-      identifyInteriorWalls: RenderFlag<this, "identifyInteriorWalls">;
-
-      /**
-       * @defaultValue `{ propagate: ["refreshVision"] }`
-       * @deprecated since v11, will be removed in v13
-       * @remarks In v12 the flag remains, but the static method it would have triggered was removed prematurely (was listed as until v13 in v11)
-       */
-      forceUpdateFog: RenderFlag<this, "forceUpdateFog">;
-    }
-  }
-}
-
-declare abstract class AnyPerceptionManager extends PerceptionManager {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/perception/vision-mode.d.mts

@@ -1,245 +0,0 @@
-import type { Brand, InterfaceToObject, RemoveIndexSignatures, SimpleMerge } from "fvtt-types/utils";
-import type { fields } from "#common/data/_module.d.mts";
-import type { DataSchema } from "#common/data/fields.d.mts";
-import DataField = foundry.data.fields.DataField;
-import type DataModel from "#common/abstract/data.d.mts";
-import type PointVisionSource from "#client-esm/canvas/sources/point-vision-source.d.mts";
-
-declare global {
-  class ShaderField<
-    const Options extends ShaderField.Options = ShaderField.DefaultOptions,
-    const AssignmentType = ShaderField.AssignmentType<Options>,
-    const InitializedType = ShaderField.InitializedType<Options>,
-    const PersistedType extends typeof AbstractBaseShader | null | undefined = ShaderField.InitializedType<Options>,
-  > extends foundry.data.fields.DataField<Options, AssignmentType, InitializedType, PersistedType> {
-    /**
-     * @defaultValue
-     * ```typescript
-     * const defaults = super._defaults;
-     * defaults.nullable = true;
-     * defaults.initial = undefined;
-     * return defaults;
-     * ```
-     */
-    static override get _defaults(): ShaderField.DefaultOptions;
-
-    // TODO: _cast blatantly breaks inheritance so this is difficult to work with
-    /** @remarks The value provided to a ShaderField must be an AbstractBaseShader subclass. */
-    override _cast(value: any): NonNullable<InitializedType>; // typeof AbstractBaseShader;
-  }
-
-  namespace ShaderField {
-    type Options = DataField.Options<typeof AbstractBaseShader>;
-
-    type DefaultOptions = SimpleMerge<
-      DataField.DefaultOptions,
-      {
-        nullable: true;
-        initial: undefined;
-      }
-    >;
-
-    /**
-     * A helper type for the given options type merged into the default options of the BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    type MergedOptions<Opts extends Options> = SimpleMerge<DefaultOptions, Opts>;
-
-    /**
-     * A shorthand for the assignment type of a BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    type AssignmentType<Opts extends Options> = DataField.DerivedAssignmentType<
-      typeof AbstractBaseShader,
-      MergedOptions<Opts>
-    >;
-
-    /**
-     * A shorthand for the initialized type of a BooleanField class.
-     * @typeParam Opts - the options that override the default options
-     */
-    type InitializedType<Opts extends Options> = DataField.DerivedInitializedType<
-      typeof AbstractBaseShader,
-      MergedOptions<Opts>
-    >;
-  }
-
-  /**
-   * A Vision Mode which can be selected for use by a Token.
-   * The selected Vision Mode alters the appearance of various aspects of the canvas while that Token is the POV.
-   */
-  class VisionMode extends foundry.abstract.DataModel<
-    VisionMode.Schema,
-    DataModel.Any | null,
-    InterfaceToObject<VisionMode.ExtraConstructorOptions>
-  > {
-    // A constructor override has been omitted as there are no typing changes
-
-    static defineSchema(): VisionMode.Schema;
-
-    /** The lighting illumination levels which are supported. */
-    static LIGHTING_LEVELS: typeof foundry.CONST.LIGHTING_LEVELS;
-
-    /**
-     * Flags for how each lighting channel should be rendered for the currently active vision modes:
-     * - Disabled: this lighting layer is not rendered, the shaders does not decide.
-     * - Enabled: this lighting layer is rendered normally, and the shaders can choose if they should be rendered or not.
-     * - Required: the lighting layer is rendered, the shaders does not decide.
-     */
-    static LIGHTING_VISIBILITY: VisionMode.LightingVisibility;
-
-    /**
-     * A flag for whether this vision source is animated
-     * @defaultValue `false`
-     */
-    animated: boolean;
-
-    /**
-     * Does this vision mode enable light sources?
-     * True unless it disables lighting entirely.
-     */
-    get perceivesLight(): boolean;
-
-    /**
-     * Special activation handling that could be implemented by VisionMode subclasses
-     * @param source - Activate this VisionMode for a specific source
-     */
-    _activate(source: PointVisionSource.Any): void;
-
-    /**
-     * Special deactivation handling that could be implemented by VisionMode subclasses
-     * @param source - Deactivate this VisionMode for a specific source
-     */
-    _deactivate(source: PointVisionSource.Any): void;
-
-    /**
-     * Special handling which is needed when this Vision Mode is activated for a VisionSource.
-     * @param source - Activate this VisionMode for a specific source
-     */
-    activate(source: PointVisionSource.Any): void;
-
-    /**
-     * Special handling which is needed when this Vision Mode is deactivated for a VisionSource.
-     * @param source - Deactivate this VisionMode for a specific source
-     */
-    deactivate(source: PointVisionSource.Any): void;
-
-    /**
-     * An animation function which runs every frame while this Vision Mode is active.
-     * @param dt - The deltaTime passed by the PIXI Ticker
-     * @remarks Calls `RenderedEffectSource#animateTime` with `this` set to this `VisionMode`
-     */
-    animate(dt: number): void;
-  }
-
-  namespace VisionMode {
-    interface Any extends AnyVisionMode {}
-    type AnyConstructor = typeof AnyVisionMode;
-
-    type ConfiguredModes = keyof RemoveIndexSignatures<CONFIG["Canvas"]["visionModes"]>;
-
-    type LIGHTING_VISIBILITY = Brand<number, "VisionMode.LIGHTING_VISIBILITY">;
-
-    interface ExtraConstructorOptions {
-      animated?: boolean | undefined | null;
-    }
-
-    interface LightingVisibility {
-      /** Disabled: this lighting layer is not rendered, the shaders does not decide. */
-      DISABLED: 0 & LIGHTING_VISIBILITY;
-      /** Enabled: this lighting layer is rendered normally, and the shaders can choose if they should be rendered or not. */
-      ENABLED: 1 & LIGHTING_VISIBILITY;
-      /** Required: the lighting layer is rendered, the shaders does not decide. */
-      REQUIRED: 2 & LIGHTING_VISIBILITY;
-    }
-
-    type ShaderSchema = fields.SchemaField<{
-      shader: ShaderField;
-      uniforms: fields.ObjectField;
-    }>;
-
-    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
-    type LightingSchema = {
-      visibility: fields.NumberField;
-      postProcessingModes: fields.ArrayField<fields.StringField>;
-      uniforms: fields.ObjectField;
-    };
-
-    type LightingSchemaField = fields.SchemaField<LightingSchema>;
-
-    type LightingLevels = Record<foundry.CONST.LIGHTING_LEVELS, foundry.CONST.LIGHTING_LEVELS>;
-    type LightingMultipliers = Record<foundry.CONST.LIGHTING_LEVELS, number>;
-
-    interface Schema extends DataSchema {
-      id: fields.StringField<{ blank: false }>;
-      label: fields.StringField<{ blank: false }>;
-      tokenConfig: fields.BooleanField<{ initial: true }>;
-      canvas: fields.SchemaField<{
-        shader: ShaderField;
-        uniforms: fields.ObjectField;
-      }>;
-      lighting: fields.SchemaField<{
-        background: LightingSchemaField;
-        coloration: LightingSchemaField;
-        illumination: LightingSchemaField;
-        levels: fields.ObjectField<
-          {
-            validate: (o: unknown) => boolean;
-            validationError: "may only contain a mapping of keys from VisionMode.LIGHTING_LEVELS";
-          },
-          LightingLevels,
-          LightingLevels,
-          LightingLevels
-        >;
-        multipliers: fields.ObjectField<
-          {
-            validate: (o: unknown) => boolean;
-            validationError: "must provide a mapping of keys from VisionMode.LIGHTING_LEVELS to numeric multiplier values";
-          },
-          LightingMultipliers,
-          LightingMultipliers,
-          LightingMultipliers
-        >;
-      }>;
-      vision: fields.SchemaField<{
-        background: ShaderSchema;
-        coloration: ShaderSchema;
-        illumination: ShaderSchema;
-        darkness: fields.SchemaField<{
-          adaptive: fields.BooleanField<{ initial: true }>;
-        }>;
-        defaults: fields.SchemaField<{
-          color: fields.ColorField<{ required: false; initial: undefined }>;
-          attenuation: fields.AlphaField<{ required: false; initial: undefined }>;
-          brightness: fields.NumberField<{
-            required: false;
-            initial: undefined;
-            nullable: false;
-            min: -1;
-            max: 1;
-          }>;
-          saturation: fields.NumberField<{
-            required: false;
-            initial: undefined;
-            nullable: false;
-            min: -1;
-            max: 1;
-          }>;
-          contrast: fields.NumberField<{
-            required: false;
-            initial: undefined;
-            nullable: false;
-            min: -1;
-            max: 1;
-          }>;
-        }>;
-        preferred: fields.BooleanField<{ initial: false }>;
-      }>;
-    }
-  }
-}
-
-declare class AnyVisionMode extends VisionMode {
-  constructor(...args: never);
-}

package/src/foundry/client/pixi/perception/weiler-atherton-clipping.d.mts

@@ -1,190 +0,0 @@
-import type { Brand, Identity, NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * An implementation of the Weiler Atherton algorithm for clipping polygons.
-   * This currently only handles combinations that will not result in any holes.
-   * Support may be added for holes in the future.
-   *
-   * This algorithm is faster than the Clipper library for this task because it relies on the unique properties of the
-   * circle, ellipse, or convex simple clip object.
-   * It is also more precise in that it uses the actual intersection points between the circle/ellipse and polygon,
-   * instead of relying on the polygon approximation of the circle/ellipse to find the intersection points.
-   *
-   * For more explanation of the underlying algorithm, see:
-   * https://en.wikipedia.org/wiki/Weiler%E2%80%93Atherton_clipping_algorithm
-   * https://www.geeksforgeeks.org/weiler-atherton-polygon-clipping-algorithm
-   * https://h-educate.in/weiler-atherton-polygon-clipping-algorithm/
-   *
-   * @throws If `!Polygon.isPositive`
-   * @remarks In practice the only thing that uses the constructor is the class's static methods
-   */
-  class WeilerAthertonClipper {
-    /**
-     * Construct a WeilerAthertonClipper instance used to perform the calculation.
-     * @param polygon       - Polygon to clip
-     * @param clipObject    - Object used to clip the polygon
-     * @param clipType      - Type of clip to use
-     *                        (default: `0`)
-     * @param clipOpts      - Object passed to the clippingObject methods toPolygon and pointsBetween
-     *                        (default: `{}`)
-     */
-    constructor(
-      polygon: PIXI.Polygon,
-      clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipType?: WeilerAthertonClipper.CLIP_TYPES,
-      clipOpts?: WeilerAthertonClipper.ClipOpts,
-    );
-
-    /**
-     * The supported clip types.
-     * Values are equivalent to those in ClipperLib.ClipType.
-     */
-    static CLIP_TYPES: WeilerAthertonClipper.ClipTypes;
-
-    /**
-     * The supported intersection types.
-     */
-    static INTERSECTION_TYPES: WeilerAthertonClipper.IntersectionTypes;
-
-    polygon: PIXI.Polygon;
-
-    clipObject: PIXI.Rectangle | PIXI.Circle;
-
-    /**
-     * Configuration settings
-     */
-    config: WeilerAthertonClipper.Config;
-
-    /**
-     * Union a polygon and clipObject using the Weiler Atherton algorithm.
-     * @param polygon       - Polygon to clip
-     * @param clipObject    - Object to clip against the polygon
-     * @param clipOpts      - Options passed to the clipping object
-     *                        methods toPolygon and pointsBetween
-     */
-    static union(
-      polygon: PIXI.Polygon,
-      clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipOpts?: WeilerAthertonClipper.ClipOpts,
-    ): PIXI.Polygon[];
-
-    /**
-     * Intersect a polygon and clipObject using the Weiler Atherton algorithm.
-     * @param polygon       - Polygon to clip
-     * @param clipObject    - Object to clip against the polygon
-     * @param clipOpts      - Options passed to the clipping object
-     *                        methods toPolygon and pointsBetween
-     */
-    static intersect(
-      polygon: PIXI.Polygon,
-      clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipOpts?: WeilerAthertonClipper.ClipOpts,
-    ): PIXI.Polygon[];
-
-    /**
-     * Clip a given clipObject using the Weiler-Atherton algorithm.
-     *
-     * At the moment, this will return a single PIXI.Polygon in the array unless clipType is a union and the polygon
-     * and clipObject do not overlap, in which case the [polygon, clipObject.toPolygon()] array will be returned.
-     * If this algorithm is expanded in the future to handle holes, an array of polygons may be returned.
-     *
-     * @param polygon    - Polygon to clip
-     * @param clipObject - Object to clip against the polygon
-     * @param options    - Options which configure how the union or intersection is computed
-     * @returns Array of polygons and clipObjects
-     */
-    static combine(
-      polygon: PIXI.Polygon,
-      clipObject: PIXI.Rectangle | PIXI.Circle,
-      /** @remarks Despite foundry marking this parameter optional, if an object with a valid `clipType` property is not passed, this will throw */
-      options: WeilerAthertonClipper.CombineOptions,
-    ): PIXI.Polygon[];
-
-    /**
-     * Test if one shape envelops the other. Assumes the shapes do not intersect.
-     *  1. Polygon is contained within the clip object. Union: clip object; Intersect: polygon
-     *  2. Clip object is contained with polygon. Union: polygon; Intersect: clip object
-     *  3. Polygon and clip object are outside one another. Union: both; Intersect: null
-     * @param polygon       - Polygon to clip
-     * @param clipObject    - Object to clip against the polygon
-     * @param clipType      - One of CLIP_TYPES
-     * @param clipOpts      - Clip options which are forwarded to toPolygon methods
-     * @returns Returns the polygon, the clipObject.toPolygon(), both, or neither.
-     */
-    static testForEnvelopment(
-      polygon: PIXI.Polygon,
-      clipObject: PIXI.Rectangle | PIXI.Circle,
-      clipType: WeilerAthertonClipper.CLIP_TYPES,
-      clipOpts: WeilerAthertonClipper.ClipOpts,
-    ): PIXI.Polygon[];
-  }
-
-  namespace WeilerAthertonClipper {
-    interface Any extends AnyWeilerAthertonClipper {}
-    interface AnyConstructor extends Identity<typeof AnyWeilerAthertonClipper> {}
-
-    type CLIP_TYPES = Brand<number, "WeilerAthertonClipper.CLIP_TYPES">;
-
-    interface ClipTypes {
-      readonly INTERSECT: 0 & CLIP_TYPES;
-      readonly UNION: 1 & CLIP_TYPES;
-    }
-
-    type INTERSECTION_TYPES = Brand<number, "WeilerAthertonClipper.INTERSECTION_TYPES">;
-
-    interface IntersectionTypes {
-      readonly OUT_IN: -1 & INTERSECTION_TYPES;
-      readonly IN_OUT: 1 & INTERSECTION_TYPES;
-      readonly TANGENT: 0 & INTERSECTION_TYPES;
-    }
-
-    /** Configuration settings */
-    interface Config {
-      /**
-       * One of CLIP_TYPES
-       * @defaultValue `WeilerAthertonClipper.CLIP_TYPES.INTERSECT`
-       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
-       */
-      clipType: WeilerAthertonClipper.CLIP_TYPES;
-
-      /**
-       * Object passed to the clippingObject methods `toPolygon` and `pointsBetween`
-       * @defaultValue `{}`
-       * @remarks Set to the value of the equivalent constructor parameter. Default provided by `??=` in the constructor body
-       */
-      clipOpts: WeilerAthertonClipper.ClipOpts;
-    }
-
-    /**
-     * @internal
-     * @privateRemarks does *not* contain:
-     * - a `scalingFactor` property, despite one being passed in `PIXI.Rectangle#intersectPolygon` in v12
-     * - a `density` property, despite one being passed in `PIXI.Circle#intersectPolygon` in v12
-     */
-    type _CombineOptions = NullishProps<{
-      /**
-       * If the WeilerAtherton constructor could mutate or not the subject polygon points
-       */
-      canMutate: boolean;
-    }>;
-
-    interface CombineOptions extends _CombineOptions, ClipOpts {
-      /**
-       * One of CLIP_TYPES
-       */
-      clipType: WeilerAthertonClipper.CLIP_TYPES;
-    }
-
-    /**
-     * @remarks These are ultimately only consumed by the `#toPolygon` and `#pointsBetween` methods
-     * of `PIXI.Rectangle` or `PIXI.Circle`. Only the `Circle` methods actually take options and those are
-     * only passed on to `#pointsForArc`.
-     */
-    type ClipOpts = PIXI.Circle.PointsForArcOptions;
-  }
-}
-
-declare abstract class AnyWeilerAthertonClipper extends WeilerAthertonClipper {
-  constructor(...args: never);
-}