@stormstreaming/stormstreamer 0.9.2-beta.3 → 1.0.0-rc.0

package/dist/types/events/EventDispatcher.d.ts

@@ -1,15 +1,49 @@
 import { StormStreamerEvent } from "./StormStreamerEvent";
 import { StormStreamerListener } from "./StormStreamerListener";
 import { Logger } from "../logger/Logger";
+/**
+ * General class for event-listeners
+ */
 export declare class EventDispatcher {
+    /**
+     * Whenever instance of this class has been removed
+     * @protected
+     */
     protected _isRemoved: boolean;
+    /**
+     * Logger attached to this player
+     * @private
+     */
     protected _logger: Logger;
+    /**
+     * An array storing all the listeners
+     * @private
+     */
     protected _listeners: {
         [K in keyof StormStreamerEvent]?: Array<StormStreamerListener<K>>;
     };
     constructor();
+    /**
+     * Method registers event listener with the object
+     * @param eventName name of an event (as a string)
+     * @param listener a reference to a method
+     * @param removable whenever this listener can be removed or not
+     */
     addEventListener<K extends keyof StormStreamerEvent>(eventName: K, listener: (ev: StormStreamerEvent[K]) => void, removable?: boolean): boolean;
+    /**
+     * Method removes a listener from this object based on event name and used method
+     * @param eventName name of an event (as a string)
+     * @param listenera reference to a method (optional)
+     */
     removeEventListener<K extends keyof StormStreamerEvent>(eventName: K, listener?: (ev: StormStreamerEvent[K]) => void): boolean;
+    /**
+     * Method removes all event listeners
+     */
     removeAllEventListeners<K extends keyof StormStreamerEvent>(): void;
+    /**
+     * Method dispatches an event of a given eventName
+     * @param eventName
+     * @param event
+     */
     dispatchEvent<K extends keyof StormStreamerEvent>(eventName: K, event: StormStreamerEvent[K]): void;
 }

package/dist/types/events/StormStreamerEvent.d.ts

