ravnur-player-public 3.4.2 → 3.4.4

package/src/utils/addClass.js

@@ -0,0 +1,9 @@
+// @flow
+import hasClass from './hasClass';
+
+export default function addClass(element: HTMLElement, cls: string) {
+   if (hasClass(element, cls)) {
+      return;
+   }
+   element.className += ' ' + cls;
+}

package/src/utils/addEvent.js

@@ -0,0 +1,31 @@
+// add event cross browser
+export default function addEvent(elem, event, fn, useCapture = false) {
+   if (elem.addEventListener) {
+      elem.addEventListener(event, listenHandler, useCapture);
+      return { elem, handler: listenHandler, event };
+   }
+   elem.attachEvent('on' + event, attachHandler);
+   return { elem, handler: attachHandler, event };
+
+   // avoid memory overhead of new anonymous functions for every event handler that's installed
+   // by using local functions
+   function listenHandler(e) {
+      var ret = fn.apply(elem, arguments);
+      if (ret === false) {
+         e.stopPropagation();
+         e.preventDefault();
+      }
+      return ret;
+   }
+
+   function attachHandler() {
+      // set the this pointer same as addEventListener when fn is called
+      // and make sure the event is passed to the fn also so that works the same too
+      var ret = fn.call(elem, window.event);
+      if (ret === false) {
+         window.event.returnValue = false;
+         window.event.cancelBubble = true;
+      }
+      return ret;
+   }
+}

package/src/utils/addProperty.js

@@ -0,0 +1,65 @@
+/**
+ * add property to object
+ *
+ * @param {Object} obj     object
+ * @param {String} name    name of property
+ * @param {Function} onGet get's function
+ * @param {Function} onSet set's function
+ * @returns {void}
+ */
+export default function addProperty(obj, name, onGet, onSet) {
+
+   // wrapper functions
+   const
+      oldValue = obj[name],
+      getFn = () => onGet.apply(obj, [oldValue]),
+      setFn = newValue => onSet.apply(obj, [newValue]);
+
+   // Modern browsers, IE9+ (IE8 only works on DOM objects, not normal JS objects)
+   if (Object.defineProperty) {
+
+      Object.defineProperty(obj, name, {
+         get: getFn,
+         set: setFn
+      });
+
+      // Older Firefox
+   } else if (obj.__defineGetter__) {
+
+      obj.__defineGetter__(name, getFn);
+      obj.__defineSetter__(name, setFn);
+
+      // IE6-7
+      // must be a real DOM object (to have attachEvent) and must be attached to document (for onpropertychange to fire)
+   } else {
+
+      const onPropertyChange = (event) => {
+
+         if (event.propertyName === name) {
+
+            // temporarily remove the event so it doesn't fire again and create a loop
+            obj.detachEvent('onpropertychange', onPropertyChange);
+
+            // get the changed value, run it through the set function
+            setFn(obj[name]);
+
+            // restore the get function
+            obj[name] = getFn;
+            obj[name].toString = () => getFn().toString();
+
+            // restore the event
+            obj.attachEvent('onpropertychange', onPropertyChange);
+         }
+      };
+
+      try {
+         obj[name] = getFn;
+         obj[name].toString = () => getFn().toString();
+      } catch (ex) {
+         //
+      }
+
+      // add the property event change only once
+      obj.attachEvent('onpropertychange', onPropertyChange);
+   }
+}

package/src/utils/appendChild.js

@@ -0,0 +1,14 @@
+// @flow
+import existy from './existy';
+import isElement from './isElement';
+
+/* Append child node */
+export default function append(parent: Node, child: Node, before: ?Node) {
+   if (!parent) return;
+
+   if (existy(before) && isElement(before)) {
+      parent.insertBefore(child, before);
+   } else {
+      parent.appendChild(child);
+   }
+}

package/src/utils/buff2hex.js

