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

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

@@ -2,36 +2,144 @@ import { IConfig } from "./IConfig";
 import { LogType } from "./enum/LogType";
 import { Logger } from "../logger/Logger";
 import { DebugConfig } from "../types/DebugConfig";
+/**
+ * This class represents "debug" section of an original player config. If any field/value is missing in the config,
+ * default values defined within this class will be used instead.
+ */
 export declare class DebugData implements IConfig {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private static readonly PRINT_ON_STARTUP;
+    /**
+     * A part of an original config with parameters for debug settings
+     *
+     * @private
+     */
     private _debugConfig;
+    /**
+     * Decides whenever log will be outputted in browser console
+     * @private
+     */
     private _consoleLogEnabled;
+    /**
+     * List of enabled console log types (order doesn't matter)
+     * @private
+     */
     private _enabledConsoleTypes;
+    /**
+     * If true, different types of logs for console will have the same color, but each player will have
+     * its own color (easier to debug with multiple players)
+     *
+     * @private
+     */
     private _consoleMonoColor;
+    /**
+     * List of enabled console log types (order doesn't matter)
+     * @private
+     */
     private _containerLogEnabled;
+    /**
+     *
+     * @private
+     */
     private _enabledContainerTypes;
+    /**
+     * Name of the DOM container where logs will be added
+     * @private
+     */
     private _containerID;
+    /**
+     * If true, different types of logs for container will have the same color, but each player will have
+     * its own color (easier to debug with multiple players)
+     *
+     * @private
+     */
     private _containerLogMonoColor;
     private _stageController;
     private _streamerController;
+    /**
+     * Creates debug object based on parameters from config object
+     *
+     * @param debugConfig
+     */
     constructor(debugConfig: DebugConfig | null);
+    /**
+     * Parses provided config
+     */
     parse(debugConfig: DebugConfig | null): void;
     private parseLogTypes;
+    /**
+     * Returns whenever logs from debug will be pushed to browser console. False by default.
+     */
     get consoleLogEnabled(): boolean;
+    /**
+     * Sets console logging on/off
+     * @param newValue
+     */
     set consoleLogEnabled(newValue: boolean);
+    /**
+     * Returns all enabled types of logs for console logging
+     */
     get enabledConsoleTypes(): Array<LogType>;
+    /**
+     * Sets console log types
+     * @param newValue
+     */
     set enabledConsoleTypes(newValue: Array<string>);
+    /**
+     * Returns whenever logs from debug will be pushed to a cointainer. False by default.
+     */
     get containerLogEnabled(): boolean;
+    /**
+     * Sets container debugging on/off
+     * @param newValue
+     */
     set containerLogEnabled(newValue: boolean);
+    /**
+     * Retruns true if all console outputs will have the same color (depending on playerID)
+     */
     get consoleLogMonoColor(): boolean;
+    /**
+     * Sets console logging to monocolor
+     * @param newValue
+     */
     set consoleLogMonoColor(newValue: boolean);
+    /**
+     * Returns all enabled types of logs for container logging
+     */
     get enabledContainerTypes(): Array<LogType>;
+    /**
+     * Sets console log types
+     * @param newValue
+     */
     set enabledContainerTypes(newValue: Array<string>);
+    /**
+     * Return a reference to a object where logs will be pushed as text. Null by default.
+     */
     get containerID(): string | null;
+    /**
+     * Sets container for logging
+     * @param object
+     */
     set containerID(object: string);
+    /**
+     * Retruns true if all container outputs will have the same color (depending on playerID)
+     */
     get containerLogMonoColor(): boolean;
+    /**
+     * Sets container logging to monocolor
+     * @param newValue
+     */
     set containerLogMonoColor(newValue: boolean);
     get stageControllerDebug(): boolean;
     get streamerControllerDebug(): boolean;
+    /**
+     * Prints current settings
+     *
+     * @param logger
+     */
     print(logger: Logger, force?: boolean): void;
 }

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

@@ -1,4 +1,7 @@
 import { Logger } from "../logger/Logger";
