ravnur-player-public 3.4.3 → 3.4.4

package/src/flash-detector.js

@@ -0,0 +1,66 @@
+/* eslint-disable */
+
+
+const NAV = window.navigator;
+
+const PluginDetector = {
+   plugins: [],
+
+   hasPluginVersion: (plugin, v) => {
+      const pv = PluginDetector.plugins[plugin];
+      v[1] = v[1] || 0;
+      v[2] = v[2] || 0;
+      return (pv[0] > v[0] || (pv[0] === v[0] && pv[1] > v[1]) || (pv[0] === v[0] && pv[1] === v[1] && pv[2] >= v[2]));
+   },
+
+   addPlugin: (p, pluginName, mimeType, activeX, axDetect) => {
+      PluginDetector.plugins[p] = PluginDetector.detectPlugin(pluginName, mimeType, activeX, axDetect);
+   },
+
+   detectPlugin: (pluginName, mimeType, activeX, axDetect) => {
+
+      let
+         version = [0, 0, 0],
+         description,
+         ax
+         ;
+
+      // Firefox, Webkit, Opera; avoid MS Edge since `plugins` cannot be accessed
+      if (NAV.plugins !== null && NAV.plugins !== undefined && typeof NAV.plugins[pluginName] === 'object') {
+         description = NAV.plugins[pluginName].description;
+         if (description && !(typeof NAV.mimeTypes !== 'undefined' && NAV.mimeTypes[mimeType] && !NAV.mimeTypes[mimeType].enabledPlugin)) {
+            version = description.replace(pluginName, '').replace(/^\s+/, '').replace(/\sr/gi, '.').split('.');
+            for (let i = 0, total = version.length; i < total; i++) {
+               version[i] = parseInt(version[i].match(/\d+/), 10);
+            }
+         }
+         // Internet Explorer / ActiveX
+      } else if (window.ActiveXObject !== undefined) {
+         try {
+            ax = new ActiveXObject(activeX);
+            if (ax) {
+               version = axDetect(ax);
+            }
+         } catch (e) {
+            console.log(e);
+         }
+      }
+      return version;
+   }
+};
+
+PluginDetector.addPlugin('flash', 'Shockwave Flash', 'application/x-shockwave-flash', 'ShockwaveFlash.ShockwaveFlash', (ax) => {
+   // adapted from SWFObject
+   let
+      version = [],
+      d = ax.GetVariable("$version")
+      ;
+
+   if (d) {
+      d = d.split(" ")[1].split(",");
+      version = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
+   }
+   return version;
+});
+
+export default PluginDetector.hasPluginVersion('flash', [10, 0, 0]);

package/src/helpers/$t.js

@@ -0,0 +1,10 @@
+// @flow
+
+import DEFAULT_I18N from '../config/i18n';
+
+import type { Player$Translation } from '../types/Translation';
+
+export default function $t(i18n: ?$Shape<Player$Translation> = {}, key: $Keys<Player$Translation>): string {
+   const val: ?string = i18n ? i18n[key] : null;
+   return val || DEFAULT_I18N[key];
+}

package/src/helpers/binder.js

@@ -0,0 +1,11 @@
+// $Flow
+
+import Entity from '../entity';
+
+import each from '../utils/each';
+
+export default function binder(ctx: Entity, funcs: string[]) {
+   each(funcs, fn => {
+      ctx[fn] = ctx[fn].bind(ctx);
+   });
+}

package/src/helpers/isAndroid.js

@@ -0,0 +1,5 @@
+// @flow
+
+export default function isAndroid() {
+   return !!navigator.userAgent.match(/Android/i);
+}

package/src/helpers/isBlackBerry.js

@@ -0,0 +1,5 @@
+// @flow
+
+export default function isBlackBerry() {
+   return !!navigator.userAgent.match(/(BlackBerry|BB10)/i);
+}

package/src/helpers/isCanvasSupported.js

@@ -0,0 +1,6 @@
+// @flow
+
+export default function isCanvasSupported() {
+   const elem = document.createElement('canvas');
+   return !!(elem.getContext && elem.getContext('2d'));
+}

package/src/helpers/isIE.js

@@ -0,0 +1,21 @@
+// @flow
+
+const IE_8 = 8;
+const NOT_FOUND_IDX = -1;
+
+export default function isIE(): false | number {
+   const na = navigator.userAgent.toLowerCase();
+   return na.indexOf('msie') === NOT_FOUND_IDX ? false : parseInt(na.split('msie')[1], 10);
+}
+
+export function isIE8() {
+   return isIE() === IE_8;
+}
+
+export function isEdge() {
+   return 'msLaunchUri' in window.navigator && !('documentMode' in document);
+}
+
+export function isIE11() {
+   return  !!window.MSInputMethodContext && !!document.documentMode;
+}

package/src/helpers/isMobile.js

