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

package/src/foundry/client/core/nue.d.ts

@@ -1,34 +0,0 @@
-/**
- * Responsible for managing the New User Experience workflows.
- */
-declare class NewUserExperience {
-  constructor();
-
-  /**
-   * Initialize the new user experience.
-   * Currently, this generates some chat messages with hints for getting started if we detect this is a new world.
-   */
-  initialize(): void;
-
-  /**
-   * Add event listeners to the chat card links.
-   * @param msg  - The ChatMessage being rendered.
-   * @param html - The HTML content of the message.
-   * @internal
-   */
-  protected _activateListeners(msg: ChatMessage, html: JQuery): void;
-
-  /**
-   * Perform some special action triggered by clicking on a link in a NUE chat card.
-   * @param event - The click event.
-   * @internal
-   */
-  protected _onActionLink(event: Event): void;
-
-  /**
-   * Switch to the appropriate tab when a user clicks on a link in the chat message.
-   * @param event - The click event.
-   * @internal
-   */
-  protected _onTabLink(event: Event): void;
-}

package/src/foundry/client/core/settings.d.ts

@@ -1,222 +0,0 @@
-import type { DocumentSubTypes, DocumentType } from '../../../types/helperTypes';
-
-import type { TokenDataSource } from '../../common/data/data.mjs/tokenData';
-
-declare global {
-  /**
-   * A class responsible for managing defined game settings or settings menus.
-   * Each setting is a string key/value pair belonging to a certain package and a certain store scope.
-   *
-   * When Foundry Virtual Tabletop is initialized, a singleton instance of this class is constructed within the global
-   * Game object as as game.settings.
-   *
-   * @see {@link Game#settings}
-   * @see {@link Settings}
-   * @see {@link SettingsConfig}
-   */
-  class ClientSettings {
-    constructor(worldSettings?: Setting['data']['_source'][]);
-
-    /**
-     * A object of registered game settings for this scope
-     */
-    settings: Map<string, SettingConfig>;
-
-    /**
-     * Registered settings menus which trigger secondary applications
-     */
-    menus: Map<string, SettingSubmenuConfig>;
-
-    /**
-     * The storage interfaces used for persisting settings
-     * Each storage interface shares the same API as window.localStorage
-     * @remarks This is a lie, it doesn't actually have the same interface...
-     */
-    storage: Map<string, Storage | WorldSettings>;
-
-    /**
-     * The types of settings which should be constructed as a primitive type
-     */
-    protected static PRIMITIVE_TYPES: [typeof String, typeof Number, typeof Boolean, typeof Array];
-
-    /**
-     * Return a singleton instance of the Game Settings Configuration app
-     */
-    get sheet(): SettingsConfig;
-
-    /**
-     * Register a new game setting under this setting scope
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The key name for the setting under the namespace module
-     * @param data      - Configuration for setting data
-     * @typeParam N     - The namespace under which the setting is registered, as a type
-     * @typeParam K     - The key name for the setting under the namespace module, as a type
-     * @typeParam T     - The type of the setting value
-     *
-     * @example
-     * ```typescript
-     * // Register a client setting
-     * game.settings.register("myModule", "myClientSetting", {
-     *   name: "Register a Module Setting with Choices",
-     *   hint: "A description of the registered setting and its behavior.",
-     *   scope: "client",     // This specifies a client-stored setting
-     *   config: true,        // This specifies that the setting appears in the configuration view
-     *   type: String,
-     *   choices: {           // If choices are defined, the resulting setting will be a select menu
-     *     "a": "Option A",
-     *     "b": "Option B"
-     *   },
-     *   default: "a",        // The default value for the setting
-     *   onChange: value => { // A callback function which triggers when the setting is changed
-     *     console.log(value)
-     *   }
-     * });
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Register a world setting
-     * game.settings.register("myModule", "myWorldSetting", {
-     *   name: "Register a Module Setting with a Range slider",
-     *   hint: "A description of the registered setting and its behavior.",
-     *   scope: "world",      // This specifies a world-level setting
-     *   config: true,        // This specifies that the setting appears in the configuration view
-     *   type: Number,
-     *   range: {             // If range is specified, the resulting setting will be a range slider
-     *     min: 0,
-     *     max: 100,
-     *     step: 10
-     *   }
-     *   default: 50,         // The default value for the setting
-     *   onChange: value => { // A callback function which triggers when the setting is changed
-     *     console.log(value)
-     *   }
-     * });
-     * ```
-     */
-    register<N extends string, K extends string, T>(
-      namespace: N,
-      key: K,
-      data: ClientSettings.Values[`${N}.${K}`] extends string | number | boolean | Array<any> | object
-        ? ClientSettings.PartialSettingConfig<ClientSettings.Values[`${N}.${K}`]>
-        : ClientSettings.PartialSettingConfig<T>
-    ): void;
-
-    /**
-     * Register a new sub-settings menu
-     *
-     * @param namespace - The namespace under which the menu is registered
-     * @param key       - The key name for the setting under the namespace module
-     * @param data      - Configuration for setting data
-     * @typeParam N     - The namespace under which the menu is registered, as a type
-     * @typeParam K     - The key name for the setting under the namespace module, as a type
-     *
-     * @example
-     * ```typescript
-     * // Define a settings submenu which handles advanced configuration needs
-     * game.settings.registerMenu("myModule", "mySettingsMenu", {
-     *   name: "My Settings Submenu",
-     *   label: "Settings Menu Label",      // The text label used in the button
-     *   hint: "A description of what will occur in the submenu dialog.",
-     *   icon: "fas fa-bars",               // A Font Awesome icon used in the submenu button
-     *   type: MySubmenuApplicationClass,   // A FormApplication subclass which should be created
-     *   restricted: true                   // Restrict this submenu to gamemaster only?
-     * });
-     * ```
-     */
-    registerMenu<N extends string, K extends string>(
-      namespace: N,
-      key: K,
-      data: ClientSettings.PartialSettingSubmenuConfig
-    ): void;
-
-    /**
-     * Get the value of a game setting for a certain namespace and setting key
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The setting key to retrieve
-     * @typeParam N     - The namespace under which the setting is registered, as a type
-     * @typeParam K     - The setting key to retrieve, as a type
-     *
-     * @example
-     * ```typescript
-     * // Retrieve the current setting value
-     * game.settings.get("myModule", "myClientSetting");
-     * ```
-     */
-    get<N extends string, K extends string>(namespace: N, key: K): ClientSettings.Values[`${N}.${K}`];
-
-    /**
-     * Set the value of a game setting for a certain namespace and setting key
-     *
-     * @param namespace - The namespace under which the setting is registered
-     * @param key       - The setting key to retrieve
-     * @param value     - The data to assign to the setting key
-     * @typeParam N     - The namespace under which the setting is registered, as a type
-     * @typeParam K     - The setting key to retrieve, as a type
-     * @typeParam V     - The type of the value being set
-     *
-     * @example
-     * ```typescript
-     * // Update the current value of a setting
-     * game.settings.set("myModule", "myClientSetting", "b");
-     * ```
-     */
-    set<N extends string, K extends string, V extends ClientSettings.Values[`${N}.${K}`]>(
-      namespace: N,
-      key: K,
-      value: V
-    ): Promise<V>;
-  }
-
-  namespace ClientSettings {
-    type PartialSettingConfig<T = unknown> = InexactPartial<Omit<SettingConfig<T>, 'key' | 'namespace'>>;
-
-    type PartialSettingSubmenuConfig = Omit<SettingSubmenuConfig, 'key' | 'namespace'>;
-
-    interface Values {
-      'core.animateRollTable': boolean;
-      'core.chatBubbles': boolean;
-      'core.chatBubblesPan': boolean;
-      'core.combatTrackerConfig': { resource: string; skipDefeated: boolean } | {};
-      'core.compendiumConfiguration': Partial<Record<string, CompendiumCollection.Configuration>>;
-      'core.coneTemplateType': 'round' | 'flat';
-      'core.defaultDrawingConfig': foundry.data.DrawingData['_source'] | {};
-      'core.defaultToken': DeepPartial<TokenDataSource>;
-      'core.disableResolutionScaling': boolean;
-      'core.fontSize': number;
-      'core.fpsMeter': boolean;
-      'core.globalAmbientVolume': number;
-      'core.globalInterfaceVolume': number;
-      'core.globalPlaylistVolume': number;
-      'core.keybindings': Record<string, KeybindingActionBinding[]>;
-      'core.language': string;
-      'core.leftClickRelease': boolean;
-      'core.lightAnimation': boolean;
-      'core.maxFPS': number;
-      'core.mipmap': boolean;
-      'core.moduleConfiguration': Record<string, boolean>;
-      'core.noCanvas': boolean;
-      'core.notesDisplayToggle': boolean;
-      'core.nue.shownTips': boolean;
-      'core.performanceMode': boolean;
-      'core.permissions': Game.Permissions;
-      'core.playlist.playingLocation': 'top' | 'bottom';
-      'core.rollMode': keyof CONFIG.Dice.RollModes;
-      'core.rtcClientSettings': typeof AVSettings.DEFAULT_CLIENT_SETTINGS;
-      'core.rtcWorldSettings': typeof AVSettings.DEFAULT_WORLD_SETTINGS;
-      'core.scrollingStatusText': boolean;
-      'core.sheetClasses': {
-        [Key in DocumentType as DocumentSubTypes<Key> extends string ? Key : never]?: Record<
-          DocumentSubTypes<Key> & string,
-          string
-        >;
-      };
-      'core.time': number;
-      'core.tokenDragPreview': boolean;
-      'core.visionAnimation': boolean;
-      [key: string]: unknown;
-    }
-  }
-}

