@7h3laughingman/foundry-types 13.351.0

package/src/client/av/client.d.mts

@@ -0,0 +1,167 @@
+import { AVMaster, AVSettings } from "./_module.mjs";
+
+/**
+ * An interface for an Audio/Video client which is extended to provide broadcasting functionality.
+ */
+export default abstract class AVClient {
+    /**
+     * @param master The master orchestration instance
+     * @param settings The audio/video settings being used
+     */
+    constructor(master: AVMaster, settings: AVSettings);
+
+    /**
+     * The master orchestration instance
+     */
+    master: AVMaster;
+
+    /**
+     * The active audio/video settings being used
+     */
+    settings: AVSettings;
+
+    /**
+     * Is audio broadcasting push-to-talk enabled?
+     */
+    get isVoicePTT(): boolean;
+
+    /**
+     * Is audio broadcasting always enabled?
+     */
+    get isVoiceAlways(): boolean;
+
+    /**
+     * Is audio broadcasting voice-activation enabled?
+     */
+    get isVoiceActivated(): boolean;
+
+    /**
+     * Is the current user muted?
+     */
+    get isMuted(): boolean;
+
+    /* -------------------------------------------- */
+    /*  Connection                                  */
+    /* -------------------------------------------- */
+
+    /**
+     * One-time initialization actions that should be performed for this client implementation.
+     * This will be called only once when the Game object is first set-up.
+     */
+    abstract initialize(): Promise<void>;
+
+    /**
+     * Connect to any servers or services needed in order to provide audio/video functionality.
+     * Any parameters needed in order to establish the connection should be drawn from the settings object.
+     * This function should return a boolean for whether the connection attempt was successful.
+     * @returns Was the connection attempt successful?
+     */
+    abstract connect(): Promise<boolean>;
+
+    /**
+     * Disconnect from any servers or services which are used to provide audio/video functionality.
+     * This function should return a boolean for whether a valid disconnection occurred.
+     * @returns Did a disconnection occur?
+     */
+    abstract disconnect(): Promise<boolean>;
+
+    /* -------------------------------------------- */
+    /*  Device Discovery                            */
+    /* -------------------------------------------- */
+
+    /**
+     * Provide an Object of available audio sources which can be used by this implementation.
+     * Each object key should be a device id and the key should be a human-readable label.
+     */
+    getAudioSinks(): Promise<Record<string, string>>;
+
+    /**
+     * Provide an Object of available audio sources which can be used by this implementation.
+     * Each object key should be a device id and the key should be a human-readable label.
+     */
+    getAudioSources(): Promise<Record<string, string>>;
+
+    /**
+     * Provide an Object of available video sources which can be used by this implementation.
+     * Each object key should be a device id and the key should be a human-readable label.
+     */
+    getVideoSources(): Promise<Record<string, string>>;
+
+    /* -------------------------------------------- */
+    /*  Track Manipulation                          */
+    /* -------------------------------------------- */
+
+    /**
+     * Return an array of Foundry User IDs which are currently connected to A/V.
+     * The current user should also be included as a connected user in addition to all peers.
+     * @returns The connected User IDs
+     */
+    abstract getConnectedUsers(): string[];
+
+    /**
+     * Provide a MediaStream instance for a given user ID
+     * @param userId The User id
+     * @returns The MediaStream for the user, or null if the user does not have one
+     */
+    abstract getMediaStreamForUser(userId: string): MediaStream | null | undefined;
+
+    /**
+     * Provide a MediaStream for monitoring a given user's voice volume levels.
+     * @param userId The User ID.
+     * @returns The MediaStream for the user, or null if the user does not have one.
+     */
+    abstract getLevelsStreamForUser(userId: string): MediaStream | null | undefined;
+
+    /**
+     * Is outbound audio enabled for the current user?
+     */
+    abstract isAudioEnabled(): boolean;
+
+    /**
+     * Is outbound video enabled for the current user?
+     */
+    abstract isVideoEnabled(): boolean;
+
+    /**
+     * Set whether the outbound audio feed for the current game user is enabled.
+     * This method should be used when the user marks themselves as muted or if the gamemaster globally mutes them.
+     * @param enable Whether the outbound audio track should be enabled (true) or disabled (false)
+     */
+    abstract toggleAudio(enable: boolean): void;
+
+    /**
+     * Set whether the outbound audio feed for the current game user is actively broadcasting.
+     * This can only be true if audio is enabled, but may be false if using push-to-talk or voice activation modes.
+     * @param broadcast Whether outbound audio should be sent to connected peers or not?
+     */
+    abstract toggleBroadcast(broadcast: boolean): void;
+
+    /**
+     * Set whether the outbound video feed for the current game user is enabled.
+     * This method should be used when the user marks themselves as hidden or if the gamemaster globally hides them.
+     * @param enable Whether the outbound video track should be enabled (true) or disabled (false)
+     */
+    abstract toggleVideo(enable: boolean): void;
+
+    /**
+     * Set the Video Track for a given User ID to a provided VideoElement
+     * @param userId The User ID to set to the element
+     * @param videoElement The HTMLVideoElement to which the video should be set
+     */
+    abstract setUserVideo(userId: string, videoElement: HTMLVideoElement): Promise<void>;
+
+    /* -------------------------------------------- */
+    /*  Settings and Configuration                  */
+    /* -------------------------------------------- */
+
+    /**
+     * Handle changes to A/V configuration settings.
+     * @param changed The settings which have changed
+     */
+    onSettingsChanged(changed: object): void;
+
+    /**
+     * Replace the local stream for each connected peer with a re-generated MediaStream.
+     */
+    abstract updateLocalStream(): Promise<void>;
+}