+/**
+ * Interface for all configs within the player
+ */
 export interface IConfig {
     print(logger: Logger, force: boolean): void;
 }

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

@@ -5,37 +5,151 @@ import { AudioData } from "./AudioData";
 import { Logger } from "../logger/Logger";
 import { SettingsConfig } from "../types/SettingsConfig";
 import { StorageData } from "./StorageData";
+/**
+ * Store all settings related to player behavior
+ */
 export declare class SettingsData implements IConfig {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private static readonly PRINT_ON_STARTUP;
+    /**
+     * Raw config provided for the player
+     *
+     * @private
+     */
     private _settingsConfig;
+    /**
+     * Whenver player should try reconnecting upon its error
+     * @private
+     */
     private _restartOnError;
+    /**
+     * Number of seconds between player reconnects
+     * @private
+     */
     private _reconnectTime;
+    /**
+     * Decides whenver player will automatically start playing content
+     * @private
+     */
     private _autoStart;
+    /**
+     * Decides whenver player will automatically connect to a server
+     * @private
+     */
     private _autoConnect;
+    /**
+     * Start player only when DOM is ready
+     *
+     * @private
+     */
     private startOnDOMReady;
+    /**
+     * Starts video playback on iOS only once DOM is ready
+     *
+     * @private
+     *
+     */
     private iOSOnDomReadyFix;
+    /**
+     * Contains configuration related to video
+     * @private
+     */
     private _videoData;
+    /**
+     * Contains configuration related to logger/debugger
+     * @private
+     */
     private _debugData;
+    /**
+     * Contains configuration related to storing user data
+     * @private
+     */
     private _storageData;
+    /**
+     * Contains configuration related to volume
+     * @private
+     */
     private _audioData;
+    /**
+     * Decides whenever player will restart on focus/blur
+     * @private
+     */
     private _restartOnFocus;
+    /**
+     * Whenever streamer should preselect some camera and microphone if no was selected prior
+     * @private
+     */
     private _preselectDevices;
     private _cancelPublishOnError;
+    /**
+     * Constructor
+     * @param config
+     */
     constructor(config: SettingsConfig);
+    /**
+     * Parses provided config
+     * @param config
+     */
     parse(config: SettingsConfig): void;
+    /**
+     * Returns Volume Config
+     */
     getAudioData(): AudioData;
+    /**
+     * Returns Video Config
+     */
     getVideoData(): VideoData;
+    /**
+     * Returns Storage Data
+     */
     getStorageData(): StorageData;
+    /**
+     * Returns if player should reset connection after error
+     */
     getIfRestartOnError(): boolean;
+    /**
+     * Returns time (in ms) when player should attempt new connection after error
+     */
     getReconnectTime(): number;
+    /**
+     * Returns true whenever autostart is activated
+     */
     get autoStart(): boolean;
+    /**
+     * Sets autostart value
+     * @param newValue
+     */
     set autoStart(newValue: boolean);
+    /**
+     * Returns true/false whenever library is set to auto-connect with a Storm server
+     */
     get autoConnect(): boolean;
+    /**
+     * Returns true whenever library should restart the connection on document focus/blur
+     */
     get restartOnFocus(): boolean;
+    /**
+     * Returns Debug Config
+     */
     getDebugData(): DebugData;
     getIfForceSelection(): boolean;
     getIfCancelPublishOnError(): boolean;
+    /**
+     * Returns whenever player should start only after DOM has been initialized
+     */
     getIfStartOnDOMReadyEnabled(): boolean;
+    /**
+     * Returns whenever player (ios mode) should start only after DOM has been initialized
+     */
     getIfIOSOnDomStartFixEnabled(): boolean;
+    /**
+     * Prints current settings
+     *
+     * @param logger
+     */
     print(logger: Logger, force?: boolean): void;
 }

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

@@ -1,16 +1,62 @@
 import { Logger } from "../logger/Logger";
 import { IConfig } from "./IConfig";
 import { StorageConfig } from "../types/StorageConfig";
