@lahzenegar/video-react/lib/actions/video.js

Video-React is a web video player built from the ground up for an HTML5 world using React library.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.handleAdError = handleAdError;
exports.handleAllAdsCompleted = handleAllAdsCompleted;
exports.handleAdStart = handleAdStart;
exports.handleAdEnded = handleAdEnded;
exports.handleContentLoading = handleContentLoading;
exports.handleLoadStart = handleLoadStart;
exports.handleCanPlay = handleCanPlay;
exports.handleWaiting = handleWaiting;
exports.handleCanPlayThrough = handleCanPlayThrough;
exports.handlePlaying = handlePlaying;
exports.handlePlay = handlePlay;
exports.handlePause = handlePause;
exports.handleEnd = handleEnd;
exports.handleSeeking = handleSeeking;
exports.handleSeeked = handleSeeked;
exports.handleDurationChange = handleDurationChange;
exports.handleTimeUpdate = handleTimeUpdate;
exports.handleVolumeChange = handleVolumeChange;
exports.handleProgressChange = handleProgressChange;
exports.handleRateChange = handleRateChange;
exports.handleSuspend = handleSuspend;
exports.handleAbort = handleAbort;
exports.handleEmptied = handleEmptied;
exports.handleStalled = handleStalled;
exports.handleLoadedMetaData = handleLoadedMetaData;
exports.handleLoadedData = handleLoadedData;
exports.handleResize = handleResize;
exports.handleError = handleError;
exports.handleMediaStateChange = handleMediaStateChange;
exports.handleMediaLatencyChange = handleMediaLatencyChange;
exports.handleLoadLevels = handleLoadLevels;
exports.handleManifestParsed = handleManifestParsed;
exports.handleRealTrackChange = handleRealTrackChange;
exports.handleTrackChange = handleTrackChange;
exports.handleSeekingTime = handleSeekingTime;
exports.handleEndSeeking = handleEndSeeking;
var LOAD_START = exports.LOAD_START = 'video-react/LOAD_START';
var CAN_PLAY = exports.CAN_PLAY = 'video-react/CAN_PLAY';
var WAITING = exports.WAITING = 'video-react/WAITING';
var CAN_PLAY_THROUGH = exports.CAN_PLAY_THROUGH = 'video-react/CAN_PLAY_THROUGH';
var PLAYING = exports.PLAYING = 'video-react/PLAYING';
var PLAY = exports.PLAY = 'video-react/PLAY';
var PAUSE = exports.PAUSE = 'video-react/PAUSE';
var END = exports.END = 'video-react/END';
var SEEKING = exports.SEEKING = 'video-react/SEEKING';
var SEEKED = exports.SEEKED = 'video-react/SEEKED';
var SEEKING_TIME = exports.SEEKING_TIME = 'video-react/SEEKING_TIME';
var END_SEEKING = exports.END_SEEKING = 'video-react/END_SEEKING';
var DURATION_CHANGE = exports.DURATION_CHANGE = 'video-react/DURATION_CHANGE';
var TIME_UPDATE = exports.TIME_UPDATE = 'video-react/TIME_UPDATE';
var VOLUME_CHANGE = exports.VOLUME_CHANGE = 'video-react/VOLUME_CHANGE';
var PROGRESS_CHANGE = exports.PROGRESS_CHANGE = 'video-react/PROGRESS_CHANGE';
var RATE_CHANGE = exports.RATE_CHANGE = 'video-react/RATE_CHANGE';
var SUSPEND = exports.SUSPEND = 'video-react/SUSPEND';
var ABORT = exports.ABORT = 'video-react/ABORT';
var EMPTIED = exports.EMPTIED = 'video-react/EMPTIED';
var STALLED = exports.STALLED = 'video-react/STALLED';
var LOADED_META_DATA = exports.LOADED_META_DATA = 'video-react/LOADED_META_DATA';
var LOADED_DATA = exports.LOADED_DATA = 'video-react/LOADED_DATA';
var RESIZE = exports.RESIZE = 'video-react/RESIZE';
var ERROR = exports.ERROR = 'video-react/ERROR';
var MEDIA_STATE_CHANGE = exports.MEDIA_STATE_CHANGE = 'video-react/MEDIA_STATE_CHANGE';
var MEDIA_LATENCY_CHANGE = exports.MEDIA_LATENCY_CHANGE = 'video-react/MEDIA_LATENCY_CHANGE';
var LOADED_LEVELS = exports.LOADED_LEVELS = 'video-react/LOADED_LEVELS';
var TRACK_CHANGE = exports.TRACK_CHANGE = 'video-react/TRACK_CHANGE';
var REAL_TRACK_CHANGE = exports.REAL_TRACK_CHANGE = 'video-react/REAL_TRACK_CHANGE';
var MANIFEST_PARSED = exports.MANIFEST_PARSED = 'video-react/MANIFEST_PARSED';
var AD_START = exports.AD_START = 'video-react/AD_START';
var ALL_ADS_COMPLETED = exports.ALL_ADS_COMPLETED = 'video-react/ALL_ADS_COMPLETED';
var AD_ERROR = exports.AD_ERROR = 'video-react/AD_ERROR';
var AD_LOAD = exports.AD_LOAD = 'video-react/AD_LOAD';
var AD_ENDED = exports.AD_ENDED = 'video-react/AD_ENDED';
var CONTENT_LOADING_STARTED = exports.CONTENT_LOADING_STARTED = 'video-react/CONTENT_LOADING_STARTED';
var CONTENT_LOADING_ENDED = exports.CONTENT_LOADING_ENDED = 'video-react/CONTENT_LOADING_ENDED';

