@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.2-beta

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

@@ -0,0 +1,52 @@
+/**
+ * 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
+ * @param url            - The URL to make the Request to
+ * @param data           - The data of the Request
+ *                         (defalt: `{}`)
+ * @param timeoutOptions - (default: `{}`)
+ * @throws {@link HttpError}
+ */
+export declare function fetchWithTimeout(
+  url: string,
+  data?: RequestInit,
+  { timeoutMs, onTimeout }?: TimeoutOptions,
+): Promise<Response>;
+
+/**
+ * A small wrapper that automatically asks for JSON with a Timeout
+ * @param url            - The URL to make the Request to
+ * @param data           - The data of the Request
+ *                         (defalt: `{}`)
+ * @param timeoutOptions - (default: `{}`)
+ */
+export declare function fetchJsonWithTimeout(
+  url: string,
+  data?: RequestInit,
+  { timeoutMs, onTimeout }?: TimeoutOptions,
+): Promise<unknown>;
+
+/**
+ * Represents an HTTP Error when a non-OK response is returned by Fetch
+ */
+export declare class HttpError extends Error {
+  constructor(statusText: string, code: number, displayMessage?: string);
+
+  code: number;
+
+  displayMessage: string;
+}
+
+interface TimeoutOptions {
+  /**
+   * How long to wait for a Response before cleanly aborting. If null, no timeout is applied
+   * @defaultValue `30000`
+   */
+  timeoutMs?: number | undefined | null;
+
+  /**
+   * A method to invoke if and when the timeout is reached
+   * @defaultValue `() => {}`
+   */
+  onTimeout?: (() => void) | undefined;
+}

package/src/foundry/common/utils/iterable-weak-map.d.mts

@@ -0,0 +1,80 @@
+interface IterableWeakMapHeldValue<K extends WeakKey> {
+  /**
+   * The set to be cleaned.
+   */
+  set: Set<WeakRef<K>>;
+
+  /**
+   * The ref to remove.
+   */
+  ref: WeakRef<K>;
+}
+
+/**
+ * Stores a map of objects with weak references to the keys, allowing them to be garbage collected. Both keys and values
+ * can be iterated over, unlike a WeakMap.
+ * @typeParam K - the type of the keys contained in the IterableWeakMap
+ * @typeParam V - The type of the values contained in the IterableWeakMap
+ */
+declare class IterableWeakMap<K extends WeakKey, V> extends WeakMap<K, V> {
+  /**
+   * @param entries - The initial entries.
+   */
+  constructor(entries?: Iterable<[K, V]>);
+
+  /**
+   * Clean up the corresponding ref in the set when its value is garbage collected.
+   * @param heldValue - The value held by the finalizer.
+   */
+  static #cleanup<K extends WeakKey>(heldValue: IterableWeakMapHeldValue<K>): void;
+
+  /**
+   * Remove a key from the map.
+   * @param key - The key to remove.
+   * @returns `true` if a key was removed, `false` otherwise.
+   */
+  delete(key: K): boolean;
+
+  /**
+   * Retrieve a value from the map.
+   * @param key - The value's key.
+   * @returns
+   */
+  get(key: K): V | undefined;
+
+  /**
+   * Place a value in the map.
+   * @param key   - The key.
+   * @param value - The value.
+   * @returns
+   */
+  set(key: K, value: V): this;
+
+  /**
+   * Enumerate the entries.
+   * @returns
+   */
+  [Symbol.iterator](): Generator<[K, V], void, never>;
+
+  /**
+   * Enumerate the entries.
+   */
+  entries(): Generator<[K, V], void, never>;
+
+  /**
+   * Enumerate the keys.
+   */
+  keys(): Generator<K, void, never>;
+
+  /**
+   * Enumerate the values.
+   */
+  values(): Generator<V, void, never>;
+
+  /**
+   * Clear all values from the map.
+   */
+  clear(): void;
+}
+
+export default IterableWeakMap;

package/src/foundry/common/utils/iterable-weak-set.d.mts