@@ -7,199 +7,340 @@ import { DeviceState } from "../playback/enum/DeviceState";
 import { PublishMetadata } from "../playback/model/PublishMetadata";
 import { StreamStatusInfo } from "../playback/model/StreamStatusInfo";
 export interface StormStreamerEvent {
+    /**
+     * This event is triggered when a streamer instance is initialized via the initialize() method.
+     */
     "streamerReady": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired when a streamer instance initiates a connection with a Storm Streaming Server/Cloud instance.
+     */
     "serverConnectionInitiate": {
         ref: StormStreamer;
         serverURL: string;
     };
+    /**
+     * This event is triggered when a streamer instance successfully establishes a connection with a Storm Streaming Server/Cloud instance.
+     */
     "serverConnect": {
         ref: StormStreamer;
         serverURL: string;
         sequenceNum: number;
     };
+    /**
+     * This event is triggered when a streamer instance successfully establishes a connection with a status server.
+     */
     "statusServerConnect": {
         ref: StormStreamer;
         serverURL: string;
         sequenceNum: number;
     };
+    /**
+     * This event is called when a streamer instance is disconnected from the Storm Streaming Server/Cloud (after a connection was previously established), which may occur due to publisher networking issues or Storm Streaming Server/Cloud problems.
+     */
     "serverDisconnect": {
         ref: StormStreamer;
         serverURL: string;
         restart: boolean;
         sequenceNum: number;
     };
+    /**
+     * This event is called when a streamer instance is disconnected from the status server.
+     */
     "statusServerDisconnect": {
         ref: StormStreamer;
         serverURL: string;
         restart: boolean;
         sequenceNum: number;
     };
+    /**
+     * This event is triggered when a streamer instance fails to establish a connection with a Storm Streaming Server/Cloud instance, possibly due to networking issues. If there are additional servers on the configuration list and the "restartOnError" parameter is set to true, the streamer will attempt to connect to a different server instead.
+     */
     "serverConnectionError": {
         ref: StormStreamer;
         serverURL: string;
         restart: boolean;
         sequenceNum: number;
     };
+    /**
+     * This event is triggered when a streamer instance fails to establish a connection with a status server.
+     */
     "statusServerConnectionError": {
         ref: StormStreamer;
         serverURL: string;
         restart: boolean;
         sequenceNum: number;
     };
+    /**
+     * This event is associated with serverConnectionError. If a streamer instance is unable to connect to any of the servers provided in the configuration list, this event indicates that no further action can be taken.
+     */
     "allConnectionsFailed": {
         ref: StormStreamer;
         mode: string;
     };
+    /**
+     * Certain browsers and devices do not permit a video element to initiate on its own and necessitate direct user interaction, such as a mouse click or a touch gesture. This event signifies that such an engagement is required.
+     */
     "interactionRequired": {
         ref: StormStreamer;
         mode: string;
     };
+    /**
+     * This event is triggered if a browser or device does not support the required features for streaming. Please note that the streamer will attempt all possible measures to ensure maximum compatibility with a given device.
+     */
     "compatibilityError": {
         ref: StormStreamer;
         message: string;
     };
+    /**
+     * This event is fired when the preview playback is forcefully paused by the system (not by user interaction).
+     */
     "playbackForcePause": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired when the preview playback is forcefully muted by the system (not by user interaction).
+     */
     "playbackForceMute": {
         ref: StormStreamer;
     };
+    /**
+     * This event notifies that video volume was changed (either its value was changed, or video was muted/un-muted).
+     */
     "volumeChange": {
         ref: StormStreamer;
         volume: number;
         muted: boolean;
         invokedBy: "user" | "browser";
     };
+    /**
+     * This event is triggered whenever a video element within a streamer instance is either created or recreated.
+     */
     "videoElementCreate": {
         ref: StormStreamer;
         videoElement: HTMLVideoElement;
     };
+    /**
+     * This event is fired whenever a streamer is detached or attached to a new container.
+     */
     "containerChange": {
         ref: StormStreamer;
         container: HTMLElement | null;
     };
+    /**
+     * This event is triggered when the video preview size is changed or updated.
+     */
     "resizeUpdate": {
         ref: StormStreamer;
         width: number;
         height: number;
     };
+    /**
+     * This event is fired when the video preview is successfully unmuted.
+     */
     "videoUnmuted": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired if an SSL layer is required for streaming and the browser does not provide it.
+     */
     "SSLError": {
         ref: StormStreamer;
         mode: string;
     };
+    /**
+     * This event is fired when there is a protocol version mismatch between the client and server.
+     */
     "incompatibleProtocol": {
         ref: StormStreamer;
         clientProtocolVer: number;
         serverProtocolVersion: number;
     };
+    /**
+     * This event is fired when a streamer instance fails to authorize with a server application on Storm Streaming Server/Cloud instance (e.g. incorrect token).
+     */
     "authorizationError": {
         ref: StormStreamer;
     };
+    /**
+     * This event is called when a streamer instance successfully authorizes with a server application on Storm Streaming Server/Cloud instance.
+     */
     "authorizationComplete": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired whenever a Storm Streaming Server/Cloud license expires.
+     */
     "invalidLicense": {
         ref: StormStreamer;
     };
+    /**
+     * This event notifies that basic stream configuration has been updated.
+     */
     "streamConfigChange": {
         ref: StormStreamer;
         newConfig: ConfigManager;
     };
+    /**
+     * This event is fired whenever a streamer instance enters browser fullscreen mode (either native or overlay type).
+     */
     "fullScreenEnter": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired whenever a streamer instance exits fullscreen mode (either native or overlay type).
+     */
     "fullScreenExit": {
         ref: StormStreamer;
     };
+    /**
+     * This event is triggered when no camera device is found on the system.
+     */
     "noCameraFound": {
         ref: StormStreamer;
     };
+    /**
+     * This event notifies about changes in the publishing state (e.g., NOT_INITIALIZED, INITIALIZING, PUBLISHING, etc.).
+     */
     "publishStateChange": {
         ref: StormStreamer;
         state: PublishState;
     };
+    /**
+     * This event is triggered when no microphone device is found on the system.
+     */
     "noMicrophoneFound": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired when the list of available input devices (cameras and microphones) is updated.
+     */
     "deviceListUpdate": {
         ref: StormStreamer;
         cameraList: InputDevice[];
         microphoneList: InputDevice[];
     };
+    /**
+     * This event is triggered when there is an error accessing or using an input device.
+     */
     "inputDeviceError": {
         ref: StormStreamer;
     };
+    /**
+     * This event is fired when camera access permission is denied by the user or the system.
+     */
     "cameraAccessDenied": {
         ref: StormStreamer;
     };
+    /**
+     * This event notifies about changes in the state of input devices and provides information about selected camera and microphone.
+     */
     "deviceStateChange": {
         ref: StormStreamer;
         state: InputDevicesState;
         selectedCamera: InputDevice | null;
         selectedMicrophone: InputDevice | null;
     };
+    /**
+     * This event is fired when new metadata about the publishing stream is available.
+     */
     "publishMetadataUpdate": {
         ref: StormStreamer;
         metadata: PublishMetadata;
     };
+    /**
+     * This event provides updated information about the status of the published stream on the server.
+     */
     "streamStatusUpdate": {
         ref: StormStreamer;
         streamStatus: StreamStatusInfo;
     };
+    /**
+     * This event notifies about changes in the camera device state and provides information about the selected camera.
+     */
     "cameraDeviceStateChange": {
         ref: StormStreamer;
         state: DeviceState;
         selectedCamera: InputDevice | null;
     };
+    /**
+     * This event notifies about changes in the microphone device state and provides information about the selected microphone.
+     */
     "microphoneDeviceStateChange": {
         ref: StormStreamer;
         state: DeviceState;
         selectedMicrophone: InputDevice | null;
     };
+    /**
+     * This event is fired when microphone access permission is denied by the user or the system.
+     */
     "microphoneAccessDenied": {
         ref: StormStreamer;
     };
+    /**
+     * This event is triggered when a previously saved camera device is no longer available on the system.
+     */
     "savedCameraNotFound": {
         ref: StormStreamer;
         savedDeviceID: string | null;
     };
+    /**
+     * This event is triggered when a previously saved microphone device is no longer available on the system.
+     */
     "savedMicrophoneNotFound": {
         ref: StormStreamer;
         savedDeviceID: string | null;
     };
+    /**
+     * This event is fired when attempting to publish with a stream key that is already in use by another publisher.
+     */
     "streamKeyInUse": {
         ref: StormStreamer;
         streamKey: string;
     };
+    /**
+     * This event is fired periodically when attempting to publish with a stream key that is already in use, providing retry count information.
+     */
     "streamKeyInUseInterval": {
         ref: StormStreamer;
         streamKey: string;
         count: number;
         maxCount: number;
     };
+    /**
+     * This event provides real-time audio level information from the microphone.
+     */
     "soundMeter": {
         ref: StormStreamer;
         high: number;
         low: number;
     };
+    /**
+     * This event notifies about changes in the microphone mute state.
+     */
     "microphoneStateChange": {
         ref: StormStreamer;
         isMuted: boolean;
     };
+    /**
+     * This event provides metadata about the video being published, including dimensions.
+     */
     "metadata": {
         ref: StormStreamer;
         videoWidth: number;
         videoHeight: number;
     };
+    /**
+     * This event is fired when publishing to a stream key is initiated.
+     */
     "publish": {
         ref: StormStreamer;
         streamKey: string;
     };
+    /**
+     * This event is fired when publishing is stopped.
+     */
     "unpublish": {
         ref: StormStreamer;
     };

package/dist/types/graph/MicrophoneGraph.d.ts

@@ -0,0 +1,11 @@
+import { StormStreamer } from "../StormStreamer";
+import { IGraph } from "./IGraph";
+export declare class MicrophoneGraph implements IGraph {
+    private _object;
+    private _main;
+    private _graph;
+    constructor(main: StormStreamer, container: string | HTMLElement);
+    start(): MicrophoneGraph;
+    private onStreamStatsUpdate;
+    stop(): MicrophoneGraph;
+}

package/dist/types/logger/Logger.d.ts

@@ -1,26 +1,129 @@
+/**
+ * Logger that helps outputting messages
+ */
 import { DebugData } from "../config/DebugData";
 import { StormStreamer } from "../StormStreamer";
 export declare class Logger {
+    /**
+     * Defines what color an info log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     private static INFO_COLOR;
+    /**
+     * Defines what color a warning log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     private static WARNING_COLOR;
+    /**
+     * Defines what color an error log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     private static ERROR_COLOR;
+    /**
+     * Defines what color a success log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     private static SUCCESS_COLOR;
+    /**
+     * Defines what color a success log would be outputted (can be either a color name or #hex)
+     * @private
+     */
     private static TRACE_COLOR;
+    /**
+     * Stores original debug config object
+     * @private
+     */
     private _debugConfig;
+    /**
+     * Reference to main object
+     * @private
+     */
     private _stormStreamer;
+    /**
+     * List of colors used for monoColor option
+     * @private
+     */
     private colorOrder;
+    /**
+     * Selected monocolor
+     * @private
+     */
     private _monoColor;
+    /**
+     * Stores all loges within this array
+     * @private
+     */
     private _logMemory;
+    /**
+     * Main name of the instance
+     * @private
+     */
     private _streamerInstanceID;
+    /**
+     * Constructor
+     *
+     * @param config object containing settings for logger
+     * @param stormLibrary reference to main class
+     */
     constructor(config: DebugData, stormStreamer: StormStreamer);
+    /**
+     * Creates new "info" type log
+     *
+     * @param objectName object that called the log
+     * @param message log message
+     */
     info(objectName: any, message: string): void;
+    /**
+     * Creates new "warning" type log
+     *
+     * @param objectName object that called the log
+     * @param message log message
+     */
     warning(objectName: any, message: string): void;
     decoratedLog(text: string, scheme: string): void;
+    /**
+     * Creates new "error" type log
+     *
+     * @param objectName object that called the log
+     * @param message log message
+     */
     error(objectName: any, message: string): void;
+    /**
+     * Creates new "success" type log
+     *
+     * @param objectName object that called the log
+     * @param message log message
+     */
     success(objectName: any, message: string): void;
+    /**
+     * Creates new "trace" type log
+     *
+     * @param objectName object that called the log
+     * @param message log message
+     */
     trace(objectName: any, message: string): void;
+    /**
+     * Prepares console message and formats its text
+     * @param _objectName object that called the log
+     * @param message log message
+     * @private
+     */
     private logData;
+    /**
+     * Writes log to a DOM container
+     *
+     * @param message the message
+     * @param color of the log
+     * @private
+     */
     private writeToContainer;
+    /**
+     * Sets player id
+     * @param playerID
+     */
     setPlayerID(playerID: number): void;
+    /**
+     * Returns all logs
+     */
     getAllLogs(): Array<string>;
 }

package/dist/types/model/AbstractSourceItem.d.ts

@@ -1,9 +1,32 @@
 import { ProtocolType } from "../config/enum/ProtocolType";
 import { StreamInfo } from "./StreamInfo";
+/**
+ * Abstract class for all source items (e.g. webrtc, rtmp, mpeg-dash)
+ */
 export declare class AbstractSourceItem {
+    /**
+     * Protocol type e.g. RTMP, RTSP
+     * @private
+     */
     protected type: ProtocolType;
+    /**
+     * Info object (cointains data related to video width, height, fps, bitrate e.g.)
+     * @private
+     */
     protected streamInfo: StreamInfo;
+    /**
+     * Constructor
+     *
+     * @param type
+     * @param info
+     */
     constructor(type: ProtocolType, info: StreamInfo);
+    /**
+     * Returns protocol type
+     */
     getType(): ProtocolType;
+    /**
+     * Return info object
+     */
     getStreamInfo(): StreamInfo;
 }

package/dist/types/model/GatewayServerItem.d.ts

@@ -1,17 +1,70 @@
 import { IServerItem } from "./IServerItem";
+/**
+ * Class stores information related to storm gateway servers
+ */
 export declare class GatewayServerItem implements IServerItem {
+    /**
+     * Server url
+     * @private
+     */
     private host;
+    /**
+     * Application name
+     * @private
+     */
     private application;
+    /**
+     * Port for storm (default is 443)
+     * @private
+     */
     private port;
+    /**
+     * Whenver connection should be made via SSL (default is true)
+     * @private
+     */
     private isSSL;
+    /**
+     * Whenever player could not establish connection with this host
+     * @private
+     */
     private hasFaild;
+    /**
+     * Constructor
+     *
+     * @param host server URL e.g. "cdn-e001.stormstreaming.com"
+     * @param applicationName e.g. "live
+     * @param port usually 443
+     * @param isSSL whenever connection should be stablished via SSL (true by default)
+     */
     constructor(host: string, application: string, port?: number, isSSL?: boolean);
+    /**
+     * Returns server URL
+     */
     getHost(): string;
+    /**
+     * Returns port number
+     */
     getPort(): number;
+    /**
+     * Returns whenever connection should be established via SSL
+     */
     getIfSSL(): boolean;
+    /**
+     * Returns whenever connection faild while trying to connect
+     */
     getIfFaild(): boolean;
+    /**
+     * Marks this server as faild, prevent it from being used anymore
+     * @param value
+     */
     setAsFaild(value: boolean): void;
+    /**
+     * Returns application
+     */
     getApplication(): string;
+    /**
+     * Returns data from this object
+     */
     getData(): any;
     toString(): string;
 }

package/dist/types/model/IServerItem.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Interface for source item
+ */
 export interface IServerItem {
     getHost(): string;
     getApplication(): string;

package/dist/types/model/ISourceItem.d.ts

@@ -1,5 +1,8 @@
 import { ProtocolType } from "../config/enum/ProtocolType";
 import { StreamInfo } from "./StreamInfo";
+/**
+ * Interface for source item
+ */
 export interface ISourceItem {
     getType(): ProtocolType;
     getStreamInfo(): StreamInfo;

package/dist/types/model/IStreamItem.d.ts

@@ -1,4 +1,7 @@
 import { ProtocolType } from "../config/enum/ProtocolType";
+/**
+ * Interface for source item
+ */
 export interface IStreamItem {
     getType(): ProtocolType;
     getStreamName(): string;