@@ -0,0 +1,10 @@
+// @flow
+
+import isAndroid from './isAndroid';
+import isiOS from './isiOS';
+import isBlackBerry from './isBlackBerry';
+import isWindowsPhone from './isWindowsPhone';
+
+export default function isMobile() {
+   return isAndroid() || isiOS() || isBlackBerry() || isWindowsPhone();
+}

package/src/helpers/isWindows.js

@@ -0,0 +1,5 @@
+// @flow
+
+export function isWindows10() {
+   return !!navigator.userAgent.match(/(Windows NT 10)/i);
+}

package/src/helpers/isWindowsPhone.js

@@ -0,0 +1,5 @@
+// @flow
+
+export default function isWindowsPhone() {
+   return !!navigator.userAgent.match(/(IEMobile|Windows Phone)/i);
+}

package/src/helpers/isiOS.js

@@ -0,0 +1,5 @@
+// @flow
+
+export default function isiOS() {
+   return !!navigator.userAgent.match(/(iPad|iPhone|iPod)/g);
+}

package/src/html5media.js

@@ -0,0 +1,19 @@
+export const properties = [
+   // GET/SET
+   'volume', 'src', 'currentTime', 'muted',
+
+   // GET only
+   'duration', 'paused', 'ended', 'levels', 'currentLevel',
+
+   // SET only
+   'level',
+
+   // OTHERS
+   'error', 'currentSrc', 'networkState', 'preload', 'buffered', 'bufferedBytes', 'bufferedTime',
+   'readyState', 'seeking', 'initialTime', 'startOffsetTime', 'defaultPlaybackRate', 'playbackRate',
+   'played', 'seekable', 'autoplay', 'loop', 'controls'
+];
+
+export const methods = [
+   'load', 'play', 'pause', 'canPlayType'
+];

package/src/index.js

@@ -0,0 +1,2 @@
+import Player from './player';
+export default Player;

package/src/logger.js

@@ -0,0 +1,31 @@
+// @flow
+import { noop, isFunction } from './utils';
+
+import type { Player$Logger } from './types/Logger';
+
+/* eslint no-console:0 */
+
+export type Level = 0 | 1 | 2 | 3 | 4
+
+const DEFAULT_LOG_LEVEL: Level = 2;
+
+function _createLog(type: $Keys<Player$Logger>) {
+   return window.console ? _inner : noop;
+
+   function _inner(...args: Array<mixed>) {
+      if (type in console && isFunction(console[type])) {
+         args.unshift( (new Date()).toString() );
+         console[type].apply(console, args);
+      }
+   }
+}
+
+export default function createLogger(level: Level = DEFAULT_LOG_LEVEL): Player$Logger {
+   let idx = 1;
+   const logger = {};
+   logger.debug = ++idx > level ? _createLog('debug') : noop;
+   logger.log   = ++idx > level ? _createLog('log')   : noop;
+   logger.warn  = ++idx > level ? _createLog('warn' ) : noop;
+   logger.error = ++idx > level ? _createLog('error') : noop;
+   return logger;
+}

package/src/microevent.js

@@ -0,0 +1,65 @@
+// @flow
+import remove from './utils/remove';
+
+type Callback = {
+   // eslint-disable-next-line
+   <T>(...args: Array<T>): mixed,
+   _safe_inner?: boolean
+};
+
+export default class MicroEvent {
+   _events: { [key: string]: Callback[] } = {}
+
+   on(event: string, fct: Callback) {
+      this._events[event] = this._events[event] || [];
+      this._events[event].push(fct);
+   }
+
+   off(event: string, fct: Callback) {
+      this._events = this._events || {};
+      if ( event in this._events === false  ) {
+         return;
+      }
+      remove(this._events[event], fct);
+   }
+
+   once(event: string, fct: Callback) {
+      const callback = (...args: Array<mixed>) => {
+         this._call(fct, args);
+         this.off(event, callback);
+      };
+
+      this.on(event, callback);
+   }
+
+   emit(event: string, ...args: Array<mixed>) {
+      if ( event !== '*' ) {
+         // $FlowFixMe
+         this.emit.apply(this, ['*', event].concat(args));
+      }
+
+      this._events = this._events || {};
+      if ( event in this._events === false ) {
+         return;
+      }
+      for (var i = this._events[event].length - 1; i >= 0; i--) {
+         this._call(this._events[event][i], args);
+      }
+   }
+
+   destroy() {
+      this._events = {};
+   }
+
+   _call<T>(fnc: Callback, args: Array<T>) {
+      if (fnc._safe_inner) {
+         fnc.apply(this, args);
+      } else {
+         try {
+            fnc.apply(this, args);
+         } catch (e) {
+            console.error(e); // eslint-disable-line
+         }
+      }
+   }
+}

package/src/normalize-options.js