package/src/client/av/clients/_module.d.mts

@@ -0,0 +1 @@
+export { default as SimplePeerAVClient } from "./simplepeer.mjs";

package/src/client/av/clients/simplepeer.d.mts

@@ -0,0 +1,123 @@
+import { SimplePeer } from "simple-peer";
+import AVClient from "../client.mjs";
+
+/**
+ * An implementation of the AVClient which uses the simple-peer library and the Foundry socket server for signaling.
+ * Credit to bekit#4213 for identifying simple-peer as a viable technology and providing a POC implementation.
+ * @extends {AVClient}
+ */
+export default class SimplePeerAVClient extends AVClient {
+    /**
+     * The local Stream which captures input video and audio
+     */
+    localStream: MediaStream | null;
+
+    /**
+     * The dedicated audio stream used to measure volume levels for voice activity detection.
+     */
+    levelsStream: MediaStream | null;
+
+    /**
+     * A mapping of connected peers
+     */
+    peers: Map<string, SimplePeer>;
+
+    /**
+     * A mapping of connected remote streams
+     */
+    remoteStreams: Map<string, MediaStream>;
+
+    /**
+     * Is outbound broadcast of local audio enabled?
+     */
+    audioBroadcastEnabled: boolean;
+
+    /* -------------------------------------------- */
+    /*  Required AVClient Methods                   */
+    /* -------------------------------------------- */
+
+    override connect(): Promise<true>;
+
+    override disconnect(): Promise<true>;
+
+    override initialize(): Promise<void>;
+
+    override getConnectedUsers(): string[];
+
+    override getMediaStreamForUser(userId: string): MediaStream | null | undefined;
+
+    override getLevelsStreamForUser(userId: string): MediaStream | null | undefined;
+
+    override isAudioEnabled(): boolean;
+
+    override isVideoEnabled(): boolean;
+
+    override toggleAudio(enabled: boolean): void;
+
+    override toggleBroadcast(enabled: boolean): void;
+
+    override toggleVideo(enabled: boolean): void;
+
+    override setUserVideo(userId: string, videoElement: HTMLVideoElement): Promise<void>;
+
+    /* -------------------------------------------- */
+    /*  Local Stream Management                     */
+    /* -------------------------------------------- */
+
+    /**
+     * Initialize a local media stream for the current user
+     */
+    initializeLocalStream(): Promise<MediaStream>;
+
+    /* -------------------------------------------- */
+    /*  Peer Stream Management                      */
+    /* -------------------------------------------- */
+
+    /**
+     * Listen for Audio/Video updates on the av socket to broker connections between peers
+     */
+    activateSocketListeners(): void;
+
+    /**
+     * Initialize a stream connection with a new peer
+     * @param userId The Foundry user ID for which the peer stream should be established
+     * @returns A Promise which resolves once the peer stream is initialized
+     */
+    initializePeerStream(userId: string): Promise<SimplePeer>;
+
+    /**
+     * Receive a request to establish a peer signal with some other User id
+     * @param userId The Foundry user ID who is requesting to establish a connection
+     * @param data The connection details provided by SimplePeer
+     */
+    receiveSignal(userId: string, data: object): void;
+
+    /**
+     * Connect to a peer directly, either as the initiator or as the receiver
+     * @param userId The Foundry user ID with whom we are connecting
+     * @param isInitiator Is the current user initiating the connection, or responding to it?
+     * @returns The constructed and configured SimplePeer instance
+     */
+    connectPeer(userId: string, isInitiator?: boolean): SimplePeer;
+
+    /**
+     * Disconnect from a peer by stopping current stream tracks and destroying the SimplePeer instance
+     * @param {string} userId           The Foundry user ID from whom we are disconnecting
+     * @returns {Promise<void>}         A Promise which resolves once the disconnection is complete
+     */
+    disconnectPeer(userId: string): Promise<void>;
+
+    /**
+     * Disconnect from all current peer streams
+     * @returns A Promise which resolves once all peers have been disconnected
+     */
+    disconnectAll(): Promise<unknown[]>;
+
+    /* -------------------------------------------- */
+    /*  Settings and Configuration                  */
+    /* -------------------------------------------- */
+
+    override onSettingsChanged(changed: object): Promise<void>;
+
+    override updateLocalStream(): Promise<void>;
+}