@@ -0,0 +1,47 @@
+/**
+ * Stores a set of objects with weak references to them, allowing them to be garbage collected. Can be iterated over,
+ * unlike a WeakSet.
+ * @typeParam T - The type of the objects contained in the WeakSet
+ */
+declare class IterableWeakSet<T extends WeakKey> extends WeakSet<T> {
+  /**
+   * @param entries - The initial entries.
+   */
+  constructor(entries?: Iterable<T>);
+
+  /**
+   * Enumerate the values.
+   */
+  [Symbol.iterator](): Generator<T, void, never>;
+
+  /**
+   * Add a value to the set.
+   * @param value - The value to add.
+   */
+  add(value: T): this;
+
+  /**
+   * Delete a value from the set.
+   * @param value - The value to delete.
+   */
+  delete(value: T): boolean;
+
+  /**
+   * Whether this set contains the given value.
+   * @param value - The value to test.
+   * @returns
+   */
+  has(value: T): boolean;
+
+  /**
+   * Enumerate the collection.
+   */
+  values(): Generator<T, void, never>;
+
+  /**
+   * Clear all values from the set.
+   */
+  clear(): void;
+}
+
+export default IterableWeakSet;

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

@@ -0,0 +1,42 @@
+import type { COMPATIBILITY_MODES } from "../constants.d.mts";
+
+/**
+ * Log a compatibility warning which is filtered based on the client's defined compatibility settings.
+ * @param message - The original warning or error message
+ * @param options - Additional options which customize logging (default: `{}`)
+ * @throws        - An Error if the mode is ERROR
+ */
+export declare function logCompatibilityWarning(message: string, options?: LogCompatibilityWarningOptions): void;
+export interface LogCompatibilityWarningOptions {
+  /**
+   * A logging level in COMPATIBILITY_MODES which overrides the configured default
+   */
+  mode?: COMPATIBILITY_MODES;
+
+  /**
+   * A version identifier since which a change was made
+   */
+  since?: number | string;
+
+  /**
+   * A version identifier until which a change remains supported
+   */
+  until?: number | string;
+
+  /**
+   * Additional details to append to the logged message
+   */
+  details?: string;
+
+  /**
+   * Include the message stack trace
+   * @defaultValue `true`
+   */
+  stack?: boolean;
+
+  /**
+   * Log this message only once?
+   * @defaultValue `false`
+   */
+  once?: boolean;
+}

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

@@ -0,0 +1,18 @@
+// 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 */
+
+export * from "./geometry.mjs";
+export * from "./helpers.mjs";
+export * from "./http.mjs";
+export * from "./logging.mjs";
+export { default as Collection } from "./collection.mjs";
+export { default as EventEmitterMixin } from "./event-emitter.mjs";
+export { default as IterableWeakSet } from "./iterable-weak-set.mjs";
+export { default as IterableWeakMap } from "./iterable-weak-map.mjs";
+export { default as Color } from "./color.mjs";
+export { default as Semaphore } from "./semaphore.mjs";
+export { default as StringTree } from "./string-tree.mjs";
+export { default as WordTree } from "./word-tree.mjs";
+export { default as BitMask } from "./bitmask.mjs";

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

@@ -0,0 +1,82 @@
+/**
+ * A simple Semaphore implementation which provides a limited queue for ensuring proper concurrency.
+ *
+ * @example Some async function that takes time to execute
+ * ```typescript
+ * function fn(x: string): Promise<string> {
+ *   return new Promise(resolve => {
+ *     setTimeout(() => {
+ *       console.log(x);
+ *       resolve(x);
+ *     }, 1000));
+ *   }
+ * };
+ *
+ * // Create a Semaphore and add many concurrent tasks
+ * const semaphore = new Semaphore(1);
+ * for ( let i of Array.fromRange(100) ) {
+ *   semaphore.add(fn, i);
+ * }
+ * ```
+ */
+declare class Semaphore {
+  /**
+   * @param max - The maximum number of tasks which are allowed concurrently.
+   *              (default: 1)
+   */
+  constructor(max?: number);
+
+  /**
+   * The maximum number of tasks which can be simultaneously attempted.
+   */
+  max: number;
+
+  /**
+   * A queue of pending function signatures
+   * @defaultValue `[]`
+   * @internal
+   * @remarks The first element of an element of `_queue` is always a function and the rest of the elements are
+   * parameters to be passed to that function.
+   */
+  _queue: Array<Array<unknown>>;
+
+  /**
+   * The number of tasks which are currently underway
+   * @defaultValue `0`
+   * @internal
+   */
+  protected _active: number;
+
+  /**
+   * The number of pending tasks remaining in the queue
+   */
+  get remaining(): number;
+
+  /**
+   * The number of actively executing tasks
+   */
+  get active(): number;
+
+  /**
+   * Add a new tasks to the managed queue
+   * @param fn   - A callable function
+   * @param args - Function arguments
+   * @returns A promise that resolves once the added function is executed
+   */
+  add<F extends (...args: any[]) => any>(fn: F, ...args: Parameters<F>): Promise<Awaited<ReturnType<F>>>;
+
+  /**
+   * Abandon any tasks which have not yet concluded
+   */
+  clear(): void;
+
+  /**
+   * Attempt to perform a task from the queue.
+   * If all workers are busy, do nothing.
+   * If successful, try again.
+   * @internal
+   */
+  protected _try(): Promise<false | void>;
+}
+
+export default Semaphore;

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

