@stormstreaming/stormstreamer 0.9.2-beta.2 → 0.9.3-beta.0

package/dist/types/StormStreamer.d.ts

@@ -16,84 +16,475 @@ import { IGraph } from "./graph/IGraph";
 import { StatsController } from "./statistics/StatsController";
 import { BitrateGraph } from "./graph/BitrateGraph";
 import { FPSGraph } from "./graph/FPSGraph";
+import { MicrophoneGraph } from "./graph/MicrophoneGraph";
+/**
+ * Main class of the player. The player itself has no GUI, but can be controlled via provided API.
+ */
 export declare class StormStreamer extends EventDispatcher {
+    /**
+     * Next ID for the streamer instance. Each subsequent instance has a higher number.
+     * @private
+     */
     private static NEXT_STREAMER_ID;
+    /**
+     * Indicates whether the streamer object is in development mode (provides more debug options)
+     * @private
+     */
     private readonly DEV_MODE;
+    /**
+     * Version of this streamer in SemVer format (Major.Minor.Patch).
+     * @private
+     */
     private readonly STREAMER_VERSION;
+    /**
+     * Compile date for this streamer
+     * @private
+     */
     private readonly COMPILE_DATE;
+    /**
+     * Defines from which branch this streamer comes from e.g. "Main", "Experimental"
+     * @private
+     */
     private readonly STREAMER_BRANCH;
+    /**
+     * Defines number of streamer protocol that is required on server-side
+     * @private
+     */
     readonly STREAMER_PROTOCOL_VERSION: number;
+    /**
+     * ID of the streamer within StormStreamerArray collection
+     * @private
+     */
     private readonly _streamerID;
+    /**
+     * Contains all streamer configuration objects
+     * @private
+     */
     private _configManager;
+    /**
+     * Indicates whether streamer was initialized or not
+     * @private
+     */
     private _initialized;
+    /**
+     * Manages data storage like bandwidth settings, volume preferences
+     * @private
+     */
     private _storageManager;
+    /**
+     * Controls all HTML elements and visual presentation
+     * @private
+     */
     private _stageController;
+    /**
+     * Controls all streaming and media operations
+     * @private
+     */
     private _streamerController;
+    /**
+     * Controls all network communication with the server
+     * @private
+     */
     private _networkController;
+    /**
+     * Collects and manages streaming statistics
+     * @private
+     */
     private _statsController;
+    /**
+     * Collection of active performance graphs
+     * @private
+     */
     private _graphs;
+    /**
+     * Constructor - creates a new StormStreamer instance
+     *
+     * @param streamConfig - Configuration object for the streamer
+     * @param autoInitialize - Whether to automatically initialize the streamer after creation
+     */
     constructor(streamConfig?: StreamerConfig, autoInitialize?: boolean);
+    /**
+     * Initializes the streamer object. From this point, a connection to the server is established and authentication occurs.
+     * It is recommended to add all event listeners before calling this method to ensure they can be properly captured.
+     */
     initialize(): void;
+    /**
+     * Sets stream config for the streamer (or overwrites an existing one).
+     *
+     * @param streamConfig - New configuration object for the streamer
+     */
     setStreamConfig(streamConfig: StreamerConfig): void;
+    /**
+     * Returns true if this streamer instance is currently connected to a Storm Server/Cloud instance.
+     *
+     * @returns Boolean indicating connection status
+     */
     isConnected(): boolean;
+    /**
+     * Mutes the streamer's video object. Audio output will be silenced.
+     */
     mute(): void;
+    /**
+     * Unmutes the streamer's video object. Audio output will be restored.
+     */
     unmute(): void;
+    /**
+     * Checks whether the streamer audio is currently muted.
+     *
+     * @returns Boolean indicating mute status
+     */
     isMute(): boolean;
+    /**
+     * Toggles between mute and unmute states. Returns the new mute state.
+     *
+     * @returns New mute state (true = muted, false = unmuted)
+     */
     toggleMute(): boolean;
+    /**
+     * Sets new volume for the streamer (0-100). Once the method is performed, the volumeChange event will be triggered.
+     * If the video was muted prior to the volume change, it will be automatically unmuted.
+     *
+     * @param newVolume - Volume level (0-100)
+     */
     setVolume(newVolume: number): void;
+    /**
+     * Returns current streamer volume (0-100).
+     *
+     * @returns Current volume level
+     */
     getVolume(): number;
+    /**
+     * Returns the list of available camera devices.
+     *
+     * @returns Array of camera input devices
+     */
     getCameraList(): InputDevice[];
+    /**
+     * Returns the list of available microphone devices.
+     *
+     * @returns Array of microphone input devices
+     */
     getMicrophoneList(): InputDevice[];
+    /**
+     * Sets the active camera device by ID.
+     *
+     * @param cameraID - ID of the camera device to use
+     */
     setCamera(cameraID: string): void;
+    /**
+     * Sets the active microphone device by ID.
+     *
+     * @param microphoneID - ID of the microphone device to use
+     */
     setMicrophone(microphoneID: string): void;
+    /**
+     * Returns the currently active camera device.
+     *
+     * @returns Current camera device or null if none is active
+     */
     getCurrentCamera(): InputDevice | null;
+    /**
+     * Returns the currently active microphone device.
+     *
+     * @returns Current microphone device or null if none is active
+     */
     getCurrentMicrophone(): InputDevice | null;
+    /**
+     * Mutes or unmutes the microphone.
+     *
+     * @param microphoneState - True to mute, false to unmute
+     */
     muteMicrophone(microphoneState: boolean): void;
+    /**
+     * Checks if the microphone is currently muted.
+     *
+     * @returns Boolean indicating if microphone is muted
+     */
     isMicrophoneMuted(): boolean;
+    /**
+     * Returns the current publishing state of the streamer.
+     *
+     * @returns Current publishing state
+     */
     getPublishState(): PublishState;
+    /**
+     * Returns the total time the stream has been publishing in milliseconds.
+     *
+     * @returns Publishing time in milliseconds
+     */
     getPublishTime(): number;
+    /**
+     * Starts publishing a stream with the given stream key.
+     *
+     * @param streamKey - Key identifying the stream to publish
+     * @returns Boolean indicating if publishing was successfully initiated
+     */
     publish(streamKey: string): boolean;
+    /**
+     * Stops publishing the current stream.
+     */
+    unpublish(): void;
+    /**
+     * Returns the current state of input devices (camera and microphone).
+     *
+     * @returns Current state of input devices
+     */
     getInputDevicesState(): InputDevicesState;
-    getCamerState(): DeviceState;
+    /**
+     * Returns the current state of the camera device.
+     *
+     * @returns Current camera device state
+     */
+    getCameraState(): DeviceState;
+    /**
+     * Returns the current state of the microphone device.
+     *
+     * @returns Current microphone device state
+     */
     getMicrophoneState(): DeviceState;
+    /**
+     * Clears saved device preferences from storage.
+     */
     clearSavedDevices(): void;
+    /**
+     * Randomizes saved device preferences (for testing purposes).
+     */
     messSavedDevices(): void;
+    /**
+     * Checks if the stream is ready for publishing.
+     *
+     * @returns Boolean indicating if stream is ready
+     */
     isStreamReady(): boolean;
-    unpublish(): void;
+    /**
+     * Attaches the streamer to a new parent container using either a container ID (string) or a reference to an HTMLElement.
+     * If the instance is already attached, it will be moved to a new parent.
+     *
+     * @param container - Container ID (string) or HTMLElement reference
+     * @returns Boolean indicating if attachment was successful
+     */
     attachToContainer(container: string | HTMLElement): boolean;
+    /**
+     * Detaches the streamer from the current parent element, if possible.
+     *
+     * @returns Boolean indicating if detachment was successful
+     */
     detachFromContainer(): boolean;
+    /**
+     * Returns the current parent element of the streamer, or null if none exists.
+     *
+     * @returns Current container element or null
+     */
     getContainer(): HTMLElement | null;
+    /**
+     * Sets a new width and height for the streamer. The values can be given as a number (in which case they are
+     * treated as the number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%",
+     * where the number is treated as a percentage of the parent container's value.
+     *
+     * @param width - Can be provided as number or a string with "%" or "px" suffix
+     * @param height - Can be provided as number or a string with "%" or "px" suffix
+     */
     setSize(width: number | string, height: number | string): void;
+    /**
+     * Sets a new width for the streamer. The value can be given as a number (in which case it is treated as the
+     * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
+     * number is treated as a percentage of the parent container's value.
+     *
+     * @param width - Can be provided as number or a string with "%" or "px" suffix
+     */
     setWidth(width: number | string): void;
+    /**
+     * Sets a new height for the streamer. The value can be given as a number (in which case it is treated as the
+     * number of pixels), or as a string ending with "px" (this will also be the number of pixels) or "%", where the
+     * number is treated as a percentage of the parent container's value.
+     *
+     * @param height - Can be provided as number or a string with "%" or "px" suffix
+     */
     setHeight(height: number | string): void;
+    /**
+     * Returns current streamer width in pixels.
+     *
+     * @returns Current width in pixels
+     */
     getWidth(): number;
+    /**
+     * Returns current streamer height in pixels.
+     *
+     * @returns Current height in pixels
+     */
     getHeight(): number;
+    /**
+     * Changes the streamer scaling mode. Available modes include fill, letterbox, original, and crop.
+     *
+     * @param newMode - New scaling mode name (fill, letterbox, original, crop)
+     */
     setScalingMode(newMode: string): void;
+    /**
+     * Returns the current streamer scaling mode.
+     *
+     * @returns Current scaling mode
+     */
     getScalingMode(): ScalingType;
+    /**
+     * Forces the streamer to recalculate its size based on parent internal dimensions.
+     */
     updateToSize(): void;
+    /**
+     * Returns a promise that resolves with a screenshot of the video element as a blob, or null if taking the
+     * screenshot was not possible.
+     *
+     * @returns Promise resolving to a Blob containing the screenshot or null
+     */
     makeScreenshot(): Promise<Blob | null>;
+    /**
+     * Creates a FPS performance graph in the specified location (container ID or reference). The graph is a
+     * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+     * of the graph depend on the dimensions of the specified container.
+     *
+     * @param container - Element ID or reference to HTMLElement
+     * @returns FPS graph instance
+     */
     createFPSGraph(container: string | HTMLElement): FPSGraph;
+    /**
+     * Creates a bitrate performance graph in the specified location (container ID or reference). The graph is a
+     * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+     * of the graph depend on the dimensions of the specified container.
+     *
+     * @param container - Element ID or reference to HTMLElement
+     * @returns Bitrate graph instance
+     */
     createBitrateGraph(container: string | HTMLElement): BitrateGraph;
+    /**
+     * Creates a microphone graph in the specified location (container ID or reference). The graph is a
+     * separate object that must be started using its start() method and stopped using its stop() method. The dimensions
+     * of the graph depend on the dimensions of the specified container.
+     *
+     * @param container - Element ID or reference to HTMLElement
+     * @returns Bitrate graph instance
+     */
+    createMicrophoneGraph(container: string | HTMLElement): MicrophoneGraph;
+    /**
+     * Adds new graph to the internal collection of active graphs.
+     *
+     * @param newGraph - Graph instance to add
+     */
     addGraph(newGraph: IGraph): void;
+    /**
+     * Stops all active performance graphs.
+     */
     stopAllGraphs(): void;
+    /**
+     * Enters fullscreen mode for the streamer container.
+     */
     enterFullScreen(): void;
+    /**
+     * Exits fullscreen mode.
+     */
     exitFullScreen(): void;
+    /**
+     * Returns true if the streamer is currently in fullscreen mode.
+     *
+     * @returns Boolean indicating fullscreen status
+     */
     isFullScreenMode(): boolean;
+    /**
+     * Returns the current stream key or null if none is set.
+     *
+     * @returns Current stream key or null
+     */
     getStreamKey(): string | null;
+    /**
+     * Returns the Stats Controller instance which contains statistical data about streaming performance.
+     *
+     * @returns Stats controller instance or null
+     */
     getStatsController(): StatsController | null;
+    /**
+     * Returns the unique ID of this streamer instance. Each subsequent instance has a higher number.
+     *
+     * @returns Streamer instance ID
+     */
     getStreamerID(): number;
+    /**
+     * Returns the logger instance used by this streamer.
+     *
+     * @returns Logger instance
+     */
     getLogger(): Logger;
+    /**
+     * Returns the configuration manager for this streamer.
+     *
+     * @returns Config manager instance or null
+     */
     getConfigManager(): ConfigManager | null;
+    /**
+     * Returns the network controller which manages all server communication.
+     *
+     * @returns Network controller instance or null
+     */
     getNetworkController(): NetworkController | null;
+    /**
+     * Returns the streamer controller which manages media stream operations.
+     *
+     * @returns Streamer controller instance or null
+     */
     getStreamerController(): StreamerController | null;
+    /**
+     * Returns the stage controller which manages visual presentation.
+     *
+     * @returns Stage controller instance or null
+     */
     getStageController(): StageController | null;
+    /**
+     * Returns the storage manager which handles persistent data storage.
+     *
+     * @returns Storage manager instance or null
+     */
+    getStorageManager(): StorageManager | null;
+    /**
+     * Returns the HTML video element used by this streamer instance.
+     *
+     * @returns Video element or null
+     */
     getVideoElement(): HTMLVideoElement | null;
+    /**
+     * Returns true if this streamer instance has already been initialized.
+     *
+     * @returns Boolean indicating initialization status
+     */
     isInitialized(): boolean;
+    /**
+     * Returns the version of this streamer instance. The version is returned in the SemVer format (Major.Minor.Patch).
+     *
+     * @returns Streamer version string
+     */
     getVersion(): string;
+    /**
+     * Returns the development branch of this streamer (e.g., main, experimental).
+     *
+     * @returns Branch name string
+     */
     getBranch(): string;
-    getStorageManager(): StorageManager | null;
+    /**
+     * Dispatches an event with the specified name and data.
+     *
+     * @param eventName - Name of the event to dispatch
+     * @param event - Object containing event data
+     */
     dispatchEvent<K extends keyof StormStreamerEvent>(eventName: K, event: StormStreamerEvent[K]): void;
+    /**
+     * Starts the streaming process.
+     *
+     * @returns Promise that resolves when streaming has started
+     */
     start(): Promise<void>;
+    /**
+     * Stops the streaming process.
+     */
     stop(): void;
+    /**
+     * Destroys this instance of StormStreamer, releasing all resources and disconnecting from the server.
+     * After calling this method, the instance should not be used anymore.
+     */
     destroy(): void;
 }

