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

package/src/foundry/common/utils/http.d.mts

@@ -1,11 +1,11 @@
 /**
  * A wrapper method around `fetch` that attaches an AbortController signal to the `fetch` call for clean timeouts
- * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal#aborting_a_fetch_with_timeout_or_explicit_abort}
  * @param url            - The URL to make the Request to
  * @param data           - The data of the Request
  *                         (defalt: `{}`)
  * @param timeoutOptions - (default: `{}`)
- * @throws {@link HttpError}
+ * @throws {@link HttpError | `HttpError`}
  */
 export declare function fetchWithTimeout(
   url: string,

package/src/foundry/common/utils/module.d.mts

@@ -1,7 +1,7 @@
 // In Foundry itself this file contains re-exports of these other modules.
 // Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
-// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
-/* eslint-disable import/extensions */
+// While `.mts` could work, to avoid `import-x/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import-x/extensions */
 
 export * from "./geometry.mjs";
 export * from "./helpers.mjs";

package/src/foundry/common/utils/string-tree.d.mts

@@ -1,9 +1,9 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
+import type { AnyObject } from "../../../utils/index.d.mts";
 
 /**
  * A data structure representing a tree of string nodes with arbitrary object leaves.
  */
-declare class StringTree<EntryType> {
+declare class StringTree<Leaf extends object = AnyObject, Key = string[]> {
   /**
    * The key symbol that stores the leaves of any given node.
    */
@@ -20,7 +20,7 @@ declare class StringTree<EntryType> {
    * @param entry    - The entry to store.
    * @returns   The node the entry was added to.
    */
-  addLeaf(strings: string[], entry: EntryType): StringTree.StringTreeNode;
+  addLeaf(strings: Key, entry: Leaf): StringTree.StringTreeNode<Leaf>;
 
   /**
    * Traverse the tree along the given string path and return any entries reachable from the node.
@@ -28,50 +28,32 @@ declare class StringTree<EntryType> {
    * @param options         - Additional options to configure behaviour.
    * @returns    The reachable entries
    */
-  lookup(
-    strings: string[],
-    options?: InexactPartial<{
-      /** The maximum number of items to retrieve. */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): StringTree.StringTreeNode[];
+  lookup(strings: Key, options?: StringTree.LookupOptions): Leaf[];
 
   /**
    * Returns the node at the given path through the tree.
-   * @param strings                     - The string path to the desired node.
-   * @param options                     - Additional options to configure behaviour.
+   * @param strings - The string path to the desired node.
+   * @param options - Additional options to configure behaviour.
    * @returns The node at the path, if found
    */
-  nodeAtPrefix(
-    strings: string[],
-    options?: InexactPartial<{
-      /**
-       * Only return the most recently visited node that has
-       * leaves, otherwise return the exact node at the prefix,
-       * if it exists. Defaults to false.
-       */
-      hasLeaves: boolean;
-    }>,
-  ): StringTree.StringTreeNode | void;
+  nodeAtPrefix<Options extends StringTree.NodeAtPrefixOptions>(
+    strings: Key,
+    options?: Options,
+  ): StringTree.StringTreeNode<Leaf> | void;
 
   /**
    * Perform a breadth-first search starting from the given node and retrieving any entries reachable from that node,
    * until we reach the limit.
-   * @param node            - The starting node.
-   * @param entries         - The accumulated entries.
-   * @param queue           - The working queue of nodes to search.
-   * @param options         - Additional options to configure behaviour.
+   * @param node    - The starting node.
+   * @param entries - The accumulated entries.
+   * @param queue   - The working queue of nodes to search.
+   * @param options - Additional options to configure behaviour.
    */
   protected _breadthFirstSearch(
-    node: StringTree.StringTreeNode,
-    entries: EntryType[],
-    queue: StringTree.StringTreeNode[],
-    options?: InexactPartial<{
-      /** The maximum number of entries to retrieve before stopping. */
-      limit: number;
-    }>,
+    node: StringTree.StringTreeNode<Leaf>,
+    entries: Leaf[],
+    queue: StringTree.StringTreeNode<Leaf>[],
+    options?: StringTree.BreadthFirstSearchOptions,
   ): void;
 }
 
@@ -80,9 +62,9 @@ declare namespace StringTree {
    * A string tree node consists of zero-or-more string keys, and a leaves property that contains any objects that
    * terminate at the current node.
    */
-  interface StringTreeNode {
-    [StringTree.leaves]: Record<string, unknown>[];
-    [key: string]: StringTreeNode;
+  interface StringTreeNode<Leaf extends object> {
+    [StringTree.leaves]: Leaf[];
+    [key: string]: StringTreeNode<Leaf>;
   }
 
   /**
@@ -90,6 +72,30 @@ declare namespace StringTree {
    * @returns Whether the entry should be included in the result set.
    */
   type StringTreeEntryFilter = (entry: unknown) => boolean;
+
+  interface LookupOptions {
+    /** The maximum number of items to retrieve. */
+    limit?: number | undefined;
+
+    /** A filter function to apply to each candidate entry. */
+    filterEntries?: StringTree.StringTreeEntryFilter | undefined;
+  }
+
+  interface NodeAtPrefixOptions {
+    /**
+     * Only return the most recently visited node that has
+     * leaves, otherwise return the exact node at the prefix,
+     * if it exists. Defaults to false.
+     *
+     * @defaultValue `false`
+     */
+    hasLeaves?: boolean | undefined;
+  }
+
+  interface BreadthFirstSearchOptions {
+    /** The maximum number of entries to retrieve before stopping. */
+    limit?: number | undefined;
+  }
 }
 
 export default StringTree;

package/src/foundry/common/utils/word-tree.d.mts

@@ -1,4 +1,3 @@
-import type { InexactPartial } from "../../../types/utils.d.mts";
 import type StringTree from "./string-tree.d.mts";
 
 /**
@@ -6,15 +5,14 @@ import type StringTree from "./string-tree.d.mts";
  * Note that this works well for languages with alphabets (latin, cyrillic, korean, etc.), but may need more nuanced
  * handling for languages that compose characters and letters.
  */
-declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
+declare class WordTree<Key = string> extends StringTree<WordTree.WordTreeEntry, Key> {
   /**
    * Insert an entry into the tree.
    * @param string    - The string key for the entry.
    * @param entry     - The entry to store.
    * @returns         The node the entry was added to.
    */
-  addLeaf(string: string, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode;
-  addLeaf(strings: string[], entry: any): StringTree.StringTreeNode;
+  addLeaf(key: Key, entry: WordTree.WordTreeEntry): StringTree.StringTreeNode<WordTree.WordTreeEntry>;
 
   /**
    * Return entries that match the given string prefix.
@@ -22,29 +20,14 @@ declare class WordTree extends StringTree<WordTree.WordTreeEntry> {
    * @param options             - Additional options to configure behaviour.
    * @returns                   A number of entries that have the given prefix.
    */
-  lookup(
-    prefix: string,
-    options?: InexactPartial<{
-      /**
-       * The maximum number of items to retrieve. It is important
-       * to set this value as very short prefixes will naturally match large numbers
-       * of entries.
-       * (default: `10`)
-       */
-      limit: number;
-      /** A filter function to apply to each candidate entry. */
-      filterEntries?: StringTree.StringTreeEntryFilter | undefined;
-    }>,
-  ): WordTree.WordTreeEntry[];
-  lookup(strings: string[], options?: InexactPartial<{ limit: number }>): StringTree.StringTreeNode[];
+  lookup(prefix: Key, options?: StringTree.LookupOptions): WordTree.WordTreeEntry[];
 
   /**
    * Returns the node at the given prefix.
-   * @param prefix        - The prefix.
+   * @param prefix - The prefix.
    * @returns The node
    */
-  nodeAtPrefix(strings: string[], options?: InexactPartial<{ hasLeaves: boolean }>): StringTree.StringTreeNode | void;
-  nodeAtPrefix(prefix: string): WordTree.WordTreeEntry;
+  nodeAtPrefix(prefix: Key): StringTree.StringTreeNode<WordTree.WordTreeEntry> | void;
 }
 
 declare namespace WordTree {
@@ -52,14 +35,18 @@ declare namespace WordTree {
    * A leaf entry in the tree.
    */
   interface WordTreeEntry {
+    // TODO(LukeAbby): This appears to be possible to be a compendium index entry.
     /** An object that this entry represents. */
     entry: foundry.abstract.Document.Any;
+
     /** The document type. */
     documentName: string;
+
     /** The document's UUID. */
     uuid: string;
+
     /** The (optional) pack ID. */
-    pack?: string;
+    pack?: string | undefined;
   }
 }
 

package/src/foundry/index.d.mts

@@ -1,5 +1,4 @@
 import "./client/index.d.mts";
 import "./client-esm/client.d.mts";
-import "./clipper/index.d.mts";
 import "./common/prosemirror/index.d.mts";
 import "./public/index.d.mts";

package/src/foundry/{clipper → public/scripts/clipper}/clipper.d.mts

@@ -1,4 +1,4 @@
-import type { Brand } from "../../types/helperTypes.d.mts";
+import type { Brand } from "fvtt-types/utils";
 
 declare global {
   namespace ClipperLib {
@@ -110,10 +110,8 @@ declare global {
     let PI2: number;
 
     class IntPoint {
-      constructor(x: number, y: number, z: number);
-      constructor(x: number, y: number);
-      constructor(dp: DoublePoint);
-      constructor();
+      constructor(x: number, y: number, z?: number);
+      constructor(dp?: DoublePoint);
 
       X: number;
       Y: number;
@@ -164,25 +162,54 @@ declare global {
     }
 
     type ClipType = Brand<number, "ClipperLib.ClipType">;
-    const ClipType: Record<"ctIntersection" | "ctUnion" | "ctDifference" | "ctXor", ClipType>;
+    const ClipType: {
+      ctIntersection: 0 & ClipType;
+      ctUnion: 1 & ClipType;
+      ctDifference: 2 & ClipType;
+      ctXor: 3 & ClipType;
+    };
 
     type PolyType = Brand<number, "ClipperLib.PolyType">;
-    const PolyType: Record<"ptSubject" | "ptClip", PolyType>;
+    const PolyType: {
+      ptSubject: 0 & PolyType;
+      ptClip: 1 & PolyType;
+    };
 
     type PolyFillType = Brand<number, "ClipperLib.PolyFillType">;
-    const PolyFillType: Record<"pftEvenOdd" | "pftNonZero" | "pftPositive" | "pftNegative", PolyFillType>;
+    const PolyFillType: {
+      pftEvenOdd: 0 & PolyFillType;
+      pftNonZero: 1 & PolyFillType;
+      pftPositive: 2 & PolyFillType;
+      pftNegative: 3 & PolyFillType;
+    };
 
     type JoinType = Brand<number, "ClipperLib.JoinType">;
-    const JoinType: Record<"jtSquare" | "jtRound" | "jtMiter", JoinType>;
+    const JoinType: {
+      jtSquare: 0 & JoinType;
+      jtRound: 1 & JoinType;
+      jtMiter: 2 & JoinType;
+    };
 
     type EndType = Brand<number, "ClipperLib.EndType">;
-    const EndType: Record<"etOpenSquare" | "etOpenRound" | "etOpenButt" | "etClosedLine" | "etClosedPolygon", EndType>;
+    const EndType: {
+      etOpenSquare: 0 & EndType;
+      etOpenRound: 1 & EndType;
+      etOpenButt: 2 & EndType;
+      etClosedLine: 3 & EndType;
+      etClosedPolygon: 4 & EndType;
+    };
 
     type EdgeSide = Brand<number, "ClipperLib.EdgeSide">;
-    const EdgeSide: Record<"esLeft" | "esRight", EdgeSide>;
+    const EdgeSide: {
+      esLeft: 0 & EdgeSide;
+      esRight: 1 & EdgeSide;
+    };
 
     type Direction = Brand<number, "Direction">;
-    const Direction: Record<"dRightToLeft" | "dLeftToRight", Direction>;
+    const Direction: {
+      dRightToLeft: 0 & Direction;
+      dLeftToRight: 1 & Direction;
+    };
 
     class TEdge {
       Bot: IntPoint;
@@ -362,10 +389,10 @@ declare global {
       protected m_Scanbeam: Scanbeam | null;
 
       /** @defaultValue `null` */
-      protected m_PolyOuts: unknown | null;
+      protected m_PolyOuts: unknown;
 
       /** @defaultValue `null` */
-      protected m_ActiveEdges: unknown | null;
+      protected m_ActiveEdges: unknown;
 
       /**
        * -2^53
@@ -465,7 +492,16 @@ declare global {
     }
 
     class Clipper extends ClipperBase {
-      constructor(InitOptions?: number);
+      constructor(
+        /**
+         * @defaultValue `0`
+         * @remarks Bitmask options:
+         * - `ReverseSolution`:  `0b0000001`
+         * - `StrictlySimple`:   `0b0000010`
+         * - `PreserveColinear`: `0b0000100`
+         */
+        InitOptions?: number | null,
+      );
 
       /** @defaultValue `[]` */
       protected m_PolyOuts: OutRec[];
@@ -748,11 +784,17 @@ declare global {
 
       ClosedPathsFromPolyTree(polytree: PolyTree): Paths;
 
-      static NodeType: Record<"ntAny" | "ntOpen" | "ntClosed", Clipper.NodeType>;
+      static NodeType: Clipper.NodeTypes;
     }
 
     namespace Clipper {
       type NodeType = Brand<number, "ClipperLib.Clipper.NodeType">;
+
+      interface NodeTypes {
+        ntAny: 0 & NodeType;
+        ntOpen: 1 & NodeType;
+        ntClosed: 2 & NodeType;
+      }
     }
 
     class ClipperOffset {

package/src/foundry/public/scripts/index.d.mts

@@ -1 +1,2 @@
 import "./earcut-edges/index.d.mts";
+import "./clipper/index.d.mts";

package/src/foundry/public/scripts/workers/image-compressor.d.mts

@@ -0,0 +1,23 @@
+// eslint-disable-next-line import-x/extensions
+import * as worker from "../../../../types/workers/image-compressor.mjs";
+
+declare global {
+  export import FORMATS = worker.FORMATS;
+  export import Debug = worker.Debug;
+
+  export import ProcessBufferToBase64Options = worker.ProcessBufferToBase64Options;
+  export import ExpandOrReduceBufferOptions = worker.ExpandOrReduceBufferOptions;
+  export import ProcessBufferToBase64Return = worker.ProcessBufferToBase64Return;
+  export import ProcessBufferRedToBufferRGBAReturn = worker.ProcessBufferRedToBufferRGBAReturn;
+  export import ProcessBufferRGBAToBufferREDReturn = worker.ProcessBufferRGBAToBufferREDReturn;
+
+  export import processBufferToBase64 = worker.processBufferToBase64;
+  export import processBufferRedToBufferRGBA = worker.processBufferRedToBufferRGBA;
+  export import processBufferRGBAToBufferRED = worker.processBufferRGBAToBufferRED;
+  export import controlHashes = worker.controlHashes;
+  export import pixelsToOffscreenCanvas = worker.pixelsToOffscreenCanvas;
+  export import offscreenToBase64 = worker.offscreenToBase64;
+  export import blobToBase64 = worker.blobToBase64;
+  export import expandBuffer = worker.expandBuffer;
+  export import reduceBuffer = worker.reduceBuffer;
+}

package/src/foundry/public/scripts/workers/index.d.mts

@@ -0,0 +1 @@
+import "./image-compressor.d.mts";

package/{index-lenient.d.mts → src/index-lenient.d.mts}

@@ -1,3 +1,5 @@
+/* eslint-disable */
+
 import "./index.d.mts";
 
 declare global {

package/src/index.d.mts

@@ -1,2 +1,8 @@
+import "handlebars";
+import "jquery";
+import "pixi.js";
+import "showdown";
+
 import "./foundry/index.d.mts";
 import "./types/index.d.mts";
+import "./configuration/index.d.mts";

package/src/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": [],
+    "outDir": "../.typescript-build/src",
+    "composite": true,
+    "noEmit": false,
+    "emitDeclarationOnly": true
+  },
+  // Note: `**/*` is used to work around a bug with `eslint`. This will be removed once it's fixed.
+  "include": ["index.d.mts", "**/*"],
+  "exclude": ["index-lenient.d.mts"],
+  "references": []
+}

package/src/types/augments/particles.d.mts

@@ -0,0 +1,29 @@
+/* eslint-disable import-x/export */
+
+import type { Brand } from "fvtt-types/utils";
+
+export namespace behaviors {
+  type BehaviorOrder = Brand<number, "PIXI.particles.behaviors.BehaviorOrder">;
+
+  /**
+   * Standard behavior order values, specifying when/how they are used. Other numeric values can be used,
+   * but only the Spawn value will be handled in a special way. All other values will be sorted numerically.
+   * Behaviors with the same value will not be given any specific sort order, as they are assumed to not
+   * interfere with each other.
+   */
+  const BehaviorOrder: {
+    /**
+     * Spawn - initial placement and/or rotation. This happens before rotation/translation due to
+     * emitter rotation/position is applied.
+     */
+    Spawn: 0 & BehaviorOrder;
+
+    /** Normal priority, for things that don't matter when they are applied. */
+    Normal: 2 & BehaviorOrder;
+
+    /** Delayed priority, for things that need to read other values in order to act correctly. */
+    Late: 5 & BehaviorOrder;
+  };
+}
+
+export * from "@pixi/particle-emitter";