@7h3laughingman/foundry-types 13.351.0

package/src/client/documents/user.d.mts

@@ -0,0 +1,148 @@
+import Token from "../canvas/placeables/token.mjs";
+import UserTargets from "../canvas/placeables/tokens/targets.mjs";
+import { DatabaseDeleteCallbackOptions, DatabaseUpdateCallbackOptions } from "./../../common/abstract/_types.mjs";
+import { UserPermission } from "./../../common/constants.mjs";
+import { BaseUser, Macro, TokenDocument, UserUUID } from "./_module.mjs";
+import { ClientDocument, ClientDocumentStatic } from "./abstract/client-document.mjs";
+
+type BaseUserStatic = typeof BaseUser;
+interface ClientBaseUserStatic extends BaseUserStatic, ClientDocumentStatic {}
+
+declare const ClientBaseUser: {
+    new (...args: any): BaseUser & ClientDocument<null>;
+} & ClientBaseUserStatic;
+
+interface ClientBaseUser extends InstanceType<typeof ClientBaseUser> {}
+
+/**
+ * The client-side User document which extends the common BaseUser model.
+ * Each User document contains UserData which defines its data schema.
+ *
+ * @see {@link Users}       The world-level collection of User documents
+ * @see {@link UserConfig} The User configuration application
+ */
+export default class User extends ClientBaseUser {
+    /** Track whether the user is currently active in the game */
+    active: boolean;
+
+    /** Track references to the current set of Tokens which are targeted by the User */
+    targets: UserTargets<Token>;
+
+    /** Track the ID of the Scene that is currently being viewed by the User */
+    viewedScene: string | null;
+
+    /** Track the Token documents that this User is currently moving. */
+    readonly movingTokens: ReadonlySet<TokenDocument>;
+
+    /** A flag for whether the current User is a Trusted Player */
+    get isTrusted(): boolean;
+
+    /** A flag for whether this User is the connected client */
+    get isSelf(): boolean;
+
+    /** Is this User the active GM? */
+    get isActiveGM(): boolean;
+
+    /** A localized label for this User's role. */
+    get roleLabel(): string;
+
+    /** The timestamp of the last observed activity for the user. */
+    get lastActivityTime(): number;
+
+    set lastActivityTime(timestamp: number);
+
+    override prepareDerivedData(): void;
+
+    /* ---------------------------------------- */
+    /*  User Methods                            */
+    /* ---------------------------------------- */
+    /**
+     * Is this User the designated User among the Users that satisfy the given condition?
+     * This function calls {@link foundry.documents.collections.Users#getDesignatedUser} and compares the designated User
+     * to this User.
+     * @example
+     * // Is the current User the designated User to create Tokens?
+     * const isDesignated = game.user.isDesignated(user => user.active && user.can("TOKEN_CREATE"));
+     * @param condition The condition the Users must satisfy
+     * @returns Is designated User?
+     */
+    isDesignated(condition: (user: this) => boolean): boolean;
+
+    /**
+     * Assign a Macro to a numbered hotbar slot between 1 and 50
+     * @param macro      The Macro entity to assign
+     * @param [slot]     A specific numbered hotbar slot to fill
+     * @param [fromSlot] An optional origin slot from which the Macro is being shifted
+     * @return A Promise which resolves once the User update is complete
+     */
+    assignHotbarMacro(macro: Macro | null, slot?: number | string, { fromSlot }?: { fromSlot?: number | undefined }): Promise<this>;
+
+    /**
+     * Assign a specific boolean permission to this user.
+     * Modifies the user permissions to grant or restrict access to a feature.
+     *
+     * @param permission The permission name from USER_PERMISSIONS
+     * @param allowed    Whether to allow or restrict the permission
+     */
+    assignPermission(permission: UserPermission, allowed: boolean): Promise<this | undefined>;
+
+    /**
+     * Submit User activity data to the server for broadcast to other players.
+     * This type of data is transient, persisting only for the duration of the session and not saved to any database.
+     *
+     * @param activityData An object of User activity data to submit to the server for broadcast.
+     * @param activityData.cursor  The coordinates of the user's cursor
+     * @param activityData.focus   Is the user pulling focus to the cursor coordinates?
+     * @param activityData.ping    Is the user emitting a ping at the cursor coordinates?
+     * @param activityData.ruler   Serialized Ruler coordinate data in JSON format
+     * @param activityData.sceneId The id of the Scene currently being viewed by the User
+     * @param activityData.targets An id of Token ids which are targeted by the User
+     */
+    broadcastActivity(activityData?: UserActivity): void;
+
+    /**
+     * Get an Array of Macro Entities on this User's Hotbar by page
+     * @param page The hotbar page number
+     */
+    getHotbarMacros(page?: number): object[];
+
+    /**
+     * Update the set of Token targets for the user given an array of provided Token ids.
+     * @param targetIds An array of Token ids which represents the new target set
+     * @internal
+     */
+    _onUpdateTokenTargets(targetIds?: string[]): void;
+
+    /**
+     * Query this User.
+     * @param queryName The query name (must be registered in `CONFIG.queries`)
+     * @param queryData The query data (must be JSON-serializable)
+     * @param queryOptions The query options
+     * @param queryOptions.timeout The timeout in milliseconds
+     * @returns The query result
+     */
+    query(queryName: string, queryData: object, queryOptions?: { timeout?: number }): Promise<unknown>;
+
+    /* -------------------------------------------- */
+    /*  Event Handlers                              */
+    /* -------------------------------------------- */
+
+    protected override _onUpdate(changed: DeepPartial<this["_source"]>, options: DatabaseUpdateCallbackOptions, userId: string): void;
+
+    protected override _onDelete(options: DatabaseDeleteCallbackOptions, userId: string): void;
+}
+
+export default interface User {
+    get uuid(): UserUUID;
+}
+
+export interface UserActivity {
+    cursor?: object;
+    focus?: boolean;
+    ping?: boolean;
+    ruler?: string;
+    sceneId?: string;
+    target?: string[];
+}
+
+export {};

