@league-of-foundry-developers/foundry-vtt-types 9.238.0 → 9.249.0

package/README.md

@@ -17,7 +17,7 @@ TypeScript type definitions for [Foundry Virtual Tabletop](https://foundryvtt.co
 
 We aim to support the latest release of each Foundry VTT version (0.7, 0.8, 9, etc.), starting with 0.7.
 
-At the moment, both version 0.7 and 0.8 are supported. Work on support for version 9 is in progress.
+At the moment, both version 0.7 and 0.8 are fully supported. Version 9 is already partially supported, but there is still a lot to be done. See https://github.com/League-of-Foundry-Developers/foundry-vtt-types/issues?q=is%3Aopen+is%3Aissue+label%3A%22foundry+V9%22 to keep track of the progress.
 
 
 ## Installation
@@ -36,10 +36,10 @@ In order to install a specific version run
 npm install --save-dev @league-of-foundry-developers/foundry-vtt-types@<version>
 ```
 
-For example, to install version `0.8.9-9`, run
+For example, to install version `9.238.0`, run
 
 ```sh
-npm install --save-dev @league-of-foundry-developers/foundry-vtt-types@0.8.9-9
+npm install --save-dev @league-of-foundry-developers/foundry-vtt-types@9.238.0
 ```
 
 You can then update foundry-vtt-types using the regular update mechanism for npm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@league-of-foundry-developers/foundry-vtt-types",
-  "version": "9.238.0",
+  "version": "9.249.0",
   "description": "TypeScript type definitions for Foundry VTT",
   "exports": {
     ".": {

package/src/foundry/common/constants.mjs.d.ts

@@ -721,6 +721,7 @@ export type WALL_DOOR_STATES = ValueOf<typeof WALL_DOOR_STATES>;
  * The wall properties which restrict the way interaction occurs with a specific wall
  */
 export const WALL_RESTRICTION_TYPES: readonly ['light', 'sight', 'sound', 'move'];
+export type WALL_RESTRICTION_TYPES = ValueOf<typeof WALL_RESTRICTION_TYPES>;
 
 /**
  * The types of sensory collision which a Wall may impose

package/src/foundry/common/data/data.mjs/adventureData.d.ts

@@ -2,16 +2,16 @@ import type { PropertiesToSource } from '../../../../types/helperTypes.js';
 import type DocumentData from '../../abstract/data.mjs';
 import { AnyDocumentData } from '../../abstract/data.mjs';
 import * as fields from '../fields.mjs';
-import type { ActorData } from './actorData.js';
-import type { CardsData } from './cardsData.js';
-import type { CombatData } from './combatData.js';
-import type { FolderData } from './folderData.js';
-import type { ItemData } from './itemData.js';
-import type { JournalEntryData } from './journalEntryData.js';
-import type { MacroData } from './macroData.js';
-import type { PlaylistData } from './playlistData.js';
-import type { RollTableData } from './rollTableData.js';
-import type { SceneData } from './sceneData.js';
+import type { ActorData, ActorDataConstructorData } from './actorData.js';
+import type { CardsData, CardsDataConstructorData } from './cardsData.js';
+import type { CombatData, CombatDataConstructorData } from './combatData.js';
+import type { FolderData, FolderDataConstructorData } from './folderData.js';
+import type { ItemData, ItemDataConstructorData } from './itemData.js';
+import type { JournalEntryData, JournalEntryDataConstructorData } from './journalEntryData.js';
+import type { MacroData, MacroDataConstructorData } from './macroData.js';
+import type { PlaylistData, PlaylistDataConstructorData } from './playlistData.js';
+import type { RollTableData, RollTableDataConstructorData } from './rollTableData.js';
+import type { SceneData, SceneDataConstructorData } from './sceneData.js';
 
 interface AdventureDataSchema extends DocumentSchema {
   _id: fields.DocumentId;
@@ -92,34 +92,34 @@ interface AdventureDataConstructorData {
   description?: string | null | undefined;
 
   /** @defaultValue `[]` */
-  actors?: ActorData[] | null | undefined;
+  actors?: ActorDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  combats?: CombatData[] | null | undefined;
+  combats?: CombatDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  items?: ItemData[] | null | undefined;
+  items?: ItemDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  scenes?: SceneData[] | null | undefined;
+  scenes?: SceneDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  journal?: JournalEntryData[] | null | undefined;
+  journal?: JournalEntryDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  tables?: RollTableData[] | null | undefined;
+  tables?: RollTableDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  macros?: MacroData[] | null | undefined;
+  macros?: MacroDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  cards?: CardsData[] | null | undefined;
+  cards?: CardsDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  playlists?: PlaylistData[] | null | undefined;
+  playlists?: PlaylistDataConstructorData[] | null | undefined;
 
   /** @defaultValue `[]` */
-  folders?: FolderData[] | null | undefined;
+  folders?: FolderDataConstructorData[] | null | undefined;
 
   /** @defaultValue `0` */
   sort?: number | null | undefined;
@@ -155,7 +155,7 @@ export class AdventureData extends DocumentData<
 
 /**
  * Property type: `D[]`
- * Constructor type: `D[] | null | undefined`
+ * Constructor type: `ConstructorDataType<D>[] | null | undefined`
  * Default: `[]`
  */
 type AdventureDocumentsField<D extends ConstructorOf<AnyDocumentData>> = DocumentField<D> & {

package/src/foundry/common/data/data.mjs/journalEntryData.d.ts

@@ -62,7 +62,7 @@ interface JournalEntryDataProperties {
   flags: ConfiguredFlags<'JournalEntry'>;
 }
 
-interface JournalEntryConstructorData {
+interface JournalEntryDataConstructorData {
   /**
    * The _id which uniquely identifies this JournalEntry document
    * @defaultValue `null`
@@ -118,10 +118,10 @@ export class JournalEntryData extends DocumentData<
   JournalEntryDataSchema,
   JournalEntryDataProperties,
   PropertiesToSource<JournalEntryDataProperties>,
-  JournalEntryConstructorData,
+  JournalEntryDataConstructorData,
   documents.BaseJournalEntry
 > {
-  constructor(data: JournalEntryConstructorData, document?: documents.BaseJournalEntry | null);
+  constructor(data: JournalEntryDataConstructorData, document?: documents.BaseJournalEntry | null);
 
   /** @override */
   static defineSchema(): JournalEntryDataSchema;

package/src/foundry/common/data/data.mjs/userData.d.ts

@@ -63,9 +63,13 @@ interface UserDataProperties {
   /** The user's name. */
   name: string;
 
-  /** @defaultValue `""` */
+  /**
+   * The user's password. Available only on the Server side for security.
+   * @defaultValue `""`
+   */
   password: string;
 
+  /** The user's password salt. Available only on the Server side for security. */
   passwordSalt: string | undefined;
 
   /**
@@ -113,9 +117,12 @@ interface UserDataConstructorData {
   /** The user's name. */
   name: string;
 
-  /** @defaultValue `""` */
-  password?: string | null | undefined;
+  /**
+   * The user's password. Available only on the Server side for security.
+   * @defaultValue `""`
+   */ password?: string | null | undefined;
 
+  /** The user's password salt. Available only on the Server side for security. */
   passwordSalt?: string | null | undefined;
 
   /**

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

@@ -26,7 +26,7 @@ export declare class BaseCombatant extends Document<
       isEmbedded: true;
       labelPlural: 'DOCUMENT.Combatants';
       permissions: {
-        create: 'PLAYER';
+        create: typeof BaseCombatant._canCreate;
         update: typeof BaseCombatant._canUpdate;
       };
     }
@@ -38,8 +38,6 @@ export declare class BaseCombatant extends Document<
    */
   protected static _canUpdate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
 
-  /**
-   * Is a user able to create this Combatant?
-   */
+  /** Is a user able to create this Combatant? */
   protected static _canCreate(user: BaseUser, doc: BaseCombatant, data?: CombatantDataConstructorData): boolean;
 }

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 {