function handleAdError() {
  return {
    type: AD_ERROR
  };
}

function handleAllAdsCompleted() {
  return {
    type: ALL_ADS_COMPLETED
  };
}

function handleAdStart() {
  return {
    type: AD_START
  };
}

function handleAdEnded() {
  return {
    type: AD_ENDED
  };
}

function handleContentLoading() {
  var contentLoading = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

  return {
    type: contentLoading ? CONTENT_LOADING_STARTED : CONTENT_LOADING_ENDED
  };
}

function handleLoadStart(videoProps) {
  return {
    type: LOAD_START,
    videoProps: videoProps
  };
}

function handleCanPlay(videoProps, delayToStartPlaying, waitingDuration) {
  return {
    type: CAN_PLAY,
    videoProps: videoProps,
    waitingDuration: waitingDuration,
    delayToStartPlaying: delayToStartPlaying
  };
}

function handleWaiting(videoProps) {
  return {
    type: WAITING,
    videoProps: videoProps
  };
}

function handleCanPlayThrough(videoProps) {
  return {
    type: CAN_PLAY_THROUGH,
    videoProps: videoProps
  };
}

function handlePlaying(videoProps) {
  return {
    type: PLAYING,
    videoProps: videoProps
  };
}

function handlePlay(videoProps) {
  return {
    type: PLAY,
    videoProps: videoProps
  };
}

function handlePause(videoProps) {
  return {
    type: PAUSE,
    videoProps: videoProps
  };
}

function handleEnd(videoProps) {
  return {
    type: END,
    videoProps: videoProps
  };
}

function handleSeeking(videoProps) {
  return {
    type: SEEKING,
    videoProps: videoProps
  };
}

function handleSeeked(videoProps) {
  return {
    type: SEEKED,
    videoProps: videoProps
  };
}

function handleDurationChange(videoProps) {
  return {
    type: DURATION_CHANGE,
    videoProps: videoProps
  };
}

function handleTimeUpdate(videoProps, secondsPlayed, percentPlayed, waitingTime) {
  return {
    type: TIME_UPDATE,
    videoProps: videoProps,
    secondsPlayed: secondsPlayed,
    percentPlayed: percentPlayed,
    waitingTime: waitingTime
  };
}

function handleVolumeChange(videoProps) {
  return {
    type: VOLUME_CHANGE,
    videoProps: videoProps
  };
}

function handleProgressChange(videoProps) {
  return {
    type: PROGRESS_CHANGE,
    videoProps: videoProps
  };
}

function handleRateChange(videoProps) {
  return {
    type: RATE_CHANGE,
    videoProps: videoProps
  };
}

function handleSuspend(videoProps) {
  return {
    type: SUSPEND,
    videoProps: videoProps
  };
}

function handleAbort(videoProps) {
  return {
    type: ABORT,
    videoProps: videoProps
  };
}

function handleEmptied(videoProps) {
  return {
    type: EMPTIED,
    videoProps: videoProps
  };
}

function handleStalled(videoProps) {
  return {
    type: STALLED,
    videoProps: videoProps
  };
}

function handleLoadedMetaData(videoProps) {
  return {
    type: LOADED_META_DATA,
    videoProps: videoProps
  };
}

function handleLoadedData(videoProps) {
  return {
    type: LOADED_DATA,
    videoProps: videoProps
  };
}

function handleResize(videoProps) {
  return {
    type: RESIZE,
    videoProps: videoProps
  };
}

function handleError(videoProps) {
  return {
    type: ERROR,
    videoProps: videoProps
  };
}

function handleMediaStateChange(hasDVR, isLive, mediaDuration, playOffset) {
  return {
    type: MEDIA_STATE_CHANGE,
    hasDVR: hasDVR,
    isLive: isLive,
    mediaDuration: mediaDuration,
    playOffset: playOffset
  };
}

function handleMediaLatencyChange(liveTime, latency) {
  return {
    type: MEDIA_LATENCY_CHANGE,
    liveTime: liveTime,
    latency: latency
  };
}

function handleLoadLevels(tracks) {
  return {
    type: LOADED_LEVELS,
    tracks: tracks
  };
}

function handleManifestParsed(hls) {
  return {
    type: MANIFEST_PARSED,
    hls: hls
  };
}

function handleRealTrackChange(realActiveTrack, switchingTrack) {
  return {
    type: REAL_TRACK_CHANGE,
    realActiveTrack: realActiveTrack,
    switchingTrack: switchingTrack
  };
}

function handleTrackChange(activeTrack) {
  return {
    type: TRACK_CHANGE,
    activeTrack: activeTrack
  };
}

function handleSeekingTime(time) {
  return {
    type: SEEKING_TIME,
    time: time
  };
}

function handleEndSeeking(time) {
  return {
    type: END_SEEKING,
    time: time
  };
}