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

package/src/foundry/client/pixi/webgl/shaders/samplers/inverse-occlusion.d.mts

@@ -0,0 +1,47 @@
+import type { ConstructorOf } from "../../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A shader used to control channels intensity using an externally provided mask texture.
+   */
+  // @ts-expect-error Foundry overrode the fragmentShader string property with a method that returns a string
+  class InverseOcclusionSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    roof: false,
+     *    vision: false,
+     *    tintAlpha: [1, 1, 1, 1],
+     *    depthElevation: 0,
+     *    sampler: null,
+     *    maskSampler: null,
+     *    alpha: 1.0,
+     *    alphaOcclusion: 1.0,
+     *    screenDimensions: [1, 1],
+     *    pixelRatio: [1, 1]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override vertexShader: string;
+
+    static override fragmentShader(sampleSize: number): string;
+
+    /**
+     * A factory method for creating the shader using its defined default values
+     */
+    static create<T extends InverseOcclusionSamplerShader>(
+      this: ConstructorOf<T>,
+      defaultUniforms?: AbstractBaseShader.Uniforms,
+    ): T;
+
+    protected override _preRender(mesh: SpriteMesh): void;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/invisibility.d.mts

@@ -0,0 +1,28 @@
+export {};
+
+declare global {
+  /**
+   * A shader that alters the source to adopt a translucent color to simulate invisibility.
+   */
+  class TokenInvisibilitySamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static classPluginName: string | null;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tintAlpha: [1, 1, 1, 1],
+     *    sampler: null,
+     *    color: [0.25, 0.35, 1.0],
+     *    alpha: 0.8
+     *  }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/monochromatic.d.mts

@@ -0,0 +1,30 @@
+export {};
+
+declare global {
+  /**
+   * A monochromatic shader
+   */
+  class MonochromaticSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `"monochromatic"`
+     */
+    static classPluginName: string;
+
+    static override batchVertexShader: string;
+
+    static override batchFragmentShader: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tintAlpha: [1, 1, 1, 1],
+     *    sampler: 0,
+     *  }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts

@@ -0,0 +1,69 @@
+export {};
+
+declare global {
+  /**
+   * An occlusion shader to reveal certain area with elevation comparisons.
+   * This shader is also working as a batched plugin.
+   */
+  class OcclusionSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `"occlusion"`
+     */
+    static override classPluginName: string;
+
+    /**
+     * @defaultValue `1`
+     */
+    static reservedTextureUnits: number;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   screenDimensions: [1, 1];
+     *   occlusionTexture: maxTex;
+     * }
+     * ```
+     */
+    static override batchDefaultUniforms(maxTex: AbstractBaseShader.UniformValue): AbstractBaseShader.Uniforms;
+
+    /**
+     * @defaultValue `7`
+     */
+    static override batchVertexSize: number;
+
+    static initializeBatchGeometry(): void;
+
+    protected static override _packInterleavedGeometry(
+      element: PIXI.IBatchableElement,
+      attributeBuffer: PIXI.ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
+
+    static override batchVertexShader: string;
+
+    static override batchFragmentShader: string;
+
+    static override vertexShader: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tintAlpha: [1, 1, 1, 1],
+     *    sampler: null,
+     *    occlusionTexture: null,
+     *    occlusionMode: 0,
+     *    screenDimensions: [1, 1]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    protected override _preRender(mesh: SpriteMesh): void;
+  }
+}

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

@@ -0,0 +1 @@
+import "./texture-worker.d.mts";

package/src/foundry/client/pixi/workers/texture-worker.d.mts

@@ -0,0 +1,125 @@
+export {};
+
+declare global {
+  /**
+   * Wrapper for a web worker meant to convert a pixel buffer to the specified image format
+   * and quality and return a base64 image
+   */
+  class TextureCompressor extends AsyncWorker {
+    /**
+     * @param name   - The worker name to be initialized
+     *                 (default: `"Texture Compressor"`)
+     * @param config - Worker initialization options
+     */
+    constructor(name?: string, config?: TextureCompressor.ConstructorOptions);
+
+    /**
+     * Process the non-blocking image compression to a base64 string.
+     * @param buffer - Buffer used to create the image data.
+     * @param width  - Buffered image width.
+     * @param height - Buffered image height.
+     */
+    compressBufferBase64(
+      buffer: Uint8ClampedArray,
+      width: number,
+      height: number,
+      options?: TextureCompressor.compressBase64Options,
+    ): Promise<unknown>;
+
+    /**
+     * Expand a buffer in RED format to a buffer in RGBA format.
+     * @param buffer - Buffer used to create the image data.
+     * @param width  - Buffered image width.
+     * @param height - Buffered image height.
+     */
+    expandBufferRedToBufferRGBA(
+      buffer: Uint8ClampedArray,
+      width: number,
+      height: number,
+      options?: TextureCompressor.expandRedToRGBAOptions,
+    ): Promise<unknown>;
+
+    /**
+     * Expand a buffer in RED format to a buffer in RGBA format.
+     * @param buffer - Buffer used to create the image data.
+     * @param width  - Buffered image width.
+     * @param height - Buffered image height.
+     */
+    reduceBufferRGBAToBufferRED(
+      buffer: Uint8ClampedArray,
+      width: number,
+      height: number,
+      options?: TextureCompressor.reduceRGBAToRedOptions,
+    ): Promise<unknown>;
+  }
+
+  namespace TextureCompressor {
+    interface ConstructorOptions {
+      /**
+       * Should the worker run in debug mode?
+       * @defaultValue `false`
+       */
+      debug?: boolean;
+
+      /**
+       * @defaultValue `["./workers/image-compressor.js", "./spark-md5.min.js"]`
+       */
+      scripts?: string[];
+
+      /**
+       * @defaultValue `false`
+       */
+      loadPrimitives?: boolean;
+
+      /**
+       * Do we need to control the hash?
+       * @defaultValue `false`
+       */
+      controlHash?: boolean;
+    }
+
+    interface compressBase64Options {
+      /**
+       * The required image type.
+       * @defaultValue `"image/png"`
+       */
+      type?: string;
+
+      /**
+       * The required image quality.
+       * @defaultValue `1`
+       */
+      quality?: number;
+
+      /**
+       * The debug option.
+       * @defaultValue `false`
+       */
+      debug?: boolean;
+
+      readFormat: PIXI.FORMATS;
+    }
+
+    interface expandRedToRGBAOptions {
+      /**
+       * The debug option
+       * @defaultValue `false`
+       */
+      debug: boolean;
+    }
+
+    interface reduceRGBAToRedOptions {
+      /**
+       * The debug option
+       * @defaultValue `false`
+       */
+      debug?: boolean;
+
+      compression: (typeof TextureExtractor)["COMPRESSION_MODES"];
+
+      type: string;
+
+      quality: number;
+    }
+  }
+}

package/src/foundry/client/tours/canvas-tour.d.mts

@@ -0,0 +1,9 @@
+import type { Tour } from "../core/tour.d.mts";
+
+declare global {
+  class CanvasTour extends Tour {
+    override start(): Promise<void>;
+    override get canStart(): boolean;
+    protected override _preStep(): Promise<void>;
+  }
+}

package/src/foundry/client/tours/index.d.mts

@@ -0,0 +1,3 @@
+import "./canvas-tour.d.mts";
+import "./setup-tour.d.mts";
+import "./sidebar-tour.d.mts";

package/src/foundry/client/tours/setup-tour.d.mts

@@ -0,0 +1,26 @@
+import type { Tour } from "../core/tour.d.mts";
+
+declare global {
+  class SetupTour extends Tour {
+    constructor(
+      config: SetupTourConfig,
+      { id, namespace }?: { id?: SetupTourConfig["id"]; namespace?: SetupTourConfig["namespace"] },
+    );
+    config: SetupTourConfig;
+
+    focusedApp: Application.Any;
+    override get canStart(): boolean;
+    override get steps(): TourStep[];
+    protected override _preStep(): Promise<void>;
+    private _installingASystem(): Promise<void>;
+    private _creatingAWorld(): Promise<void>;
+  }
+
+  interface SetupTourConfig extends TourConfig {
+    /**
+     * Whether to close all open windows before beginning the tour.
+     * @defaultValue `true`
+     */
+    closeWindows: boolean;
+  }
+}

package/src/foundry/client/tours/sidebar-tour.d.mts

@@ -0,0 +1,9 @@
+import type { Tour } from "../core/tour.d.mts";
+
+declare global {
+  class SidebarTour extends Tour {
+    override start(): Promise<void>;
+    protected override _preStep(): Promise<void>;
+    _updateSidebarTab(): Promise<void>;
+  }
+}

package/src/foundry/client/ui/context.d.mts

@@ -0,0 +1,213 @@
+import type { InexactPartial } from "../../../types/utils.d.mts";
+import type ApplicationV2 from "../../client-esm/applications/api/application.d.mts";
+
+export {};
+
+declare global {
+  interface ContextMenuEntry {
+    /**
+     * The context menu label. Can be localized.
+     */
+    name: string;
+
+    /**
+     * A string containing an HTML icon element for the menu item
+     */
+    icon: string;
+
+    /**
+     * An identifier for a group this entry belongs to.
+     * @defaultValue `_none`
+     */
+    group?: string | undefined;
+
+    /**
+     * The function to call when the menu item is clicked. Receives the HTML element
+     * of the entry that this context menu is for.
+     */
+    callback: (target: JQuery) => void;
+
+    /**
+     * A function to call or boolean value to determine if this entry
+     * appears in the menu.
+     */
+    condition?: boolean | ((target: JQuery) => boolean) | undefined;
+  }
+
+  /**
+   * @param html      - The HTML element of the context menu entry.
+   * @returns         whether the entry should be rendered in the context menu.
+   */
+  type ContextMenuCondition = (html: JQuery) => boolean;
+
+  namespace ContextMenu {
+    interface RenderOptions {
+      /** The event that triggered the context menu opening. */
+      event: PointerEvent;
+    }
+  }
+
+  /**
+   * Display a right-click activated Context Menu which provides a dropdown menu of options
+   * A ContextMenu is constructed by designating a parent HTML container and a target selector
+   * An Array of menuItems defines the entries of the menu which is displayed
+   */
+  class ContextMenu {
+    /**
+     * @param element   - The containing HTML element within which the menu is positioned
+     * @param selector  - A CSS selector which activates the context menu.
+     * @param menuItems - An Array of entries to display in the menu
+     * @param eventName - Optionally override the triggering event which can spawn the menu
+     *                    (default: `"contextmenu"`)
+     * @param onOpen    - A function to call when the context menu is opened.
+     * @param onClose   - A function to call when the context menu is closed.
+     */
+    constructor(
+      element: JQuery,
+      selector: string | null | undefined,
+      menuItems: ContextMenuEntry[],
+      { hookName, onOpen, onClose }?: ContextMenu.ConstructorOptions,
+    );
+
+    /**
+     * The target HTMLElement being selected
+     */
+    element: JQuery;
+
+    /**
+     * The target CSS selector which activates the menu
+     * @defaultValue `element.attr("id")`
+     */
+    selector: string;
+
+    /**
+     * An interaction event name which activates the menu
+     */
+    eventName: string;
+
+    /**
+     * The array of menu items being rendered
+     */
+    menuItems: ContextMenuEntry[];
+
+    /**
+     * A function to call when the context menu is opened.
+     */
+    onOpen: ContextMenu.ContextMenuCallback;
+
+    /**
+     * A function to call when the context menu is closed.
+     */
+    onClose: ContextMenu.ContextMenuCallback;
+
+    /**
+     * Track which direction the menu is expanded in
+     * @defaultValue `false`
+     */
+    protected _expandUp: boolean;
+
+    /**
+     * A convenience accessor to the context menu HTML object
+     */
+    get menu(): JQuery;
+
+    /**
+     * Create a ContextMenu for this Application and dispatch hooks.
+     * @param app       - The Application this ContextMenu belongs to.
+     * @param html      - The Application's rendered HTML.
+     * @param selector  - The target CSS selector which activates the menu.
+     * @param menuItems - The array of menu items being rendered.
+     * @param options   - Additional options to configure context menu initialization.
+     *                    (default: `"EntryContext"`)
+     */
+    static create(
+      app: Application | ApplicationV2,
+      html: JQuery | HTMLElement,
+      selector: string,
+      menuItems: ContextMenuEntry[],
+      options?: ContextMenu.ConstructorOptions,
+    ): ContextMenu;
+
+    /**
+     * Attach a ContextMenu instance to an HTML selector
+     */
+    bind(): void;
+
+    /**
+     * Closes the menu and removes it from the DOM.
+     * @param options - Options to configure the closing behavior.
+     */
+    close(options?: ContextMenu.CloseOptions | undefined): Promise<void>;
+
+    /** @internal */
+    protected _close(): void;
+
+    /** @internal */
+    protected _animateOpen(menu: JQuery): Promise<void>;
+
+    /** @internal */
+    protected _animateClose(menu: JQuery): Promise<void>;
+
+    /**
+     * Render the Context Menu by iterating over the menuItems it contains
+     * Check the visibility of each menu item, and only render ones which are allowed by the item's logical condition
+     * Attach a click handler to each item which is rendered
+     * @param target        - The target element to which the context menu is attached
+     * @param options       - (default: `{}`)
+     */
+    render(target: JQuery, options?: InexactPartial<ContextMenu.RenderOptions>): void | Promise<JQuery | void>;
+
+    /**
+     * Set the position of the context menu, taking into consideration whether the menu should expand upward or downward
+     * @param html            - The context menu element.
+     * @param target          - The element that the context menu was spawned on.
+     * @param options         - (default: `{}`)
+     */
+    protected _setPosition(html: JQuery, target: JQuery, options?: InexactPartial<ContextMenu.RenderOptions>): void;
+
+    /**
+     * Local listeners which apply to each ContextMenu instance which is created.
+     * @param html - The ContextMenu
+     */
+    activateListeners(html: JQuery): void;
+
+    /**
+     * Global listeners which apply once only to the document.
+     */
+    static eventListeners(): void;
+  }
+
+  namespace ContextMenu {
+    interface CloseOptions {
+      /**
+       * Animate the context menu closing.
+       * @defaultValue `true`
+       */
+      animate?: boolean;
+    }
+
+    type ContextMenuCallback =
+      /**
+       * @param target - The element that the context menu has been triggered for.
+       */
+      (target: HTMLElement) => void;
+
+    interface ConstructorOptions {
+      /**
+       * The name of the hook to call
+       * @defaultValue `EntryContext`
+       */
+      hookName?: string;
+
+      /**
+       * A function to call when the context menu is opened.
+       */
+      onOpen?: ContextMenuCallback;
+
+      /**
+       * A function to call when the context menu is closed.
+       */
+      onClose?: ContextMenuCallback;
+    }
+  }
+}