package/src/client/documents/wall.d.mts

@@ -0,0 +1,20 @@
+import Wall from "../canvas/placeables/wall.mjs";
+import { BaseWall } from "./_module.mjs";
+import { CanvasDocument, CanvasDocumentStatic } from "./abstract/canvas-document.mjs";
+import Scene from "./scene.mjs";
+
+interface CanvasBaseWallStatic extends Omit<typeof BaseWall, "new">, CanvasDocumentStatic {}
+
+declare const CanvasBaseWall: {
+    new <TParent extends Scene | null>(...args: any): BaseWall<TParent> & CanvasDocument<TParent>;
+} & CanvasBaseWallStatic;
+
+interface CanvasBaseWall<TParent extends Scene | null> extends InstanceType<typeof CanvasBaseWall<TParent>> {}
+
+export default class WallDocument<TParent extends Scene | null = Scene | null> extends CanvasBaseWall<TParent> {}
+
+export default interface WallDocument<TParent extends Scene | null = Scene | null> extends CanvasBaseWall<TParent> {
+    get object(): Wall<this> | null;
+}
+
+export {};

package/src/client/game.d.mts

@@ -0,0 +1,231 @@
+import { ReleaseData } from "#common/config.mjs";
+import { Actor, Adventure, Cards, ChatMessage, Combat, Item, JournalEntry, Macro, Playlist, RollTable, Scene, User } from "./documents/_module.mjs";
+import WorldCollection from "./documents/abstract/world-collection.mjs";
+import * as collections from "./documents/collections/_module.mjs";
+import { CompendiumMetadata } from "./documents/collections/compendium-collection.mjs";
+import * as helpers from "./helpers/_module.mjs";
+import * as packages from "./packages/_module.mjs";
+import { Collection } from "./utils/_module.mjs";
+
+/**
+ * The core Game instance which encapsulates the data, settings, and states relevant for managing the game experience.
+ * The singleton instance of the Game class is available as the global variable game.
+ *
+ * @param view      The named view which is active for this game instance.
+ * @param data      An object of all the World data vended by the server when the client first connects
+ * @param sessionId The ID of the currently active client session retrieved from the browser cookie
+ * @param socket    The open web-socket which should be used to transact game-state data
+ */
+export default class Game<
+    TActor extends Actor<null>,
+    TActors extends collections.Actors<TActor>,
+    TChatMessage extends ChatMessage,
+    TCombat extends Combat,
+    TItem extends Item<null>,
+    TMacro extends Macro,
+    TScene extends Scene,
+    TUser extends User,
+> {
+    /**
+     * The named view which is currently active.
+     * Game views include: join, setup, players, license, game, stream
+     */
+    view: string;
+
+    // Undocumented
+    _documentsReady?: boolean;
+
+    /** The object of world data passed from the server */
+    data: {
+        actors: TActor["_source"][];
+        items: TItem["_source"][];
+        macros: TMacro["_source"][];
+        messages: TChatMessage["_source"][];
+        packs: CompendiumMetadata[];
+        tables: foundry.documents.RollTableSource[];
+        users: TUser["_source"][];
+        version: string;
+    };
+
+    /** The game World which is currently active */
+    world: {
+        id: string;
+        title: string;
+    };
+
+    /** Localization support */
+    i18n: helpers.Localization;
+
+    /** The Keyboard Manager */
+    keyboard: helpers.interaction.KeyboardManager;
+
+    /** A mapping of installed modules */
+    modules: Collection<string, packages.Module>;
+
+    /** The user role permissions setting */
+    permissions: Record<string, number[]>;
+
+    /** The client session id which is currently active */
+    sessionId: string;
+
+    /** Client settings which are used to configure application behavior */
+    settings: helpers.ClientSettings;
+
+    /** Client keybindings which are used to configure application behavior */
+    keybindings: helpers.interaction.ClientKeybindings;
+
+    /** A reference to the open Socket.io connection */
+    socket: io.Socket;
+
+    /** A singleton GameTime instance which manages the progression of time within the game world. */
+    time: helpers.GameTime;
+
+    /** The id of the active game user */
+    userId: string;
+
+    /* -------------------------------------------- */
+    /*  Helper Classes                              */
+    /* -------------------------------------------- */
+
+    /** The singleton compendium art manager. */
+    compendiumArt: helpers.media.CompendiumArt;
+
+    /** A singleton instance of the Audio Helper class */
+    audio: foundry.audio.AudioHelper;
+
+    /** A singleton instance of the Video Helper class */
+    video: helpers.media.VideoHelper;
+
+    /** A singleton instance of the TooltipManger class */
+    tooltip: helpers.interaction.TooltipManager;
+
+    /** A singleton instance of the Clipboard Helper class. */
+    clipboard: helpers.interaction.ClipboardHelper;
+
+    /** A singleton instance of the Tours class */
+    tours: foundry.nue.ToursCollection;
+
+    /** The global document index. */
+    documentIndex: helpers.DocumentIndex;
+
+    documentTypes: Record<string, string[]>;
+
+    /** Whether the Game is running in debug mode */
+    debug: boolean;
+
+    /**
+     * A flag for whether texture assets for the game canvas are currently loading
+     */
+    loading: boolean;
+
+    /** A flag for whether the Game has successfully reached the "ready" hook */
+    ready: boolean;
+
+    /** The Release data for this version of Foundry */
+    release: ReleaseData;
+
+    /* -------------------------------------------- */
+    /*  World Collections                           */
+    /* -------------------------------------------- */
+
+    actors: TActors;
+    collections: Collection<string, WorldCollection<TActor | TItem | JournalEntry | TMacro | Playlist | RollTable | TScene>>;
+
+    combats: collections.CombatEncounters<TCombat>;
+    folders: collections.Folders;
+    items: collections.Items<TItem>;
+    journal: collections.Journal;
+    macros: collections.Macros<TMacro>;
+    messages: collections.Messages<TChatMessage>;
+    packs: Collection<string, collections.CompendiumCollection<TActor | Adventure | Cards | TItem | JournalEntry | TMacro | Playlist | RollTable | TScene>>;
+    playlists: collections.Playlists;
+    scenes: collections.Scenes<TScene>;
+    tables: collections.RollTables;
+    users: collections.Users<TUser>;
+
+    constructor(view: string, worldData: object, sessionId: string, socket: io.Socket);
+
+    /** Returns the current version of the Release, usable for comparisons using isNewerVersion */
+    get version(): string;
+
+    /**
+     * Fetch World data and return a Game instance
+     * @return A Promise which resolves to the created Game instance
+     */
+    static create(): Promise<Game<Actor<null>, collections.Actors<Actor<null>>, ChatMessage, Combat, Item<null>, Macro, Scene, User>>;
+
+    /** Request World data from server and return it */
+    static getWorldData(socket: io.Socket): Promise<object>;
+
+    /** Request setup data from server and return it */
+    static getSetupData(socket: io.Socket): Promise<object>;
+
+    /** Initialize the Game for the current window location */
+    initialize(): Promise<void>;
+
+    /** Fully set up the game state, initializing Entities, UI applications, and the Canvas */
+    setupGame(): Promise<void>;
+
+    /** Initialize game state data by creating Collections for all Entity types */
+    initializeEntities(): void;
+
+    /** Initialization actions for compendium packs */
+    initializePacks(config: object): Promise<void>;
+
+    /** Initialize the WebRTC implementation */
+    initializeRTC(): void;
+
+    /** Initialize core UI elements */
+    initializeUI(): void;
+
+    /** Initialize the game Canvas */
+    initializeCanvas(): Promise<void>;
+
+    /** Initialize Keyboard controls */
+    initializeKeyboard(): void;
+
+    /** Initialize Mouse controls */
+    initializeMouse(): void;
+
+    /** Register core game settings */
+    registerSettings(): void;
+
+    /** The currently connected User */
+    get user(): TUser & { active: true };
+
+    /** Metadata regarding the game System which powers this World */
+    get system(): packages.System;
+
+    /** A convenience accessor for the currently active Combat encounter */
+    get combat(): TCombat | null;
+
+    /** A state variable which tracks whether or not the game session is currently paused */
+    get paused(): boolean;
+
+    /** A convenient reference to the currently active canvas tool */
+    get activeTool(): string;
+
+    /** An alias for the structured data model organized by document class and type. */
+    get model(): Record<"Actor" | "Card" | "Cards" | "Item" | "JournalEntryPage", object>;
+
+    /**
+     * Toggle the pause state of the game
+     * Trigger the `pauseGame` Hook when the paused state changes
+     * @param pause The new pause state
+     * @param push  Push the pause state change to other connected clients?
+     */
+    togglePause(pause: boolean, push?: boolean): void;
+
+    static getCookies(): object;
+
+    static clearCookies(): boolean;
+
+    /** Open socket listeners which transact game state data */
+    openSockets(): void;
+
+    /** General game-state socket listeners and event handlers */
+    static socketListeners(socket: io.Socket): void;
+
+    /** Activate Event Listeners which apply to every Game View */
+    activateListeners(): void;
+}

