@league-of-foundry-developers/foundry-vtt-types 9.238.1 → 9.249.1

package/src/foundry/common/documents.mjs/baseWall.d.ts

@@ -2,10 +2,24 @@ import { ConfiguredDocumentClass } from '../../../types/helperTypes';
 import { Context, DocumentMetadata } from '../abstract/document.mjs';
 import { Document } from '../abstract/module.mjs';
 import * as data from '../data/data.mjs';
-import type { WallDataConstructorData } from '../data/data.mjs/wallData.js';
+import type { WallDataConstructorData } from '../data/data.mjs/wallData';
 import { BaseScene } from './baseScene';
 import { BaseUser } from './baseUser';
 
+type WallMetadata = Merge<
+  DocumentMetadata,
+  {
+    name: 'Wall';
+    collection: 'walls';
+    label: 'DOCUMENT.Wall';
+    labelPlural: 'DOCUMENT.Walls';
+    isEmbedded: true;
+    permissions: {
+      update: (user: BaseUser, doc: BaseWall, data: DeepPartial<WallDataConstructorData>) => boolean;
+    };
+  }
+>;
+
 /**
  * The base Wall model definition which defines common behavior of an Wall document between both client and server.
  */
@@ -22,22 +36,10 @@ export declare class BaseWall extends Document<data.WallData, InstanceType<Confi
   static get schema(): typeof data.WallData;
 
   /** @override */
-  static get metadata(): Merge<
-    DocumentMetadata,
-    {
-      name: 'Wall';
-      collection: 'walls';
-      label: 'DOCUMENT.Wall';
-      labelPlural: 'DOCUMENT.Walls';
-      isEmbedded: true;
-      permissions: {
-        update: typeof BaseWall._canUpdate;
-      };
-    }
-  >;
+  static get metadata(): WallMetadata;
 
   /**
    * Is a user able to update an existing Wall?
    */
-  protected static _canUpdate(user: BaseUser, doc: BaseWall, data?: Partial<WallDataConstructorData>): boolean;
+  protected static _canUpdate(user: BaseUser, doc: BaseWall, data: DeepPartial<WallDataConstructorData>): boolean;
 }

package/src/foundry/common/packages.mjs/packageAuthorData.d.ts

@@ -37,13 +37,15 @@ interface PackageAuthorDataConstructorData {
   discord?: string | null | undefined;
 }
 
+type PackageAuthorDataSource = PropertiesToSource<PackageAuthorDataProperties>;
+
 /**
  * An inner data object which represents a single package author in the authors array.
  */
 export class PackageAuthorData extends DocumentData<
   PackageAuthorDataSchema,
   PackageAuthorDataProperties,