package/src/foundry/client/core/socket.d.ts

@@ -1,46 +0,0 @@
-declare class SocketInterface {
-  /**
-   * Standardize the way that socket messages are dispatched and their results are handled
-   * @param eventName - The socket event name being handled
-   * @param request   - Data provided to the Socket event
-   * @returns A Promise which resolves to the SocketResponse
-   */
-  static dispatch(eventName: string, request: SocketInterface.Request): Promise<SocketInterface.Response>;
-
-  /* -------------------------------------------- */
-
-  /**
-   * Handle an error returned from the database, displaying it on screen and in the console
-   * @param err - The provided Error message
-   */
-  protected static _handleError(err: Error): Error;
-}
-
-declare namespace SocketInterface {
-  namespace Requests {
-    interface ModifyEmbeddedDocument {
-      action: Action;
-      data: any; // TODO: add generics to this
-      options: any;
-      parentId: string;
-      parentType: string;
-      type: string;
-    }
-
-    // TODO: add remaining actions
-    type Action = 'create' | 'update' | 'delete';
-  }
-
-  namespace Responses {
-    interface ModifyEmbeddedDocument {
-      request: Requests.ModifyEmbeddedDocument;
-      result: any[]; // TODO
-      userId: string;
-    }
-  }
-
-  // TODO: go through all SocketInterface.dispatch calls and collect requests
-  type Request = Requests.ModifyEmbeddedDocument;
-
-  type Response = Responses.ModifyEmbeddedDocument;
-}

