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

package/src/foundry/common/utils/collection.mjs.d.ts

@@ -1,151 +0,0 @@
-interface MapReplacementMembers<K, V> {
-  set(key: K, value: V): this;
-}
-
-type PatchedMap<K, V> = Omit<Map<K, V>, 'forEach' | typeof Symbol.iterator | 'get' | 'set'> &
-  MapReplacementMembers<K, V>;
-
-interface PatchedMapConstructor {
-  new (): PatchedMap<any, any>;
-  new <K, V>(entries?: readonly (readonly [K, V])[] | null): PatchedMap<K, V>;
-  new <K, V>(iterable: Iterable<readonly [K, V]>): PatchedMap<K, V>;
-  readonly [Symbol.species]: PatchedMapConstructor;
-  readonly prototype: PatchedMap<any, any>;
-}
-
-declare const Map: PatchedMapConstructor;
-
-/**
- * A reusable storage concept which blends the functionality of an Array with the efficient key-based lookup of a Map.
- * This concept is reused throughout Foundry VTT where a collection of uniquely identified elements is required.
- * @typeParam T - The type of the objects contained in the Collection
- */
-declare class Collection<T> extends Map<string, T> {
-  constructor(entries?: readonly (readonly [string, T])[] | null);
-
-  /**
-   * When iterating over a Collection, we should iterate over its values instead of over its entries
-   */
-  [Symbol.iterator](): IterableIterator<T>;
-
-  /**
-   * Return an Array of all the entry values in the Collection
-   */
-  get contents(): T[];
-
-  /**
-   * Find an entry in the Map using an functional condition.
-   * @see {@link Array#find}
-   *
-   * @param condition - The functional condition to test
-   * @returns The value, if found, otherwise undefined
-   *
-   * @example
-   * ```typescript
-   * let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
-   * let a = c.find(entry => entry === "A");
-   * ```
-   */
-  find<S extends T>(condition: (e: T) => e is S): S | undefined;
-  find(condition: (e: T) => boolean): T | undefined;
-
-  /**
-   * Filter the Collection, returning an Array of entries which match a functional condition.
-   * @see {@link Array#filter}
-   *
-   * @param condition - The functional condition to test
-   * @returns An Array of matched values
-   *
-   * @example
-   * ```typescript
-   * let c = new Collection([["a", "AA"], ["b", "AB"], ["c", "CC"]]);
-   * let hasA = c.filters(entry => entry.slice(0) === "A");
-   * ```
-   */
-  filter<S extends T>(condition: (e: T) => e is S): S[];
-  filter(condition: (e: T) => boolean): T[];
-
-  /**
-   * Apply a function to each element of the collection
-   * @see Array#forEach
-   * @param fn - The function to apply
-   *
-   * @example
-   * ```typescript
-   * let c = new Collection([["a", {active: false}], ["b", {active: false}], ["c", {active: false}]]);
-   * c.forEach(e => e.active = true);
-   * ```
-   */
-  forEach(fn: (e: T) => void): void;
-
-  /**
-   * Get an element from the Collection by its key.
-   * @param key     - The key of the entry to retrieve
-   * @param strict  - Throw an Error if the requested id does not exist, otherwise
-   *                  (default: `false`)
-   * @returns The retrieved entry value, if the key exists, otherwise undefined
-   * @example
-   * ```typescript
-   * let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
-   * c.get("a"); // "A"
-   * c.get("d"); // null
-   * c.get("d", {strict: true}); // throws Error
-   * ```
-   */
-  get(key: string, { strict }: { strict: true }): T;
-  get(key: string, { strict }?: { strict?: false }): T | undefined;
-
-  /**
-   * Get an entry from the Collection by name.
-   * Use of this method assumes that the objects stored in the collection have a "name" attribute.
-   * @param name    - The name of the entry to retrieve
-   * @param strict  - Throw an Error if the requested id does not exist,
-   *                  otherwise return null.
-   *                  (default: `false`)
-   * @returns The retrieved Entity, if one was found, otherwise undefined
-   */
-  getName(name: string, { strict }: { strict: true }): T;
-  getName(name: string, { strict }?: { strict?: false }): T | undefined;
-
-  /**
-   * Transform each element of the Collection into a new form, returning an Array of transformed values
-   * @param transformer - The transformation function to apply to each entry value
-   * @typeParam M       - The type of the mapped values
-   * @returns An Array of transformed values
-   */
-  map<M>(transformer: (entity: T) => M): M[];
-
-  /**
-   * Reduce the Collection by applying an evaluator function and accumulating entries
-   * @see {@link Array#reduce}
-   * @param evaluator - A function which mutates the accumulator each iteration
-   * @param initial   - An initial value which accumulates with each iteration
-   * @typeParam A     - The type of the accumulator and the return value
-   * @returns The accumulated result
-   *
-   * @example
-   * ```typescript
-   * let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
-   * let letters = c.reduce((s, l) => {
-   *   return s + l;
-   * }, ""); // "ABC"
-   * ```
-   */
-  reduce<A>(evaluator: (accumulator: A, entity: T) => A, initial: A): A;
-
-  /**
-   * Test whether a condition is met by some entry in the Collection
-   * @see Array#some
-   * @param condition - A test condition to apply to each entry
-   * @returns Was the test condition passed by at least one entry?
-   */
-  some(condition: (e: T) => boolean): boolean;
-
-  /**
-   * Convert the Collection to a primitive array of its contents.
-   * @returns An array of contained values
-   */
-  toJSON(): Array<T extends { toJSON: (...args: any[]) => infer U } ? U : T>;
-}
-
-export default Collection;