-  PropertiesToSource<PackageAuthorDataProperties>,
+  PackageAuthorDataSource,
   PackageAuthorDataConstructorData,
   null
 > {

package/src/foundry/common/packages.mjs/packageCompendiumData.d.ts

@@ -62,20 +62,22 @@ interface PackageCompendiumDataConstructorData {
   system?: string | null | undefined;
 }
 
+type PackageCompendiumDataSource = PropertiesToSource<PackageCompendiumDataProperties>;
+
 /**
  * An inner data object which represents a single compendium pack definition provided by a package in the packs array.
  */
 export class PackageCompendiumData extends DocumentData<
   PackageCompendiumDataSchema,
   PackageCompendiumDataProperties,
-  PropertiesToSource<PackageCompendiumDataProperties>,
+  PackageCompendiumDataSource,
   PackageCompendiumDataConstructorData
 > {
   /** @override */
   static defineSchema(): PackageCompendiumDataSchema;
 
   /** @override */
-  _initializeSource(data: PackageCompendiumDataConstructorData): PropertiesToSource<PackageCompendiumDataProperties>;
+  _initializeSource(data: PackageCompendiumDataConstructorData): PackageCompendiumDataSource;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

package/src/foundry/common/packages.mjs/packageData.d.ts

@@ -1,6 +1,6 @@
 import { FieldReturnType, PropertiesToSource } from '../../../types/helperTypes';
 import { DocumentData } from '../abstract/module.mjs';
-import type { PACKAGE_AVAILABILITY_CODES } from '../constants.mjs.js';
+import type { PACKAGE_AVAILABILITY_CODES } from '../constants.mjs';
 import * as fields from '../data/fields.mjs';
 import { PackageAuthorData, PackageAuthorDataConstructorData } from './packageAuthorData';
 import { PackageCompendiumData, PackageCompendiumDataConstructorData } from './packageCompendiumData';
@@ -296,7 +296,6 @@ interface PackageDataConstructorData {
    */
   protected?: boolean | null | undefined;
 }
-
 /**
  * The data schema used to define a Package manifest.
  * Specific types of packages extend this schema with additional fields.
@@ -305,12 +304,12 @@ export class PackageData<
   Schema extends Omit<PackageDataSchema, 'system'>,
   Properties extends Omit<PackageDataProperties, 'system'>,
   ConstructorData extends Omit<PackageDataConstructorData, 'system'>
-> extends DocumentData<Schema, Properties, PropertiesToSource<PackageDataProperties>, ConstructorData> {
+> extends DocumentData<Schema, Properties, PropertiesToSource<Properties>, ConstructorData> {
   /** @override */
   static defineSchema(): Omit<PackageDataSchema, 'system'>;
 
   /** @override */
-  _initializeSource(data: ConstructorData): PropertiesToSource<PackageDataProperties>;
+  _initializeSource(data: ConstructorData): PropertiesToSource<Properties>;
 
   /**
    * Determine the availability a package based on the version numbers of its dependencies.

package/src/foundry/common/packages.mjs/packageDependencyData.d.ts

@@ -43,13 +43,15 @@ interface PackageDependencyDataConstructorData {
   manifest?: string | null | undefined;
 }
 
+type PackageDependencyDataSource = PropertiesToSource<PackageDependencyDataProperties>;
+
 /**
  * An inner data object which represents a single package dependency in the dependencies array.
  */
 export class PackageDependencyData extends DocumentData<
   PackageDependencyDataSchema,
   PackageDependencyDataProperties,
-  PropertiesToSource<PackageDependencyDataProperties>,
+  PackageDependencyDataSource,
   PackageDependencyDataConstructorData
 > {
   /** @override */

package/src/foundry/common/packages.mjs/packageLanguageData.d.ts

@@ -48,13 +48,15 @@ interface PackageLanguageDataConstructorData {
   module?: string | null | undefined;
 }
 
+type PackageLanguageDataSource = PropertiesToSource<PackageLanguageDataProperties>;
+
 /**
  * An inner data object which represents a single language specification provided by a package in the languages array.
  */
 export class PackageLanguageData extends DocumentData<
   PackageLanguageDataSchema,
   PackageLanguageDataProperties,
-  PropertiesToSource<PackageLanguageDataProperties>,
+  PackageLanguageDataSource,
   PackageLanguageDataConstructorData
 > {
   /** @override */

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

@@ -0,0 +1,148 @@
+/**
+ * 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 }[];

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

@@ -258,43 +258,6 @@ export declare function isNewerVersion(v1: number | string, v0: number | string)
  */
 export declare function isObjectEmpty(obj: object): boolean;
 
-/**
- * Update a source object by replacing its keys and values with those from a target object.
- *
- * @param original - The initial object which should be updated with values from the target
- * @param other    - A new object whose values should replace those in the source
- *                   (default: `{}`)
- * @param options  - Additional options which configure the merge
- *                   (default: `{}`)
- * @param _d       - A privately used parameter to track recursion depth.
- *                   (default: `0`)
- * @returns The original source object including updated, inserted, or overwritten records.
- *
- * @example <caption>Control how new keys and values are added</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
- * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Control how existing data is overwritten</caption>
- * ```typescript
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
- * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
- * ```
- *
- * @example <caption>Control whether merges are performed recursively</caption>
- * ```typescript
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
- * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
- * ```
- *
- * @example <caption>Deleting an existing object key</caption>
- * ```typescript
- * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
- * ```
- */
 type OmitByValue<T, ValueType> = { [Key in keyof T as T[Key] extends ValueType ? never : Key]: T[Key] };
 type RemoveNever<T> = OmitByValue<T, never>;
 type PropWithMinus<K> = K extends string ? `-=${K}` : never;
@@ -333,6 +296,43 @@ type WithWidenedArrayTypes<T> = T extends Array<any>
   ? { [K in keyof T]: WithWidenedArrayTypes<T[K]> }
   : T;
 
+/**
+ * Update a source object by replacing its keys and values with those from a target object.
+ *
+ * @param original - The initial object which should be updated with values from the target
+ * @param other    - A new object whose values should replace those in the source
+ *                   (default: `{}`)
+ * @param options  - Additional options which configure the merge
+ *                   (default: `{}`)
+ * @param _d       - A privately used parameter to track recursion depth.
+ *                   (default: `0`)
+ * @returns The original source object including updated, inserted, or overwritten records.
+ *
+ * @example <caption>Control how new keys and values are added</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: false}); // {k1: "v1"}
+ * mergeObject({k1: "v1"}, {k2: "v2"}, {insertKeys: true});  // {k1: "v1", k2: "v2"}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: false}); // {k1: {i1: "v1"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {insertValues: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Control how existing data is overwritten</caption>
+ * ```typescript
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: true}); // {k1: "v2"}
+ * mergeObject({k1: "v1"}, {k1: "v2"}, {overwrite: false}); // {k1: "v1"}
+ * ```
+ *
+ * @example <caption>Control whether merges are performed recursively</caption>
+ * ```typescript
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: false}); // {k1: {i1: "v2"}}
+ * mergeObject({k1: {i1: "v1"}}, {k1: {i2: "v2"}}, {recursive: true}); // {k1: {i1: "v1", i2: "v2"}}
+ * ```
+ *
+ * @example <caption>Deleting an existing object key</caption>
+ * ```typescript
+ * mergeObject({k1: "v1", k2: "v2"}, {"-=k1": null});   // {k2: "v2"}
+ * ```
+ */
 export declare function mergeObject<
   T extends object,
   U extends DeepPartial<WithWidenedArrayTypes<T>>,

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

@@ -1,3 +1,4 @@
+export * from './geometry.mjs';
 export * from './helpers.mjs';
 export { default as Collection } from './collection.mjs';
 export { default as Semaphore } from './semaphore.mjs';

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

@@ -198,6 +198,13 @@ interface NumberConstructor {
    * @returns Is it a number?
    */
   isNumeric(n: unknown): n is number;
+
+  /**
+   * Attempt to create a number from a user-provided string.
+   * @param str - The string.
+   * @returns The number that the string represents, or NaN if no number could be determined.
+   */
+  fromString(str: string): number;
 }
 
 interface ArrayConstructor {