@@ -0,0 +1,5 @@
+export default function buf2hex(buffer) {
+   return [...new Uint8Array(buffer)]
+      .map(x => x.toString(16).padStart(2, '0'))
+      .join(' ');
+}

package/src/utils/contains.js

@@ -0,0 +1,33 @@
+import isString from './isString';
+import isFunction from './isFunction';
+
+/**
+ * check if item contains in some array
+ *
+ * @export
+ * @param {Array|String} etalon array
+ * @param {Function|String} cond condition
+ * @returns {Boolean} `true` if item contains in array
+ */
+export default function contains(etalon, cond) {
+   if (isString(etalon) && isString(cond)) {
+      return _containsInString(etalon, cond);
+   }
+   const condFnc = isFunction(cond) ? cond : obj => obj === cond;
+   return _containsInArray(etalon, condFnc);
+}
+
+function _containsInString(string, substring) {
+   // eslint-disable-next-line no-magic-numbers
+   return string.indexOf(substring) > -1;
+}
+
+function _containsInArray(array, cond) {
+   for (let i = 0; i < array.length; i++) {
+      if (cond(array[i])) {
+         return true;
+      }
+   }
+
+   return false;
+}

package/src/utils/createElement.js

@@ -0,0 +1,24 @@
+import each from './each';
+import append from './appendChild';
+import isElement from './isElement';
+import existy from './existy';
+
+export default function createElement(tagName, props = {}, parent = null, namespace = 'http://www.w3.org/1999/xhtml') {
+
+   let el;
+   if ( existy(document.createElementNS) ) {
+      el = document.createElementNS(namespace, tagName);
+   } else {
+      el = document.createElement(tagName);
+   }
+
+   each(props, (val, key) => {
+      el.setAttribute(key, val);
+   });
+
+   if ( existy(parent) && isElement(parent) ) {
+      append(parent, el);
+   }
+
+   return el;
+}

package/src/utils/each.js

@@ -0,0 +1,34 @@
+// @flow
+// import isArray from './isArray';
+// import isObject from './isObject';
+import has from './has';
+
+type ObjMap<T> = {
+   [key: $Subtype<string>]: T
+}
+
+type Iterable<T> = Array<T> | ObjMap<T>
+type Callback<T> = (T, number | string, Iterable<T>) => void
+
+export default function each<T>(iterable: Iterable<T>, callback: Callback<T>) {
+   if (iterable instanceof Array) {
+      eachOfArray(iterable, callback);
+   } else {
+      eachOfObject(iterable, callback);
+   }
+}
+
+function eachOfObject<T>(obj: ObjMap<T>, callback: Callback<T>) {
+   // eslint-disable-next-line no-unused-vars
+   for (const key in obj) {
+      if (has(obj, key)) {
+         callback(obj[key], key, obj);
+      }
+   }
+}
+
+function eachOfArray<T>(arr: T[], callback: Callback<T>) {
+   for (let i = 0; i < arr.length; i++) {
+      callback(arr[i], i, arr);
+   }
+}

package/src/utils/escapeHTML.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {String} text text for escape
+ * @return {String} escaped text
+ */
+export default function escapeHTML(text) {
+   return text.toString().split('&').join('&amp;').split('<').join('&lt;').split('"').join('&quot;');
+}

package/src/utils/existy.js

@@ -0,0 +1,4 @@
+export default function existy(arg) {
+   // eslint-disable-next-line
+   return arg != null;
+}

package/src/utils/extend.js

@@ -0,0 +1,17 @@
+import each from './each';
+import notExisty from './notExisty';
+
+// Merge the contents of two or more objects together into the first object
+export default function extend(target, ...args) {
+   each(args, options => {
+      if (notExisty(options)) {
+         return;
+      }
+      each(options, (val, key) => {
+         target[key] = val;
+      });
+   });
+
+   // Return the modified object
+   return target;
+}

package/src/utils/filter.js