@@ -0,0 +1,95 @@
+import type { InexactPartial } from "../../../types/utils.d.mts";
+
+/**
+ * A data structure representing a tree of string nodes with arbitrary object leaves.
+ */
+declare class StringTree<EntryType> {
+  /**
+   * The key symbol that stores the leaves of any given node.
+   */
+  // replaced the getter definition with a static property so that
+  //    it can be referenced as part of the StringTreeNode interface
+  // static get leaves(): symbol;
+  static readonly leaves: unique symbol;
+
+  static readonly #leaves: unique symbol;
+
+  /**
+   * Insert an entry into the tree.
+   * @param strings  - The string parents for the entry.
+   * @param entry    - The entry to store.
+   * @returns   The node the entry was added to.
+   */
+  addLeaf(strings: string[], entry: EntryType): StringTree.StringTreeNode;
+
+  /**
+   * Traverse the tree along the given string path and return any entries reachable from the node.
+   * @param strings         - The string path to the desired node.
+   * @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[];
+
+  /**
+   * 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.
+   * @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;
+
+  /**
+   * 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.
+   */
+  protected _breadthFirstSearch(
+    node: StringTree.StringTreeNode,
+    entries: EntryType[],
+    queue: StringTree.StringTreeNode[],
+    options?: InexactPartial<{
+      /** The maximum number of entries to retrieve before stopping. */
+      limit: number;
+    }>,
+  ): void;
+}
+
+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;
+  }
+
+  /**
+   * @param entry   - The entry to filter.
+   * @returns Whether the entry should be included in the result set.
+   */
+  type StringTreeEntryFilter = (entry: unknown) => boolean;
+}
+
+export default StringTree;

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