package/src/foundry/client/core/sorting.d.ts

@@ -1,78 +0,0 @@
-/**
- * A collection of functions related to sorting objects within a parent container.
- */
-declare class SortingHelpers {
-  /**
-   * Given a source object to sort, a target to sort relative to, and an Array of siblings in the container:
-   * Determine the updated sort keys for the source object, or all siblings if a reindex is required.
-   * Return an Array of updates to perform, it is up to the caller to dispatch these updates.
-   * Each update is structured as:
-   * ```typescript
-   * {
-   *   target: object,
-   *   update: {sortKey: sortValue}
-   * }
-   * ```
-   *
-   * @param source     - source object being sorted
-   * @param target     - The target object relative which to sort
-   *                     (default: `null`)
-   * @param siblings   - The sorted Array of siblings which share the same sorted container
-   *                     (default: `[]`)
-   * @param sortKey    - The name of the data property within the source object which defines the sort key
-   *                     (default: `'sort'`)
-   * @param sortBefore - Whether to sort before the target (if true) or after (if false)
-   *                     (default: `true`)
-   * @typeParam T      - the type of the source and target object
-   *
-   * @returns An Array of updates for the caller of the helper function to perform
-   */
-  static performIntegerSort<T, SortKey extends string = 'sort'>(
-    source: T,
-    {
-      target,
-      siblings,
-      sortKey,
-      sortBefore
-    }?: {
-      /**
-       * The target object relative which to sort
-       * @defaultValue `null`
-       */
-      target?: T | null;
-
-      /**
-       * The sorted Array of siblings which share the same sorted container
-       * @defaultValue `[]`
-       */
-      siblings?: T[];
-
-      /**
-       * The name of the data property within the source object which defines the sort key
-       * @defaultValue `'sort'`
-       */
-      sortKey?: SortKey;
-
-      /**
-       * Whether to sort before the target (if true) or after (if false)
-       * @defaultValue `true`
-       */
-      sortBefore?: boolean;
-    }
-  ): Array<{
-    target: T;
-    update: {
-      [Key in SortKey]: number;
-    };
-  }>;
-
-  /**
-   * Given an ordered Array of siblings and a target position, return the [min,max] indices to sort before the target
-   */
-  protected static _sortBefore<T>(siblings: T[], idx: number, sortKey: string): [T, T];
-
-  /**
-   * Given an ordered Array of siblings and a target position, return the [min,max] indices to sort after the target
-   */
-  protected static _sortAfter<T>(siblings: T[], idx: number, sortKey: string): [T, T];
-}