+/**
+ * Class contains all parameters related to volume
+ */
 export declare class StorageData implements IConfig {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private static readonly PRINT_ON_STARTUP;
+    /**
+     * Original config object
+     * @private
+     */
     private _storageConfig;
+    /**
+     * Whenever storage is enabled or not (true by default)
+     * @private
+     */
     private _enabled;
+    /**
+     * Prefix for loading and saving settings
+     * @private
+     */
     private _prefix;
+    /**
+     * Constructor
+     * @param storageConfig
+     */
     constructor(storageConfig: StorageConfig | null);
+    /**
+     * Parses provided config
+     */
     parse(config: StorageConfig | null): void;
+    /**
+     * Returns if storage is enabled
+     */
     get enabled(): boolean;
+    /**
+     * Sets new value for enabled
+     * @param newValue
+     */
     set enabled(newValue: boolean);
+    /**
+     * Returns storage prefix
+     */
     get prefix(): string;
+    /**
+     * Sets storage prefix
+     * @param newValue
+     */
     set prefix(newValue: string);
+    /**
+     * Prints current settings
+     *
+     * @param logger
+     */
     print(logger: Logger, force?: boolean): void;
 }

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

@@ -2,24 +2,99 @@ import { StormServerItem } from "../model/StormServerItem";
 import { ISourceItem } from "../model/ISourceItem";
 import { Logger } from "../logger/Logger";
 import { StreamConfig } from "../types/StreamConfig";