package/src/client/global.d.mts

@@ -0,0 +1,28 @@
+import * as PixiGraphicsSmooth from "@pixi/graphics-smooth";
+import * as PixiParticles from "@pixi/particle-emitter";
+import "handlebars";
+import "jquery";
+import PixiJS from "pixi.js";
+import "showdown";
+import * as SocketIO from "socket.io-client";
+import "../public/scripts/clipper.mjs";
+import * as constants from "./../common/constants.mjs";
+import { TinyMCE as tinymce } from "./../tinymce-stub.mjs";
+import * as globalFoundry from "./client.mjs";
+
+declare module "pixi.js" {
+    export import LegacyGraphics = PixiJS.Graphics;
+    export import smooth = PixiGraphicsSmooth;
+    export import particles = PixiParticles;
+}
+
+declare global {
+    namespace globalThis {
+        export import CONST = constants;
+        export import Hooks = foundry.helpers.Hooks;
+        export import PIXI = PixiJS;
+        export import TinyMCE = tinymce;
+        export import foundry = globalFoundry;
+        export import io = SocketIO;
+    }
+}

package/src/client/helpers/_module.d.mts

@@ -0,0 +1,13 @@
+/** @module helpers */
+
+export * from "./_types.mjs";
+export { default as ClientIssues } from "./client-issues.mjs";
+export { default as ClientSettings } from "./client-settings.mjs";
+export { default as DocumentIndex } from "./document-index.mjs";
+export { Hooks } from "./hooks.mjs";
+export * as interaction from "./interaction/_module.mjs";
+export { default as Localization } from "./localization.mjs";
+export * as media from "./media/_module.mjs";
+export { default as SocketInterface } from "./socket-interface.mjs";
+export { default as GameTime } from "./time.mjs";
+export { AsyncWorker, WorkerManager } from "./workers.mjs";