package/src/foundry/client/core/time.d.ts

@@ -1,67 +0,0 @@
-/**
- * A singleton class {@link game#time} which keeps the official Server and World time stamps.
- * Uses a basic implementation of https://www.geeksforgeeks.org/cristians-algorithm/ for synchronization.
- */
-declare class GameTime {
-  constructor(socket?: io.Socket | null);
-
-  /**
-   * The most recently synchronized timestamps retrieved from the server.
-   * @defaultValue `{}`
-   */
-  protected _time: GameTime.Timestamps;
-
-  /**
-   * The average one-way latency across the most recent 5 trips
-   * @defaultValue `0`
-   */
-  protected _dt: number;
-
-  /**
-   * The most recent five synchronization durations
-   * @defaultValue `[]`
-   */
-  protected _dts: number[];
-
-  /**
-   * The amount of time to delay before re-syncing the official server time.
-   * @defaultValue `1000 * 60 * 5`
-   */
-  static SYNC_INTERVAL_MS: number;
-
-  /**
-   * The current server time based on the last synchronization point and the approximated one-way latency.
-   */
-  get serverTime(): number;
-
-  /**
-   * The current World time based on the last recorded value of the core.time setting
-   */
-  get worldTime(): number;
-
-  /**
-   * Advance the game time by a certain number of seconds
-   * @param seconds - The number of seconds to advance (or rewind if negative) by
-   * @returns The new game time
-   */
-  advance(seconds: number): Promise<number>;
-
-  /**
-   * Synchronize the local client game time with the official time kept by the server
-   */
-  sync(socket?: io.Socket | null): Promise<this>;
-
-  /**
-   * Handle follow-up actions when the official World time is changed
-   * @param worldTime - The new canonical World time.
-   */
-  onUpdateWorldTime(worldTime: number): void;
-}
-
-declare namespace GameTime {
-  interface Timestamps {
-    clientTime: number;
-    serverTime: number;
-    worldTime: number;
-  }
-}

package/src/foundry/client/core/utils.d.ts

@@ -1,33 +0,0 @@
-/**
- * Export data content to be saved to a local file
- * @param data     - Data content converted to a string
- * @param type     - The type of
- * @param filename - The filename of the resulting download
- */
-declare function saveDataToFile(data: string, type: string, filename: string): void;
-
-/**
- * Read text data from a user provided File object
- * @param file - A File object
- * @returns A Promise which resolves to the loaded text data
- */
-declare function readTextFromFile(file: File): Promise<string>;
-
-/**
- * Retrieve an Entity or Embedded Entity by its Universally Unique Identifier (uuid).
- * @param uuid - The uuid of the Entity or Embedded Entity to retrieve
- */
-declare function fromUuid(uuid: string): Promise<foundry.abstract.Document<any, any> | null>;
-
-/**
- * Return a reference to the Document class implementation which is configured for use.
- * @param documentName - The canonical Document name, for example "Actor"
- * @returns configured Document class implementation
- */
-declare function getDocumentClass<DocumentName extends string>(
-  documentName: DocumentName
-): DocumentName extends keyof CONFIG
-  ? 'documentClass' extends keyof CONFIG[DocumentName]
-    ? CONFIG[DocumentName]['documentClass']
-    : undefined
-  : undefined;

package/src/foundry/client/core/video.d.ts