package/src/client/av/master.d.mts

@@ -0,0 +1,128 @@
+import { KeyboardEventContext } from "./../_types.mjs";
+
+/**
+ * The master Audio/Video controller instance.
+ * This is available as the singleton game.webrtc
+ */
+export default class AVMaster {
+    constructor();
+
+    get mode(): string;
+
+    /* -------------------------------------------- */
+    /*  Initialization                              */
+    /* -------------------------------------------- */
+
+    /**
+     * Connect to the Audio/Video client.
+     * @returns Was the connection attempt successful?
+     */
+    connect(): Promise<boolean>;
+
+    /**
+     * Disconnect from the Audio/Video client.
+     * @returns Whether an existing connection was terminated?
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Callback actions to take when the user becomes disconnected from the server.
+     */
+    reestablish(): Promise<void>;
+
+    /* -------------------------------------------- */
+    /*  Permissions                                 */
+    /* -------------------------------------------- */
+
+    /**
+     * A user can broadcast audio if the AV mode is compatible and if they are allowed to broadcast.
+     * @param userId
+     */
+    canUserBroadcastAudio(userId: string): boolean | undefined;
+
+    /**
+     * A user can share audio if they are allowed to broadcast and if they have not muted themselves or been blocked.
+     * @param userId
+     */
+    canUserShareAudio(userId: string): boolean;
+
+    /**
+     * A user can broadcast video if the AV mode is compatible and if they are allowed to broadcast.
+     * @param userId
+     */
+    canUserBroadcastVideo(userId: string): boolean | undefined;
+
+    /* -------------------------------------------- */
+
+    /**
+     * A user can share video if they are allowed to broadcast and if they have not hidden themselves or been blocked.
+     */
+    canUserShareVideo(userId: string): boolean | undefined;
+
+    /* -------------------------------------------- */
+    /*  Broadcasting                                */
+    /* -------------------------------------------- */
+
+    /**
+     * Trigger a change in the audio broadcasting state when using a push-to-talk workflow.
+     * @param intent The user's intent to broadcast. Whether an actual broadcast occurs will depend on whether or not
+     *               the user has muted their audio feed.
+     */
+    broadcast(intent: boolean): void;
+
+    /**
+     * Set up audio level listeners to handle voice activation detection workflow.
+     * @param mode The currently selected voice broadcasting mode
+     * @internal
+     */
+    _initializeUserVoiceDetection(mode: string): void;
+
+    /**
+     * Activate voice detection tracking for a userId on a provided MediaStream.
+     * Currently only a MediaStream is supported because MediaStreamTrack processing is not yet supported cross-browser.
+     * @param stream The MediaStream which corresponds to that User
+     * @param ms A number of milliseconds which represents the voice activation volume interval
+     */
+    activateVoiceDetection(stream: MediaStream, ms: number): void;
+
+    /**
+     * Actions which the orchestration layer should take when a peer user disconnects from the audio/video service.
+     */
+    deactivateVoiceDetection(): void;
+
+    /* -------------------------------------------- */
+    /*  Push-To-Talk Controls                       */
+    /* -------------------------------------------- */
+
+    /**
+     * Handle activation of a push-to-talk key or button.
+     * @param context The context data of the event
+     * @internal
+     */
+    _onPTTStart(context: KeyboardEventContext): boolean;
+
+    /**
+     * Handle deactivation of a push-to-talk key or button.
+     * @param context The context data of the event
+     * @internal
+     */
+    _onPTTEnd(context: KeyboardEventContext): boolean;
+
+    /* -------------------------------------------- */
+    /*  User Interface Controls                     */
+    /* -------------------------------------------- */
+
+    render(): Promise<this>;
+
+    /* -------------------------------------------- */
+    /*  Events Handlers and Callbacks               */
+    /* -------------------------------------------- */
+
+    /**
+     * Respond to changes which occur to AV Settings.
+     * Changes are handled in descending order of impact.
+     * @param changed The object of changed AV settings
+     */
+    onSettingsChanged(changed: Record<string, unknown>): void;
+
+    debug(message: string): void;
+}