@@ -0,0 +1,16 @@
+// @flow
+
+import isNotEmpty from './isNotEmpty';
+import each from './each';
+
+export default function filter<T>(array: T[], cond?: (T) => boolean = isNotEmpty): T[] {
+   const res = [];
+
+   each(array, o => {
+      if (cond(o)) {
+         res.push(o);
+      }
+   });
+
+   return res;
+}

package/src/utils/find.js

@@ -0,0 +1,11 @@
+// @flow
+export default function find<T>(array: T[], cond: (T) => boolean ): ?T {
+   for (let i = 0; i < array.length; i++) {
+      const item = array[i];
+      if (cond(item)) {
+         return item;
+      }
+   }
+
+   return null;
+}

package/src/utils/findIndex.js

@@ -0,0 +1,20 @@
+import isFunction from './isFunction';
+
+const NON_FOUND_IDX = -1;
+
+/**
+ * Find index of element by condition
+ * @export
+ * @param {Array} array array
+ * @param {Function|Object} condition some condition
+ * @returns {Number} index of object, or `-1` if cond not returned true
+ */
+export default function findIndex(array, condition) {
+   const cond = isFunction(condition) ? condition : (c) => c === condition;
+   for (let i = 0; i < array.length; i++) {
+      if (cond(array[i])) {
+         return i;
+      }
+   }
+   return NON_FOUND_IDX;
+}

package/src/utils/first.js

@@ -0,0 +1,5 @@
+const FIRST_ID = 0;
+
+export default function first(arr) {
+   return arr[FIRST_ID];
+}

package/src/utils/get.js

@@ -0,0 +1,19 @@
+import existy from './existy';
+
+/**
+ * Get valur fromm object by path
+ * @export
+ * @param {Object} source  object
+ * @param {String} path    path to props (use `.` as delim)
+ * @param {any}    defaultValue return this attr if result is not exists
+ * @returns {any} value
+ */
+export default function get(source, path = '', defaultValue = null) {
+   const pathes = path.split('.');
+
+   while (existy(source) && pathes.length) {
+      source = source[pathes.shift()];
+   }
+
+   return existy(source) ? source : defaultValue;
+}

package/src/utils/has.js

@@ -0,0 +1,5 @@
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export default function has(obj, prop) {
+   return hasOwn.call(obj, prop);
+}

package/src/utils/hasClass.js

@@ -0,0 +1,6 @@
+// @flow
+export default function hasClass(element: HTMLElement, cls: string) {
+   if (!element) return false;
+
+   return !!element.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
+}

package/src/utils/head.js

@@ -0,0 +1,11 @@
+const HEAD_IDX = 0;
+
+/**
+ * Get first element from array
+ * @export
+ * @param {Array} arr array
+ * @returns {any} first element
+ */
+export default function head(arr) {
+   return arr[HEAD_IDX];
+}

package/src/utils/inRange.js

@@ -0,0 +1,16 @@
+const DEFAULT_MIN = 0;
+const DEFAULT_MAX = Number.MAX_VALUE;
+
+/**
+ * Checks if n is between start and up to, but not including, end. If end is not specified,
+ * it's set to start with start then set to 0.
+ * If start is greater than end the params are swapped to support negative ranges.
+ * @export
+ * @param {number} number     The number to check.
+ * @param {number} [from=0]   The start of the range.
+ * @param {number} [to]       The end of the range.
+ * @returns {Boolean}  Returns true if number is in the range, else false.
+ */
+export default function inRange(number, from = DEFAULT_MIN, to = DEFAULT_MAX) {
+   return number >= from && number < to;
+}

package/src/utils/index.js