+/**
+ * Class contains streaming data
+ */
 export declare class StreamData {
+    /**
+     * Decides whenever player will print this config data on startup
+     *
+     * @private
+     */
     private static readonly PRINT_ON_STARTUP;
+    /**
+     * Default storm port (usually 443)
+     * @private
+     */
     private static readonly DEFAULT_CONNECTION_PORT;
+    /**
+     * Whenever all connection to strom should be made via SSL
+     * @private
+     */
     private static readonly IS_SSL_BY_DEFAULT;
+    /**
+     * Original config file
+     * @private
+     */
     private _streamConfig;
+    /**
+     * List of all servers (Storm)
+     * @private
+     */
     private _serverList;
+    /**
+     * List of all sources (usually the same video, but in a different resolution)
+     * @private
+     */
     private _sourceList;
+    /**
+     * Contains stream data (for publishing aka Streamer mode)
+     * @private
+     */
     private publishData;
+    /**
+     * Group name for gateway server
+     * @private
+     */
     private _streamKey;
+    /**
+     * Constructor
+     * @param streamConfig
+     */
     constructor(streamConfig: StreamConfig);
+    /**
+     * Parses provided config
+     */
     parse(streamConfig: StreamConfig): void;
+    /**
+     * Returns list of all provided servers
+     */
     getServerList(): Array<StormServerItem>;
+    /**
+     * Returns list of all video sources
+     */
     getSourceList(): Array<ISourceItem>;
+    /**
+     * Returns group name;
+     */
     get streamKey(): string | null;
+    /**
+     * Returns group name;
+     */
     set streamKey(newValue: string | null);
+    /**
+     * Allows to push server list to the config
+     * @param serverList
+     */
     set serverList(serverList: Array<StormServerItem>);
+    /**
+     * Allows to push source list to the config
+     * @param sourceList
+     */
     set sourceList(sourceList: Array<ISourceItem>);
+    /**
+     * Removes all sources
+     */
     clearSourceList(): void;
+    /**
+     * Removes all SERVERS
+     */
     clearServerList(): void;
+    /**
+     * 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;
 }

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

@@ -3,38 +3,153 @@ import { ScalingType } from "./enum/ScalingType";
 import { Logger } from "../logger/Logger";
 import { VideoConfig } from "../types/VideoConfig";
 import { SizeCalculationType } from "./enum/SizeCalculationType";
+/**
+ * Class contains settings for video object
+ */
 export declare class VideoData implements IConfig {
+    /**
+     * Original config
+     * @private
+     */
     private videoConfig;
+    /**
+     * Selected scaling mode
+     * @private
+     */
     private _scalingMode;
+    /**
+     * Container ID for video object (must be created prior to starting the player)
+     * @private
+     */
     private _containerID;
+    /**
+     * Aspect ratio saved as a string (two numbers with : in between)
+     * @private
+     */
     private _aspectRatio;
+    /**
+     * Initial video container width
+     * @private
+     */
     private _videoWidthValue;
+    /**
+     * Whenever width is in pixels
+     * @private
+     */
     private _isVideoWidthInPixels;
+    /**
+     * Whenever width was provided
+     * @private
+     */
     private _wasVideoWidthProvided;
+    /**
+     * Initial video container height;
+     * @private
+     */
     private _videoHeightValue;
+    /**
+     * Whenever height is in pixels
+     * @private
+     */
     private _isVideoHeightInPixels;
+    /**
+     * Whenever height was provided
+     * @private
+     */
     private _wasVideoHeightProvided;
+    /**
+     * Resize debounce parameter
+     * @private
+     */
     private _resizeDebounce;
+    /**
+     * Method used for calculating parent size;
+     * @private
+     */
     private _parentSizeCalculationMethod;
+    /**
+     * Constructor
+     *
+     * @param videoConfig video config object
+     */
     constructor(videoConfig: VideoConfig | null);
+    /**
+     * Parses provided config
+     */
     parse(config: VideoConfig | null): void;
+    /**
+     * Returns selected scaling mode
+     */
     get scalingMode(): ScalingType;
+    /**
+     * Returns ID of the main video container
+     */
     get containerID(): string | null;
+    /**
+     * Returns video screen initial width
+     */
     get videoWidthValue(): number;
+    /**
+     * Returns whenever screen width was provided in pixels
+     */
     get videoWidthInPixels(): boolean;
+    /**
+     * Returns whenever screen width was provided in pixels
+     */
     get videoWidthProvided(): boolean;
+    /**
+     * Returns video container initial width
+     */
     get videoHeightValue(): number;
+    /**
+     * Returns video container initial width
+     */
     get videoHeightInPixels(): boolean;
+    /**
+     * Returns whenever screen width was provided in pixels
+     */
     get videoHeightProvided(): boolean;
+    /**
+     * Returns aspect ratio;
+     */
     get aspectRatio(): string;
     get resizeDebounce(): number;
     set resizeDebounce(newValue: number);
+    /**
+     * Sets new width to the player config
+     * @param newWidth
+     */
     set videoWidthValue(newWidth: number);
+    /**
+     * Sets new width to the player config
+     * @param newWidth
+     */
     set videoWidthInPixels(value: boolean);
+    /**
+     * Sets new height to the player config
+     * @param newHeight
+     */
     set videoHeightValue(newHeight: number);
+    /**
+     * Sets new width to the player config
+     * @param newWidth
+     */
     set videoHeightInPixels(value: boolean);
+    /**
+     * Sets new containerID for the player
+     * @param newContainerID
+     */
     set containerID(newContainerID: string);
+    /**
+     * Sets new scaling mode
+     * @param newScalingMode
+     */
     set scalingMode(newScalingMode: string);
     get parentSizeCalculationMethod(): SizeCalculationType;
+    /**
+     * Prints current settings
+     *
+     * @param logger
+     */
     print(logger: Logger): void;
 }

package/dist/types/config/enum/LogType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Contains all log types
+ */
 export declare enum LogType {
     TRACE = 0,
     INFO = 1,

package/dist/types/config/enum/ProtocolType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Contains all known protocol types for either source or stream itself
+ */
 export declare enum ProtocolType {
     RTMP = "RTMP",
     RTSP = "RTSP",

package/dist/types/config/enum/ScalingType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Different types of video scaling mechanisms
+ */
 export declare enum ScalingType {
     FILL = "fill",
     LETTER_BOX = "letterbox",

package/dist/types/config/enum/SecurityType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Different types of security methods for player
+ */
 export declare enum SecurityType {
     NONE = 0,
     TOKEN = 1

package/dist/types/config/enum/SizeCalculationType.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Different types of security methods for player
+ */
 export declare enum SizeCalculationType {
     CLIENT_DIMENSIONS = "clientDimensions",
     BOUNDING_BOX = "boundingBox",