package/src/client/av/settings.d.mts

@@ -0,0 +1,100 @@
+import * as fields from "./../../common/data/fields.mjs";
+
+interface AVSettingsData {
+    /** Whether this user has muted themselves. */
+    muted?: boolean;
+    /** Whether this user has hidden their video. */
+    hidden?: boolean;
+    /** Whether the user is broadcasting audio. */
+    speaking?: boolean;
+}
+
+export default class AVSettings {
+    constructor();
+
+    /**
+     * WebRTC Mode, Disabled, Audio only, Video only, Audio & Video
+     */
+    static AV_MODES: {
+        DISABLED: 0;
+        AUDIO: 1;
+        VIDEO: 2;
+        AUDIO_VIDEO: 3;
+    };
+
+    /**
+     * Voice modes: Always-broadcasting, voice-level triggered, push-to-talk.
+     */
+    static VOICE_MODES: {
+        ALWAYS: "always";
+        ACTIVITY: "activity";
+        PTT: "ptt";
+    };
+
+    /**
+     * Displayed nameplate options: Off entirely, animate between player and character name, player name only, character
+     * name only.
+     */
+    static NAMEPLATE_MODES: {
+        OFF: 0;
+        BOTH: 1;
+        PLAYER_ONLY: 2;
+        CHAR_ONLY: 3;
+    };
+
+    /**
+     * AV dock positions.
+     */
+    static DOCK_POSITIONS: {
+        TOP: "top";
+        RIGHT: "right";
+        BOTTOM: "bottom";
+        LEFT: "left";
+    };
+
+    /**
+     * Schemas for world and client settings
+     */
+    static get schemaFields(): { world: fields.SchemaField; client: fields.SchemaField };
+
+    /**
+     * Default client settings for each connected user.
+     */
+    static get DEFAULT_USER_SETTINGS(): object;
+
+    /**
+     * Register world and client WebRTC settings.
+     */
+    static register(): void;
+
+    /**
+     * A debounce callback for when either the world or client settings change.
+     */
+    changed: () => void;
+
+    /**
+     * Stores the transient AV activity data received from other users.
+     */
+    activity: Record<string, AVSettingsData>;
+
+    get(scope: string, setting: string): unknown;
+
+    getUser(userId: string): object | null;
+
+    set(scope: string, setting: string, value: unknown): void;
+
+    /**
+     * Return a mapping of AV settings for each game User.
+     */
+    get users(): Record<string, object>;
+
+    /**
+     * A helper to determine if the dock is configured in a vertical position.
+     */
+    get verticalDock(): boolean;
+
+    /**
+     * Handle another connected user changing their AV settings.
+     */
+    handleUserActivity(userId: string, settings: AVSettingsData): void;
+}

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