@@ -0,0 +1,73 @@
+// @flow
+import isElement from './isElement';
+import isArray from './isArray';
+import isObject from './isObject';
+import isString from './isString';
+import isFunction from './isFunction';
+import isBoolean from './isBoolean';
+import isEqual from './isEqual';
+import isEqualBuffer from './isEqualBuffer';
+
+// utils
+import noop from './noop';
+import inRange from './inRange';
+import existy from './existy';
+import negate from './negate';
+import notExisty from './notExisty';
+import isEmpty from './isEmpty';
+import isNotEmpty from './isNotEmpty';
+import absolutizeUrl from './absolutizeUrl';
+import escapeHTML from './escapeHTML';
+import uidGenerator from './uidGenerator';
+
+// DOM
+import createElement from './createElement';
+import addEvent from './addEvent';
+import removeEvent from './removeEvent';
+import addClass from './addClass';
+import hasClass from './hasClass';
+import removeClass from './removeClass';
+import toggleClass from './toggleClass';
+import append from './appendChild';
+
+// collections
+import each from './each';
+import contains from './contains';
+import filter from './filter';
+import find from './find';
+import map from './map';
+
+// array
+import head from './head';
+import last from './last';
+import first from './first';
+import findIndex from './findIndex';
+import remove from './remove';
+import toArray from './toArray';
+import reduce from './reduce';
+
+// Object
+import has from './has';
+import extend from './extend';
+import get from './get';
+import addProperty from './addProperty';
+
+// String
+import upperFirst from './upperFirst';
+
+export {
+   isArray, isElement, isObject, isString, isFunction, isBoolean, isEqual, isEqualBuffer,
+
+   noop, existy, negate, notExisty, isEmpty, isNotEmpty, inRange, absolutizeUrl, escapeHTML,
+   uidGenerator,
+
+   createElement, append, addEvent, removeEvent, hasClass, addClass, removeClass, toggleClass,
+
+   each, contains, filter, find, map, reduce,
+
+   head, findIndex, first, last, remove, toArray,
+
+   has, extend, get, addProperty,
+
+   upperFirst
+};

package/src/utils/isArray.js

@@ -0,0 +1,4 @@
+// @flow
+export default function isArray(arr: mixed): boolean {
+   return Array.isArray(arr);
+}

package/src/utils/isBoolean.js

@@ -0,0 +1,3 @@
+export default function isBoolean(b) {
+   return b === true || b === false;
+}

package/src/utils/isElement.js

@@ -0,0 +1,7 @@
+export default function isElement(node) {
+   try {
+      return node instanceof Element;
+   } catch (e) {
+      return !!node.nodeName;
+   }
+}

package/src/utils/isEmpty.js

@@ -0,0 +1,6 @@
+// @flow
+import notExisty from './notExisty';
+
+export default function isEmpty(val: mixed): boolean {
+   return notExisty(val) || val instanceof Array && !val.length || typeof val === 'string' && !val.length;
+}

package/src/utils/isEqual.js

@@ -0,0 +1,33 @@
+import isArray from './isArray';
+import contains from './contains';
+import isObject from './isObject';
+import reduce from './reduce';
+
+export default function isEqual(value, other) {
+   if (value === other) {
+      return true;
+   }
+
+   if ( isArray(value) && isArray(other) ) {
+      if ( value.length !== other.length ) {
+         return false;
+      }
+
+      return reduce(value, (memo, o) => memo && contains(other, o), true);
+   }
+
+   if ( isObject(value) && isObject(other) ) {
+      const valueKeys = Object.keys(value);
+      const otherKeys = Object.keys(other);
+
+      if ( !isEqual(valueKeys, otherKeys) ) {
+         return false;
+      }
+
+      return reduce(value, (memo, v, k) => {
+         return memo && isEqual(v, other[k]);
+      }, true);
+   }
+
+   return false;
+}

package/src/utils/isEqualBuffer.js

@@ -0,0 +1,13 @@
+export default function isEqualBuffer(value, other) {
+   if (value.byteLength !== other.byteLength) {
+      return false;
+   }
+
+   for (let i = 0; i < value.length; i++) {
+      if (value[i] !== other[i]) {
+         return false;
+      }
+   }
+
+   return true;
+}