@@ -1,65 +0,0 @@
-/**
- * A helper class to provide common functionality for working with HTML5 video objects
- * A singleton instance of this class is available as `game.video`
- */
-declare class VideoHelper {
-  constructor();
-
-  /**
-   * A user gesture must be registered before video playback can begin.
-   * This Set records the video elements which await such a gesture.
-   */
-  pending: Set<HTMLVideoElement>;
-
-  /**
-   * A mapping of base64 video thumbnail images
-   * @defaultValue an empty Map
-   */
-  thumbs: Map<string, string>;
-
-  /**
-   * A flag for whether video playback is currently locked by awaiting a user gesture
-   * @defaultValue `true`
-   */
-  locked: boolean;
-
-  static hasVideoExtension(src: string): boolean;
-
-  /**
-   * Play a single video source
-   * If playback is not yet enabled, add the video to the pending queue
-   * @param video - The VIDEO element to play
-   */
-  play(video: HTMLVideoElement): void;
-
-  /**
-   * Stop a single video source
-   * @param video - The VIDEO element to stop
-   */
-  stop(video: HTMLVideoElement): void;
-
-  /**
-   * Register an event listener to await the first mousemove gesture and begin playback once observed
-   * A user interaction must involve a mouse click or keypress.
-   * Listen for any of these events, and handle the first observed gesture.
-   */
-  awaitFirstGesture(): void;
-
-  /**
-   * Handle the first observed user gesture
-   * We need a slight delay because unfortunately Chrome is stupid and doesn't always acknowledge the gesture fast enough.
-   * @param event - The mouse-move event which enables playback
-   * @internal
-   */
-  protected _onFirstGesture(event: Event): void;
-
-  /**
-   * Create and cache a static thumbnail to use for the video.
-   * The thumbnail is cached using the video file path or URL.
-   * @param src     - The source video URL
-   * @param options - Thumbnail creation options, including width and height
-   * @returns The created and cached base64 thumbnail image, or a placeholder image if the canvas is
-   *          disabled and no thumbnail can be generated.
-   */
-  createThumbnail(src: string, options: ImageHelper.CompositeOptions): Promise<string>;
-}

package/src/foundry/client/data/abstract/canvas-document.d.ts

@@ -1,70 +0,0 @@
-import { ConstructorDataType } from '../../../../types/helperTypes';
-import { ContextType, DocumentModificationOptions } from '../../../common/abstract/document.mjs';
-import { ClientDocumentMixin } from './client-document';
-
-declare global {
-  // TODO: Replace ConstructorOf<…> with DocumentConstructor once the problem with circular reference has been solved
-  /**
-   * A specialized sub-class of the ClientDocumentMixin which is used for document types that are intended to be represented upon the game Canvas.
-   */
-  const CanvasDocumentMixin: <T extends ConstructorOf<foundry.abstract.Document<any, any>>>(
-    Base: T
-  ) => CanvasDocumentConstructor<T>;
-}
-
-type CanvasDocumentConstructor<T extends ConstructorOf<foundry.abstract.Document<any, any>>> = Pick<T, keyof T> &
-  Pick<typeof CanvasDocumentMixin, keyof typeof CanvasDocumentMixin> &
-  Pick<typeof ClientDocumentMixin, keyof typeof ClientDocumentMixin> & {
-    new (...args: ConstructorParameters<T>): InstanceType<T> & CanvasDocumentMixin<InstanceType<T>>;
-  };
-
-declare class CanvasDocumentMixin<T extends foundry.abstract.Document<any, any>> extends ClientDocumentMixin<T> {
-  constructor(data?: ConstructorDataType<T['data']>, context?: ContextType<T>);
-
-  /**
-   * A reference to the PlaceableObject instance which represents this Embedded Document.
-   * @defaultValue `null`
-   */
-  protected _object: PlaceableObject | null; // TODO: Replace with InstanceType<ObjectClass<T>> | null once the circular reference problem has been solved
-
-  /**
-   * Has this object been deliberately destroyed as part of the deletion workflow?
-   * @internal
-   * @defaultValue `false`
-   */
-  protected _destroyed: boolean;
-
-  /**
-   * A lazily constructed PlaceableObject instance which can represent this Document on the game canvas.
-   */
-  get object(): PlaceableObject | null; // TODO: Replace with InstanceType<ObjectClass<T>> | null once the circular reference problem has been solved
-
-  /**
-   * A reference to the CanvasLayer which contains Document objects of this type.
-   */
-  get layer(): PlaceablesLayer<any>; // TODO: Replace with InstanceType<LayerClass<T>> | null once the circular reference problem has been solved
-
-  /**
-   * An indicator for whether this document is currently rendered on the game canvas.
-   */
-  get rendered(): boolean;
-
-  /**
-   * @see abstract.Document#_onCreate
-   */
-  protected _onCreate(data: T['data']['_source'], options: DocumentModificationOptions, userId: string): void;
-
-  /**
-   * @see abstract.Document#_onUpdate
-   */
-  protected _onUpdate(
-    data: DeepPartial<T['data']['_source']>,
-    options: DocumentModificationOptions,
-    userId: string
-  ): void;
-
-  /**
-   * @see abstract.Document#_onDelete
-   */
-  protected _onDelete(options: DocumentModificationOptions, userId: string): void;
-}