package/src/foundry/common/utils/geometry.mjs.d.ts

@@ -1,148 +0,0 @@
-/**
- * Determine the relative orientation of three points in two-dimensional space.
- * The result is also an approximation of twice the signed area of the triangle defined by the three points.
- * This method is fast - but not robust against issues of floating point precision. Best used with integer coordinates.
- * Adapted from https://github.com/mourner/robust-predicates
- *
- * @param a - An endpoint of segment AB, relative to which point C is tested
- * @param b - An endpoint of segment AB, relative to which point C is tested
- * @param c - A point that is tested relative to segment AB
- *
- * @returns The relative orientation of points A, B, and C
- *          A positive value if the points are in counter-clockwise order (C lies to the left of AB)
- *          A negative value if the points are in clockwise order (C lies to the right of AB)
- *          Zero if the points A, B, and C are collinear.
- */
-export function orient2dFast(a: Point, b: Point, c: Point): number;
-
-/**
- * Quickly test whether the line segment AB intersects with the line segment CD.
- * This method does not determine the point of intersection, for that use lineLineIntersection
- *
- * @param a - The first endpoint of segment AB
- * @param b - The second endpoint of segment AB
- * @param c - The first endpoint of segment CD
- * @param d - The second endpoint of segment CD
- *
- * @returns Do the line segments intersect?
- */
-export function lineSegmentIntersects(a: Point, b: Point, c: Point, d: Point): boolean;
-
-interface LineIntersection {
-  /** The x-coordinate of intersection */
-  x: number;
-
-  /** The y-coordinate of intersection */
-  y: number;
-
-  /** The vector distance from A to B on segment AB */
-  t0: number;
-
-  /** The vector distance from C to D on segment CD */
-  t1?: number;
-}
-
-/**
- * An internal helper method for computing the intersection between two infinite-length lines.
- * Adapted from http://paulbourke.net/geometry/pointlineplane/
- *
- * @param a - The first endpoint of segment AB
- * @param b - The second endpoint of segment AB
- * @param c - The first endpoint of segment CD
- * @param d - The second endpoint of segment CD
- *
- * @returns An intersection point, or null if no intersection occurred
- */
-export function lineLineIntersection(a: Point, b: Point, c: Point, d: Point): LineIntersection | null;
-
-/**
- * An internal helper method for computing the intersection between two finite line segments.
- * Adapted from http://paulbourke.net/geometry/pointlineplane/
- *
- * @param a       - The first endpoint of segment AB
- * @param b       - The second endpoint of segment AB
- * @param c       - The first endpoint of segment CD
- * @param d       - The second endpoint of segment CD
- * @param epsilon - A small epsilon which defines a tolerance for near-equality
- *                  (default: `1e-8`)
- *
- * @returns An intersection point, or null if no intersection occurred
- */
-export function lineSegmentIntersection(
-  a: Point,
-  b: Point,
-  c: Point,
-  d: Point,
-  epsilon?: number
-): LineIntersection | null;
-
-interface LineCircleIntersection {
-  /** Is point A inside the circle? */
-  aInside: boolean;
-
-  /** Is point B inside the circle? */
-  bInside: boolean;
-
-  /** Is the segment AB contained within the circle? */
-  contained: boolean;
-
-  /** Is the segment AB fully outside the circle? */
-  outside: boolean;
-
-  /** Is the segment AB tangent to the circle? */
-  tangent: boolean;
-
-  /** Intersection points: zero, one, or two */
-  intersections: [number] | [number, number] | [number, number, number];
-}
-
-/**
- * Determine the intersection between a candidate wall and the circular radius of the polygon.
- *
- * @param a       - The initial vertex of the candidate edge
- * @param b       - The second vertex of the candidate edge
- * @param center  - The center of the bounding circle
- * @param radius  - The radius of the bounding circle
- * @param epsilon - A small tolerance for floating point precision
- *                  (default: `1e-8`)
- *
- * @returns The intersection of the segment AB with the circle
- */
-export function lineCircleIntersection(
-  a: Point,
-  b: Point,
-  center: Point,
-  radius: number,
-  epsilon?: number
-): LineCircleIntersection;
-
-/**
- * Identify the point closest to C on segment AB
- *
- * @param c - The reference point C
- * @param a - Point A on segment AB
- * @param b - Point B on segment AB
- *
- * @returns The closest point to C on segment AB
- */
-export function closestPointToSegment(c: Point, a: Point, b: Point): Point;
-
-/**
- * Determine the points of intersection between a line segment (p0,p1) and a circle.
- * There will be zero, one, or two intersections
- * See https://math.stackexchange.com/a/311956
- *
- * @param p0      - The initial point of the line segment
- * @param p1      - The terminal point of the line segment
- * @param center  - The center of the circle
- * @param radius  - The radius of the circle
- * @param epsilon - A small tolerance for floating point precision
- *                  (default: `0`)
- */
-export function quadraticIntersection(
-  p0: Point,
-  p1: Point,
-  center: Point,
-  radius: number,
-  epsilon?: number
-): { x: number; y: number }[];