@@ -0,0 +1,20 @@
+/** @module canvas */
+
+export * as animation from "./animation/_module.mjs";
+export { default as Canvas } from "./board.mjs";
+export * as containers from "./containers/_module.mjs";
+export * as extensions from "./extensions/_module.mjs";
+export { default as FramebufferSnapshot } from "./framebuffer-snapshot.mjs";
+export * as geometry from "./geometry/_module.mjs";
+export * as groups from "./groups/_module.mjs";
+export * as interaction from "./interaction/_module.mjs";
+export * as layers from "./layers/_module.mjs";
+export { default as TextureLoader, getTexture, loadTexture, srcExists } from "./loader.mjs";
+export * as perception from "./perception/_module.mjs";
+export * as placeables from "./placeables/_module.mjs";
+export * as primary from "./primary/_module.mjs";
+export * as rendering from "./rendering/_module.mjs";
+export { default as SceneManager } from "./scene-manager.mjs";
+export * as sources from "./sources/_module.mjs";
+export { default as TextureExtractor } from "./texture-extractor.mjs";
+export * as workers from "./workers/_module.mjs";

package/src/client/canvas/animation/_module.d.mts

@@ -0,0 +1,5 @@
+export * from "./_types.mjs";
+export { default as CanvasAnimation } from "./canvas-animation.mjs";
+export * from "./chat-bubbles.mjs";
+export { default as ChatBubbles } from "./chat-bubbles.mjs";
+export { default as SmoothNoise } from "./smooth-noise.mjs";

package/src/client/canvas/animation/_types.d.mts

@@ -0,0 +1,73 @@
+import Color from "./../../../common/utils/color.mjs";
+import { TokenAnimationData } from "./../../_types.mjs";
+
+export interface CanvasAnimationAttribute {
+    /** The attribute name being animated */
+    attribute: string;
+
+    /** The object within which the attribute is stored */
+    parent: object;
+
+    /** The destination value of the attribute */
+    to: number | Color;
+
+    /** An initial value of the attribute, otherwise `parent[attribute]` is used */
+    from?: number | Color | undefined;
+
+    /** The computed delta between to and from */
+    delta?: number | undefined;
+
+    /** The amount of the total delta which has been animated */
+    done?: number | undefined;
+
+    /** Is this a color animation that applies to RGB channels */
+    color?: boolean | undefined;
+}
+
+export type CanvasAnimationEasingFunction = "easeInOutCosine" | "easeOutCircle" | "easeInCircle" | ((percentage: number) => number);
+
+export interface CanvasAnimationOptions {
+    /** A DisplayObject which defines context to the PIXI.Ticker function */
+    context?: PIXI.DisplayObject | undefined;
+
+    /** A unique name which can be used to reference the in-progress animation */
+    name?: string | symbol | undefined;
+
+    /** A duration in milliseconds over which the animation should occur */
+    duration?: number | undefined;
+
+    /** The current time of the animation, in milliseconds */
+    time?: number | undefined;
+
+    /** A priority in PIXI.UPDATE_PRIORITY which defines when the animation should be evaluated related to others */
+    priority?: number | undefined;
+
+    /** An easing function used to translate animation time or the string name of a static member of CanvasAnimation */
+    easing?: CanvasAnimationEasingFunction | undefined;
+
+    /** A callback function which fires after every frame */
+    ontick?: ((elapsedMS: number, animation: CanvasAnimationData, data: TokenAnimationData) => void) | undefined;
+
+    /** The animation isn't started until this promise resolves */
+    wait?: Promise<any> | undefined;
+}
+
+export interface CanvasAnimationData extends CanvasAnimationOptions {
+    /** The animation function being executed each frame */
+    fn: () => void;
+
+    /** The attributes being animated */
+    attributes: CanvasAnimationAttribute[];
+
+    /** The current state of the animation (see {@link CanvasAnimation.STATES}) */
+    state: number;
+
+    /** A Promise which resolves once the animation is complete */
+    promise: Promise<boolean>;
+
+    /** The resolution function, allowing animation to be ended early */
+    resolve: (completed: boolean) => void;
+
+    /** The rejection function, allowing animation to be ended early */
+    reject: (error: Error) => void;
+}