@@ -0,0 +1,66 @@
+import type { InexactPartial } from "../../../types/utils.d.mts";
+import type StringTree from "./string-tree.d.mts";
+
+/**
+ * A data structure for quickly retrieving objects by a string prefix.
+ * 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> {
+  /**
+   * 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;
+
+  /**
+   * Return entries that match the given string prefix.
+   * @param prefix              - The prefix.
+   * @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[];
+
+  /**
+   * Returns the node at the given prefix.
+   * @param prefix        - The prefix.
+   * @returns The node
+   */
+  nodeAtPrefix(strings: string[], options?: InexactPartial<{ hasLeaves: boolean }>): StringTree.StringTreeNode | void;
+  nodeAtPrefix(prefix: string): WordTree.WordTreeEntry;
+}
+
+declare namespace WordTree {
+  /**
+   * A leaf entry in the tree.
+   */
+  interface WordTreeEntry {
+    /** 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;
+  }
+}
+
+export default WordTree;

package/src/foundry/index.d.mts

@@ -0,0 +1,5 @@
+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/public/index.d.mts

@@ -0,0 +1 @@
+import "./scripts/index.d.mts";

package/src/foundry/public/scripts/earcut-edges/earcut-edges.d.mts

@@ -0,0 +1,11 @@
+export {};
+
+declare global {
+  interface EarcutEdges {
+    (data: number[], holeIndices: number[]): number[];
+    flatten(data: number[][][]): { vertices: number[]; holes: number[]; dimensions: number };
+    deviation(data: number[], holeIndices: number[], dim: number, triangles: number[]): number;
+  }
+
+  const earcut: { earcutEdges: EarcutEdges };
+}

package/src/foundry/public/scripts/earcut-edges/index.d.mts

@@ -0,0 +1 @@
+import "./earcut-edges.d.mts";

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

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

package/src/index.d.mts

@@ -0,0 +1,2 @@
+import "./foundry/index.d.mts";
+import "./types/index.d.mts";

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

@@ -0,0 +1,4 @@
+import "./pixi.d.mts";
+import "./simple-peer.d.mts";
+import "./socket.io-client.d.mts";
+import "./tinyMCE.d.mts";

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

@@ -0,0 +1,99 @@
+import * as _PIXI from "pixi.js";
+import * as pixiParticles from "@pixi/particle-emitter";
+import * as graphicsSmooth from "@pixi/graphics-smooth";
+
+export * from "pixi.js";
+
+/**
+ * Foundry exports PIXI into the global namespace
+ */
+export as namespace PIXI;
+
+declare global {
+  namespace PIXI {
+    export import smooth = graphicsSmooth;
+    export import particles = pixiParticles;
+
+    export class Graphics extends PIXI.smooth.SmoothGraphics {}
+
+    export import BatchGeometry = _PIXI.BatchGeometry;
+
+    namespace BatchGeometry {
+      type AnyConstructor = typeof AnyPIXIBatchGeometry;
+    }
+
+    export import BatchRenderer = _PIXI.BatchRenderer;
+
+    namespace BatchRenderer {
+      type AnyConstructor = typeof AnyPIXIBatchRenderer;
+    }
+
+    export import Container = _PIXI.Container;
+
+    namespace Container {
+      type AnyConstructor = typeof AnyPIXIContainer;
+    }
+
+    export import DisplayObject = _PIXI.DisplayObject;
+
+    namespace DisplayObject {
+      type AnyConstructor = typeof AnyDisplayObject;
+
+      type DestroyOptions = _PIXI.IDestroyOptions | boolean;
+    }
+
+    export import Filter = _PIXI.Filter;
+
+    namespace Filter {
+      type AnyConstructor = typeof AnyPIXIFilter;
+    }
+
+    export import Shader = _PIXI.Shader;
+
+    namespace Shader {
+      type AnyConstructor = typeof AnyPIXIShader;
+    }
+  }
+}
+
+declare module "pixi.js" {
+  export import LegacyGraphics = _PIXI.Graphics;
+
+  export enum UPDATE_PRIORITY {
+    /**
+     * @remarks Foundry defined custom ticker priority
+     * Handled in Canvas##activateTicker
+     */
+    OBJECTS = 23,
+
+    /**
+     * @remarks Foundry defined custom ticker priority
+     * Handled in Canvas##activateTicker
+     */
+    PERCEPTION = 2,
+  }
+}
+
+declare abstract class AnyPIXIBatchGeometry extends PIXI.BatchGeometry {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPIXIBatchRenderer extends PIXI.BatchRenderer {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPIXIContainer extends PIXI.Container {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyDisplayObject extends PIXI.DisplayObject {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPIXIFilter extends PIXI.Filter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPIXIShader extends PIXI.Shader {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/types/augments/simple-peer.d.mts

@@ -0,0 +1,13 @@
+import type * as _SimplePeer from "simple-peer";
+
+declare global {
+  namespace SimplePeer {
+    type Options = _SimplePeer.Options;
+    type SimplePeer = _SimplePeer.SimplePeer;
+    type TypedArray = _SimplePeer.TypedArray;
+    type SimplePeerData = _SimplePeer.SimplePeerData;
+    type SignalData = _SimplePeer.SignalData;
+    type Instance = _SimplePeer.Instance;
+  }
+  const SimplePeer: SimplePeer.SimplePeer;
+}

package/src/types/augments/socket.io-client.d.mts

@@ -0,0 +1,12 @@
+import type * as _io from "socket.io-client";
+
+declare global {
+  // eslint-disable-next-line no-var
+  var io: typeof _io & typeof _io.io & { connect: typeof _io.io };
+  namespace io {
+    type Socket = _io.Socket;
+    type SocketOptions = _io.SocketOptions;
+    type Manager = _io.Manager;
+    type ManagerOptions = _io.ManagerOptions;
+  }
+}