package/src/client/helpers/_types.d.mts

@@ -0,0 +1,26 @@
+import { ImageFilePath } from "./../../common/constants.mjs";
+
+export interface CompendiumArtInfo {
+    /** The path to the Actor's portrait image. */
+    actor?: ImageFilePath;
+    /** The path to the token image, or an object to merge into the Actor's prototype token. */
+    token?: ImageFilePath | object;
+    /** An optional credit string for use by the game system to apply in an appropriate place. */
+    credit?: string;
+}
+
+/** A mapping of compendium pack IDs to Document IDs to art information. */
+export type CompendiumArtMapping = Record<string, Record<string, CompendiumArtInfo>>;
+
+export interface CompendiumArtDescriptor {
+    /** The ID of the package providing the art. */
+    packageId: string;
+    /** The title of the package providing the art. */
+    title: string;
+    /** The path to the art mapping file. */
+    mapping: string;
+    /** An optional credit string for use by the game system to apply in an appropriate place. */
+    credit?: string;
+    /** The package's user-configured priority. */
+    priority: number;
+}

package/src/client/helpers/client-issues.d.mts

@@ -0,0 +1,90 @@
+import Document from "./../../common/abstract/document.mjs";
+import { DataModelValidationError } from "./../../common/data/validation-failure.mjs";
+import { Setting, WorldDocument } from "./../documents/_module.mjs";
+import WorldCollection from "./../documents/abstract/world-collection.mjs";
+import Module from "./../packages/module.mjs";
+
+/**
+ * An object structure of document types at the top level, with a count of different sub-types for that document type.
+ */
+type ModuleSubTypeCounts = Record<string, Record<string, number>>;
+
+interface PackageCompatibilityIssue {
+    /** Error messages. */
+    error: string[];
+    /** Warning messages. */
+    warning: string[];
+}
+
+interface UsabilityIssue {
+    /** The pre-localized message to display in relation to the usability issue. */
+    message: string;
+    /** The severity of the issue, either "error", "warning", or "info". */
+    severity: string;
+    /** Parameters to supply to the localization. */
+    params?: object;
+}
+
+/**
+ * A class responsible for tracking issues in the current world.
+ */
+export default class ClientIssues {
+    /**
+     * Detect and display warnings for known performance issues which may occur due to the user's hardware or browser
+     * configuration.
+     * @internal
+     */
+    _detectWebGLIssues(): void;
+
+    /**
+     * Add an invalid Document to the module-provided sub-type counts.
+     * @param cls The Document class.
+     * @param source The Document's source data.
+     * @param options.decrement Decrement the counter rather than incrementing it.
+     * @internal
+     */
+    _countDocumentSubType(cls: typeof Document, source: object, options?: { decrement?: boolean }): void;
+
+    /**
+     * Track a validation failure that occurred in a WorldCollection.
+     * @param collection The parent collection.
+     * @param source The Document's source data.
+     * @param error  The validation error.
+     * @internal
+     */
+    _trackValidationFailure(collection: WorldCollection<WorldDocument | Setting>, source: object, error: DataModelValidationError): void;
+
+    /**
+     * Detect and record certain usability error messages which are likely to result in the user having a bad experience.
+     * @internal
+     */
+    _detectUsabilityIssues(): void;
+
+    /**
+     * Get the Document sub-type counts for a given module.
+     * @param module The module or its ID.
+     */
+    getSubTypeCountsFor(module: Module | string): ModuleSubTypeCounts;
+
+    /**
+     * Retrieve all sub-type counts in the world.
+     */
+    getAllSubTypeCounts(): Iterator<string, ModuleSubTypeCounts>;
+
+    /**
+     * Retrieve the tracked validation failures.
+     */
+    get validationFailures(): object;
+
+    /**
+     * Retrieve the tracked usability issues.
+     */
+    get usabilityIssues(): Record<string, UsabilityIssue>;
+
+    /**
+     * Retrieve package compatibility issues.
+     */
+    get packageCompatibilityIssues(): Record<string, PackageCompatibilityIssue>;
+}
+
+export {};