package/src/utils/isFunction.js

@@ -0,0 +1,3 @@
+export default function isFunction(obj) {
+   return typeof obj === 'function';
+}

package/src/utils/isNotEmpty.js

@@ -0,0 +1,5 @@
+// @flow
+import isEmpty from './isEmpty';
+import negate from './negate';
+
+export default negate(isEmpty);

package/src/utils/isObject.js

@@ -0,0 +1,5 @@
+import isArray from './isArray';
+
+export default function isObject(obj) {
+   return obj && typeof obj === 'object' && isArray(obj) === false;
+}

package/src/utils/isString.js

@@ -0,0 +1,9 @@
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ */
+export default function isString(value) {
+   return typeof value === 'string';
+}

package/src/utils/last.js

@@ -0,0 +1,4 @@
+export default function last(arr) {
+   // eslint-disable-next-line no-magic-numbers
+   return arr[arr.length - 1];
+}

package/src/utils/map.js

@@ -0,0 +1,11 @@
+// @flow
+import each from './each';
+
+type Callback<T, K> = (T, number, Array<T>) => K
+
+export default function map<T, K>(array: Array<T>, callback: Callback<T, K>): Array<K> {
+   const memo = [];
+   // $FlowFixMe
+   each(array, (val, key, arr) => memo.push(callback(val, key, arr)) );
+   return memo;
+}

package/src/utils/negate.js

@@ -0,0 +1,8 @@
+// @flow
+
+export default function negate(predicate: (any) => boolean): (any) => boolean {
+   return (e: any) => {
+      return !predicate(e);
+      // return !predicate.apply(null, args);
+   };
+}

package/src/utils/noop.js

@@ -0,0 +1 @@
+export default function noop() { /* */ }

package/src/utils/notExisty.js

@@ -0,0 +1,5 @@
+// @flow
+import existy from './existy';
+import negate from './negate';
+
+export default negate(existy);

package/src/utils/reduce.js

@@ -0,0 +1,8 @@
+import each from './each';
+
+export default function reduce(iterable, callback, memo = null) {
+   each( iterable, (val, key, it) => {
+      memo = callback(memo, val, key, it);
+   });
+   return memo;
+}

package/src/utils/remove.js

@@ -0,0 +1,7 @@
+/* eslint no-magic-numbers: 0 */
+export default function remove(array, item) {
+   const idx = array.indexOf(item);
+   if ( idx >= 0 ) {
+      array.splice(idx, 1);
+   }
+}

package/src/utils/removeClass.js

@@ -0,0 +1,8 @@
+import hasClass from './hasClass';
+
+export default function removeClass(element, cls) {
+   if (hasClass(element, cls)) {
+      var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
+      element.className = element.className.replace(reg, ' ').trim();
+   }
+}

package/src/utils/removeEvent.js

@@ -0,0 +1,7 @@
+export default function removeEvent(token) {
+   if (token.elem.removeEventListener) {
+      token.elem.removeEventListener(token.event, token.handler);
+   } else {
+      token.elem.detachEvent('on' + token.event, token.handler);
+   }
+}

package/src/utils/toArray.js

@@ -0,0 +1,7 @@
+export default function toArray(arrayLike) {
+   const res = [];
+   for (let i = 0; i < arrayLike.length; i++) {
+      res.push(arrayLike[i]);
+   }
+   return res;
+}

package/src/utils/toggleClass.js

@@ -0,0 +1,16 @@
+import hasClass from './hasClass';
+import addClass from './addClass';
+import removeClass from './removeClass';
+import notExisty from './notExisty';
+
+export default function toggleClass(el, className, state) {
+   if ( notExisty(state) ) {
+      state = !hasClass(el, className);
+   }
+
+   if (state) {
+      addClass(el, className);
+   } else {
+      removeClass(el, className);
+   }
+}