package/dist/types/config/AudioData.d.ts

@@ -1,16 +1,62 @@
 import { Logger } from "../logger/Logger";
 import { IConfig } from "./IConfig";
 import { AudioConfig } from "../types/AudioConfig";
+/**
+ * Class contains all parameters related to volume
+ */
 export declare class AudioData implements IConfig {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private static readonly PRINT_ON_STARTUP;
+    /**
+     * Original config object
+     * @private
+     */
     private _audioConfig;
+    /**
+     * Default value for volume
+     * @private
+     */
     private _startVolume;
+    /**
+     * Whenever video is muted
+     * @private
+     */
     private _isMuted;
+    /**
+     * Constructor
+     * @param volumeConfig
+     */
     constructor(volumeConfig: AudioConfig | null);
+    /**
+     * Parses provided config
+     */
     parse(config: AudioConfig | null): void;
+    /**
+     * Returns player start volume
+     */
     get startVolume(): number;
+    /**
+     * Sets start volume for the player (by default it's 100)
+     * @param newValue
+     */
     set startVolume(newValue: number);
+    /**
+     * Returns whenever library should be muted on start
+     */
     get muted(): boolean;
+    /**
+     * Sets whenever library should be muted or not
+     * @param newValue
+     */
     set muted(newValue: boolean);
+    /**
+     * Prints current settings
+     *
+     * @param logger
+     */
     print(logger: Logger, force?: boolean): void;
 }

