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

package/src/foundry/client/canvas/interaction/ping/pulse.d.mts

@@ -0,0 +1,104 @@
+import type { Identity, InexactPartial } from "#utils";
+import type { Canvas } from "#client/canvas/_module.d.mts";
+import type { CanvasAnimation } from "#client/canvas/animation/_module.d.mts";
+import type { Ping } from "#client/canvas/interaction/_module.d.mts";
+
+/**
+ * A type of ping that produces a pulsing animation.
+ */
+declare class PulsePing extends Ping {
+  /**
+   * @param origin - The canvas coordinates of the origin of the ping.
+   * @param options - Additional options to configure the ping animation.
+   */
+  constructor(
+    origin: Canvas.Point,
+
+    /** @privateRemarks Can't be `null` as it's directly assigned to  `Ping#options` which has properties accessed null-unsafely */
+    options?: PulsePing.ConstructorOptions,
+  );
+
+  override options: PulsePing.ConstructorOptions;
+
+  _color2: Color;
+
+  /**
+   * The radius is half the diameter.
+   * @defaultValue `this.options.size / 2`
+   */
+  _r: number;
+
+  /**
+   * This is the radius that the rings initially begin at. It's set to 1/5th of the maximum radius.
+   * @defaultValue `this._r / 5`
+   */
+  _r0: number;
+
+  /**
+   * Initialize some time slice variables that will be used to control the animation.
+   *
+   * The animation for each ring can be separated into two consecutive stages.
+   * Stage 1: Fade in a white ring with radius r0.
+   * Stage 2: Expand radius outward. While the radius is expanding outward, we have two additional, consecutive
+   * animations:
+   *  Stage 2.1: Transition color from white to the configured color.
+   *  Stage 2.2: Fade out.
+   * 1/5th of the animation time is allocated to Stage 1. 4/5ths are allocated to Stage 2. Of those 4/5ths, 2/5ths
+   * are allocated to Stage 2.1, and 2/5ths are allocated to Stage 2.2.
+   */
+  protected _computeTimeSlices(): void;
+
+  override animate(): Promise<boolean>;
+
+  override _animateFrame(dt: number, animation: CanvasAnimation.AnimationData): void;
+
+  /**
+   * Transition linearly from one color to another.
+   * @param from     - The color to transition from.
+   * @param to       - The color to transition to.
+   * @param duration - The length of the transition in milliseconds.
+   * @param t        - The current time along the duration.
+   * @returns The incremental color between from and to.
+   * @privateRemarks Foundry marked `@private`, and only types the return as `number`, instead of the more accurate `Color`
+   */
+  protected _colorTransition(from: Color, to: Color, duration: number, t: number): Color;
+
+  /**
+   * Draw the shape for this ping.
+   * @param g     - The graphics object to draw to.
+   * @param color - The color of the shape.
+   * @param alpha - The alpha of the shape.
+   * @param size  - The size of the shape to draw.
+   */
+  protected _drawShape(g: PIXI.Graphics, color: number | Color, alpha: number, size: number): void;
+}
+
+declare namespace PulsePing {
+  interface Any extends AnyPulsePing {}
+  interface AnyConstructor extends Identity<typeof AnyPulsePing> {}
+
+  /** @internal */
+  type _ConstructorOptions = InexactPartial<{
+    /**
+     * The number of rings used in the animation.
+     * @defaultValue `3`
+     * @remarks Can't be `null` as it only has a parameter default and a coerced `0` ring count is nonsensical
+     */
+    rings: number;
+
+    /**
+     * The alternate color that the rings begin at. Use white for a 'flashing' effect.
+     * @defaultValue `#ffffff`
+     * @remarks Can't be `null` as it only has a parameter default and `Color(NaN)`s are to be avoided
+     */
+    color2: Color.Source;
+  }>;
+
+  interface ConstructorOptions extends _ConstructorOptions, Ping.ConstructorOptions {}
+}
+
+export default PulsePing;
+
+declare abstract class AnyPulsePing extends PulsePing {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/interaction/render-flags.d.mts

@@ -0,0 +1,182 @@
+import type {
+  AnyConstructor,
+  Coalesce,
+  ConcreteKeys,
+  FixedInstanceType,
+  InexactPartial,
+  MakeConform,
+  Mixin,
+  PhantomConstructor,
+} from "#utils";
+import type { LogCompatibilityWarningOptions } from "#common/utils/logging.d.mts";
+
+declare class RenderFlagObject {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * Configure the render flags used for this class.
+   * @defaultValue `{}`
+   */
+  static RENDER_FLAGS: RenderFlagsMixin.RENDER_FLAGS;
+
+  /**
+   * The ticker priority when RenderFlags of this class are handled.
+   * Valid values are OBJECTS or PERCEPTION.
+   * @defaultValue `"OBJECTS"`
+   */
+  static RENDER_FLAG_PRIORITY: "OBJECTS" | "PERCEPTION";
+
+  /**
+   * Status flags which are applied at render-time to update the PlaceableObject.
+   * If an object defines RenderFlags, it should at least include flags for "redraw" and "refresh".
+   */
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  renderFlags: RenderFlags<{}>;
+
+  /**
+   * Apply any current render flags, clearing the renderFlags set.
+   * Subclasses should override this method to define behavior.
+   */
+  applyRenderFlags(): void;
+}
+
+/**
+ * @privateRemarks Values are marked as optional here based on use, foundry docs incomplete
+ * @internal
+ */
+type _RenderFlag<Keys extends string> = InexactPartial<{
+  /**
+   * Activating this flag also sets these flags to true
+   */
+  propagate: Keys[];
+
+  /**
+   * Activating this flag resets these flags to false
+   */
+  reset: Keys[];
+
+  /**
+   * Is this flag deprecated? The deprecation options are passed to
+   * logCompatibilityWarning. The deprectation message is auto-generated
+   * unless message is passed with the options.
+   * By default the message is logged only once.
+   */
+  deprecated: {
+    message: string;
+  } & LogCompatibilityWarningOptions;
+
+  /**
+   * @remarks Possibly meant to be a sub-property of deprecated,
+   * the runtime check in `RenderFlags##set` looks for this as a top level property
+   */
+  alias: boolean;
+}>;
+
+// Note(LukeAbby): The usage of `ConcreteKeys` is a hazard; if tsc were to become smarter it might
+// notice that `ConcreteKeys<Flags>` is actually contravariant and reject this type. However
+// `RenderFlags` is built upon the assumption this is only used in safe ways.
+declare interface RenderFlag<out Flags extends object, Key extends keyof Flags>
+  extends _RenderFlag<Exclude<Extract<ConcreteKeys<Flags>, string>, Key>> {}
+
+declare namespace RenderFlag {
+  interface Any extends _RenderFlag<string> {}
+}
+
+/**
+ * A data structure for tracking a set of boolean status flags.
+ * This is a restricted set which can only accept flag values which are pre-defined.
+ */
+declare class RenderFlags<Flags extends RenderFlags.ValidateFlags<Flags>> extends Set<string> {
+  /**
+   * @param flags  - An object which defines the flags which are supported for tracking
+   * @param config - Optional configuration
+   */
+  constructor(flags: Flags, config?: RenderFlags.Config);
+
+  readonly flags: Flags;
+
+  readonly object: RenderFlagObject;
+
+  readonly priority: "OBJECT" | "PERCEPTION";
+
+  /**
+   * @returns The flags which were previously set that have been cleared.
+   */
+  clear(): Record<string, boolean>;
+
+  /**
+   * Allow for handling one single flag at a time.
+   * This function returns whether the flag needs to be handled and removes it from the pending set.
+   */
+  handle(flag: string): boolean;
+
+  /**
+   * Activate certain flags, also toggling propagation and reset behaviors
+   * @remarks Flags are only set if `true`, nullish values are discarded
+   */
+  set(changes: Record<string, boolean | undefined | null>): void;
+}
+
+declare namespace RenderFlags {
+  type ValidateFlags<Flags extends object> = {
+    [K in keyof Flags]: MakeConform<Flags[K], _RenderFlag<Extract<Exclude<keyof Flags, K>, string>>>;
+  };
+
+  interface Config {
+    /** The object which owns this RenderFlags instance */
+    object?: RenderFlagObject;
+
+    /**
+     * The update priority when these render flags are applied.
+     * Valid options are OBJECTS or PERCEPTION.
+     * @defaultValue `PIXI.UPDATE_PRIORITY.OBJECTS`
+     */
+    priority?: typeof PIXI.UPDATE_PRIORITY.OBJECTS | typeof PIXI.UPDATE_PRIORITY.PERCEPTION;
+  }
+}
+
+/**
+ * Add RenderFlags functionality to some other object.
+ * This mixin standardizes the interface for such functionality.
+ * @param Base - The base class being mixed: defaults to an anonymous empty class.
+ * @returns The mixed class definition
+ *
+ * @remarks `Base` is normally a PIXI.DisplayObject
+ */
+// Note(LukeAbby): In theory a similar thing to what happens in `CanvasGroupMixin` could be done.
+// That is passing up a generic to instantiate the generic side. However `RenderFlagsMixin` is
+// only inherited directly by `PerceptionManager` and `PlaceableObject`.
+// Therefore it's mostly the subclasses of `PlaceableObject` that face this problem and that can't
+// be solved here unfortunately.
+declare function RenderFlagsMixin<BaseClass extends RenderFlagsMixin.BaseClass | undefined = undefined>(
+  Base?: BaseClass,
+): RenderFlagsMixin.Mix<BaseClass>;
+
+declare namespace RenderFlagsMixin {
+  interface AnyMixedConstructor extends ReturnType<typeof RenderFlagsMixin<BaseClass>> {}
+  interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
+
+  type Mix<BaseClass extends RenderFlagsMixin.BaseClass | undefined> = Mixin<
+    typeof RenderFlagObject,
+    Coalesce<BaseClass, PhantomConstructor>
+  >;
+
+  type BaseClass = AnyConstructor;
+
+  type RENDER_FLAGS = Record<string, RenderFlag.Any>;
+
+  /**
+   * This type exists only to make sure `ToBooleanFlags` isn't a homomorphic mapped type
+   * to avoid keeping documentation.
+   *
+   * @internal
+   */
+  type _KeyOf<T> = keyof T;
+
+  type ToBooleanFlags<RenderFlags extends object> = {
+    [K in _KeyOf<RenderFlags>]?: boolean | null | undefined;
+  };
+}
+
+export { RenderFlags as default, RenderFlagsMixin, RenderFlag };

package/src/foundry/client/canvas/interaction/ruler/base-ruler.d.mts

@@ -0,0 +1,17 @@
+import type { Identity } from "#utils";
+import type { RenderFlagsMixin } from "../render-flags.d.mts";
+
+declare class BaseRuler extends RenderFlagsMixin() {
+  #BaseRuler: true;
+}
+
+declare namespace BaseRuler {
+  interface Any extends AnyBaseRuler {}
+  interface AnyConstructor extends Identity<typeof AnyBaseRuler> {}
+}
+
+export default BaseRuler;
+
+declare abstract class AnyBaseRuler extends BaseRuler {
+  constructor(...args: never);
+}