@@ -0,0 +1,139 @@
+// @flow
+
+import { getPlayerType, FLASH_TYPE } from './players';
+
+import { extend, existy, notExisty, isNotEmpty, contains } from './utils';
+
+import type { Player$CombineOptions, Player$InputOptions } from './types/Options';
+
+import isMobile from './helpers/isMobile';
+import isAndroid from './helpers/isAndroid';
+import isCanvasSupported from './helpers/isCanvasSupported';
+import { isIE8 } from './helpers/isIE';
+import { isWindows10 } from './helpers/isWindows';
+import isiOS from './helpers/isiOS';
+
+import SOURCE_OPTIONS from './config/source';
+
+const AUDIO_TYPES = [ 'audio/mp3', 'audio/mpeg', 'audio/mp4' ];
+
+// eslint-disable-next-line
+export default function normalize(common: $Shape<Player$InputOptions>, options: $Shape<Player$CombineOptions>): $Shape<Player$CombineOptions> {
+   options =  extend({}, SOURCE_OPTIONS, common, options);
+   const custom: $Shape<Player$CombineOptions> = {
+      showAnnotations: existy(options.showAnnotations) ? options.showAnnotations : true,
+      showQuality: existy(options.showQuality) ? options.showQuality : true,
+      showPlaceholder: existy(options.showPlaceholder) ? options.showPlaceholder : true
+   };
+
+   custom.showPoster = options.showPoster && existy(options.poster);
+
+   if (options.showHelp) {
+      custom.showHelp = isCanvasSupported();
+   }
+
+   if (_isAudio(options.type) || options.isAudio) {
+      custom.showFullScreen = false;
+      custom.showClosedCaptions = false;
+      custom.showTOC = false;
+      custom.showAnnotations = false;
+      custom.showQuality = false;
+      custom.isAudio = true;
+      // =(
+      // options.showSettings = false;
+   }
+
+   if (isMobile()) {
+      custom.showVolume = false;
+      custom.showQuality = false;
+      custom.showHelp = false;
+      custom.preview = null;
+      custom.showTitle = false;
+      custom.showCCLayout = false;
+      custom.isMobile = true;
+
+      custom.extensionsVisibilityTimeout = 4000;
+   }
+
+   if (isAndroid()) {
+      custom.showPlaybackRate = false;
+   }
+
+   if (isIE8()) {
+      custom.showCCLayout = false;
+      custom.useMux = false;
+   }
+
+   if (!options.startTime && isiOS()) {
+      custom.startTime = 0.5;
+   }
+
+   if (notExisty(options.annotations)) {
+      custom.showAnnotations = false;
+   }
+
+   if (options.startTime && !custom.isAudio) {
+      custom.showPoster = false;
+   }
+
+   const type = getPlayerType(options);
+   if (type === FLASH_TYPE) {
+      custom.showPlaybackRate = false;
+   }
+
+   // if (options.showClosedCaptions) {
+   //    custom.showClosedCaptions = existy(options.cc) && isNotEmpty(options.cc);
+   // }
+
+   // if (options.showTOC) {
+   //    custom.showTOC = existy(options.chapters) && isNotEmpty(options.chapters);
+   // }
+
+   if (options.showAnnotations) {
+      custom.showAnnotations = existy(options.annotations) && isNotEmpty(options.annotations);
+   }
+
+   if ( custom.showAnnotations === false && custom.showPlaybackRate === false && custom.showQuality === false ) {
+      custom.showSettings = false;
+      options.showSettings = false;
+   }
+
+   custom.showDownloadCC = options.showDownloadCC && existy(options.cc) && isNotEmpty(options.cc);
+
+   if (options.showDownloadVideo) {
+      custom.showDownloadVideo = isWindows10() && existy(options.downloadURL) && isNotEmpty(options.downloadURL);
+   }
+
+   custom.showDownload = options.showDownload && (custom.showDownloadVideo || custom.showDownloadCC || !!options.downloadVideoURL);
+
+   custom.showCaptionSearch = options.showCaptionSearch && existy(options.cc) && isNotEmpty(options.cc);
+
+   if (!options.showExtensions) {
+      custom.showPlay = false;
+      custom.showProgress = false;
+      custom.showVolume = false;
+      custom.showFullScreen = false;
+      custom.showClosedCaptions = false;
+      custom.showTOC = false;
+      custom.showAnnotations = false;
+      custom.showQuality = false;
+      custom.showPoster = false;
+      custom.showPlaceholder = false;
+      custom.showPlaybackRate = false;
+      custom.showForward = false;
+      custom.showBackward = false;
+      custom.showSettings = false;
+      custom.showDownload = false;
+      custom.showHelp = false;
+      custom.showTitle = false;
+      custom.showNext = false;
+   }
+
+   const res = extend(options, custom);
+
+   return res;
+}
+
+function _isAudio(type) {
+   return contains(AUDIO_TYPES, type);
+}