package/dist/types/config/ConfigManager.d.ts

@@ -3,16 +3,63 @@ import { StreamData } from "./StreamData";
 import { SettingsData } from "./SettingsData";
 import { Logger } from "../logger/Logger";
 import { StreamerConfig } from "../types/StreamerConfig";
+/**
+ * Class responsible for parsing config object.
+ */
 export declare class ConfigManager implements IConfig {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private readonly PRINT_ON_STARTUP;
+    /**
+     * Original config template provided via constructor
+     * @private
+     */
     private configTemplate;
+    /**
+     * Contains configurations related to servers and streams
+     * @private
+     */
     private streamData;
+    /**
+     * Contains configuration related to player settings
+     * @private
+     */
     private settingsData;
+    /**
+     * Whenver we're in demo mode
+     * @private
+     */
     private demoMode;
+    /**
+     * Constuctor
+     * @param config config object
+     */
     constructor(config: StreamerConfig);
+    /**
+     * Parses config objects into smaller chunkes related to their kind.
+     * @private
+     */
     parse(config: StreamerConfig): void;
+    /**
+     * Returns the part of the config with player stream data (what to play)
+     */
     getStreamData(): StreamData;
+    /**
+     * Returns the part of the config with player settings
+     */
     getSettingsData(): SettingsData;
+    /**
+     * Returns true/false whenever we're in demo mode or not
+     */
     getIfDemoMode(): boolean;
+    /**
+     * Prints current settings.
+     *
+     * @param logger reference to logger
+     * @param force if printing is disabled, this parameter can overwrite it
+     */
     print(logger: Logger, force?: boolean): void;
 }