uikit 3.11.2-dev.31cd2ba38 → 3.11.2-dev.3dfa2c50b

package/src/js/util/options.js

@@ -1,14 +1,24 @@
-import {assign, hasOwn, includes, isArray, isFunction, isUndefined, sortBy} from './lang';
+import {
+    assign,
+    hasOwn,
+    includes,
+    isArray,
+    isFunction,
+    isUndefined,
+    sortBy,
+    startsWith,
+} from './lang';
 
 const strats = {};
 
 strats.events =
-strats.created =
-strats.beforeConnect =
-strats.connected =
-strats.beforeDisconnect =
-strats.disconnected =
-strats.destroy = concatStrat;
+    strats.created =
+    strats.beforeConnect =
+    strats.connected =
+    strats.beforeDisconnect =
+    strats.disconnected =
+    strats.destroy =
+        concatStrat;
 
 // args strategy
 strats.args = function (parentVal, childVal) {
@@ -17,37 +27,33 @@ strats.args = function (parentVal, childVal) {
 
 // update strategy
 strats.update = function (parentVal, childVal) {
-    return sortBy(concatStrat(parentVal, isFunction(childVal) ? {read: childVal} : childVal), 'order');
+    return sortBy(
+        concatStrat(parentVal, isFunction(childVal) ? { read: childVal } : childVal),
+        'order'
+    );
 };
 
 // property strategy
 strats.props = function (parentVal, childVal) {
-
     if (isArray(childVal)) {
-        childVal = childVal.reduce((value, key) => {
+        const value = {};
+        for (const key of childVal) {
             value[key] = String;
-            return value;
-        }, {});
+        }
+        childVal = value;
     }
 
     return strats.methods(parentVal, childVal);
 };
 
 // extend strategy
-strats.computed =
-strats.methods = function (parentVal, childVal) {
-    return childVal
-        ? parentVal
-            ? assign({}, parentVal, childVal)
-            : childVal
-        : parentVal;
+strats.computed = strats.methods = function (parentVal, childVal) {
+    return childVal ? (parentVal ? assign({}, parentVal, childVal) : childVal) : parentVal;
 };
 
 // data strategy
 strats.data = function (parentVal, childVal, vm) {
-
     if (!vm) {
-
         if (!childVal) {
             return parentVal;
         }
@@ -59,7 +65,6 @@ strats.data = function (parentVal, childVal, vm) {
         return function (vm) {
             return mergeFnData(parentVal, childVal, vm);
         };
-
     }
 
     return mergeFnData(parentVal, childVal, vm);
@@ -67,26 +72,21 @@ strats.data = function (parentVal, childVal, vm) {
 
 function mergeFnData(parentVal, childVal, vm) {
     return strats.computed(
-        isFunction(parentVal)
-            ? parentVal.call(vm, vm)
-            : parentVal,
-        isFunction(childVal)
-            ? childVal.call(vm, vm)
-            : childVal
+        isFunction(parentVal) ? parentVal.call(vm, vm) : parentVal,
+        isFunction(childVal) ? childVal.call(vm, vm) : childVal
     );
 }
 
 // concat strategy
 function concatStrat(parentVal, childVal) {
-
     parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
 
     return childVal
         ? parentVal
             ? parentVal.concat(childVal)
             : isArray(childVal)
-                ? childVal
-                : [childVal]
+            ? childVal
+            : [childVal]
         : parentVal;
 }
 
@@ -96,7 +96,6 @@ function defaultStrat(parentVal, childVal) {
 }
 
 export function mergeOptions(parent, child, vm) {
-
     const options = {};
 
     if (isFunction(child)) {
@@ -108,8 +107,8 @@ export function mergeOptions(parent, child, vm) {
     }
 
     if (child.mixins) {
-        for (let i = 0, l = child.mixins.length; i < l; i++) {
-            parent = mergeOptions(parent, child.mixins[i], vm);
+        for (const mixin of child.mixins) {
+            parent = mergeOptions(parent, mixin, vm);
         }
     }
 
@@ -131,25 +130,21 @@ export function mergeOptions(parent, child, vm) {
 }
 
 export function parseOptions(options, args = []) {
-
     try {
-
         return options
-            ? options.match(/^[{[]/)
+            ? startsWith(options, '{')
                 ? JSON.parse(options)
                 : args.length && !includes(options, ':')
-                    ? ({[args[0]]: options})
-                    : options.split(';').reduce((options, option) => {
-                        const [key, value] = option.split(/:(.*)/);
-                        if (key && !isUndefined(value)) {
-                            options[key.trim()] = value.trim();
-                        }
-                        return options;
-                    }, {})
+                ? { [args[0]]: options }
+                : options.split(';').reduce((options, option) => {
+                      const [key, value] = option.split(/:(.*)/);
+                      if (key && !isUndefined(value)) {
+                          options[key.trim()] = value.trim();
+                      }
+                      return options;
+                  }, {})
             : {};
-
     } catch (e) {
         return {};
     }
-
 }

package/src/js/util/player.js

@@ -1,43 +1,38 @@
-import {once} from './event';
-import {Promise} from './promise';
-import {assign, includes, noop} from './lang';
+import { once } from './event';
+import { assign, includes, noop } from './lang';
 
 export function play(el) {
-
     if (isIFrame(el)) {
-        call(el, {func: 'playVideo', method: 'play'});
+        call(el, { func: 'playVideo', method: 'play' });
     }
 
     if (isHTML5(el)) {
         try {
             el.play().catch(noop);
-        } catch (e) {}
+        } catch (e) {
+            // noop
+        }
     }
-
 }
 
 export function pause(el) {
-
     if (isIFrame(el)) {
-        call(el, {func: 'pauseVideo', method: 'pause'});
+        call(el, { func: 'pauseVideo', method: 'pause' });
     }
 
     if (isHTML5(el)) {
         el.pause();
     }
-
 }
 
 export function mute(el) {
-
     if (isIFrame(el)) {
-        call(el, {func: 'mute', method: 'setVolume', value: 0});
+        call(el, { func: 'mute', method: 'setVolume', value: 0 });
     }
 
     if (isHTML5(el)) {
         el.muted = true;
     }
-
 }
 
 export function isVideo(el) {
@@ -45,35 +40,39 @@ export function isVideo(el) {
 }
 
 function isHTML5(el) {
-    return el && el.tagName === 'VIDEO';
+    return el?.tagName === 'VIDEO';
 }
 
 function isIFrame(el) {
-    return el && el.tagName === 'IFRAME' && (isYoutube(el) || isVimeo(el));
+    return el?.tagName === 'IFRAME' && (isYoutube(el) || isVimeo(el));
 }
 
 function isYoutube(el) {
-    return !!el.src.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/);
+    return !!el.src.match(
+        /\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/
+    );
 }
 
 function isVimeo(el) {
     return !!el.src.match(/vimeo\.com\/video\/.*/);
 }
 
-function call(el, cmd) {
-    enableApi(el).then(() => post(el, cmd));
+async function call(el, cmd) {
+    await enableApi(el);
+    post(el, cmd);
 }
 
 function post(el, cmd) {
     try {
-        el.contentWindow.postMessage(JSON.stringify(assign({event: 'command'}, cmd)), '*');
-    } catch (e) {}
+        el.contentWindow.postMessage(JSON.stringify(assign({ event: 'command' }, cmd)), '*');
+    } catch (e) {
+        // noop
+    }
 }
 
 const stateKey = '_ukPlayer';
 let counter = 0;
 function enableApi(el) {
-
     if (el[stateKey]) {
         return el[stateKey];
     }
@@ -84,24 +83,29 @@ function enableApi(el) {
     const id = ++counter;
     let poller;
 
-    return el[stateKey] = new Promise(resolve => {
-
-        youtube && once(el, 'load', () => {
-            const listener = () => post(el, {event: 'listening', id});
-            poller = setInterval(listener, 100);
-            listener();
-        });
-
-        once(window, 'message', resolve, false, ({data}) => {
+    return (el[stateKey] = new Promise((resolve) => {
+        youtube &&
+            once(el, 'load', () => {
+                const listener = () => post(el, { event: 'listening', id });
+                poller = setInterval(listener, 100);
+                listener();
+            });
 
+        once(window, 'message', resolve, false, ({ data }) => {
             try {
                 data = JSON.parse(data);
-                return data && (youtube && data.id === id && data.event === 'onReady' || vimeo && Number(data.player_id) === id);
-            } catch (e) {}
-
+                return (
+                    data &&
+                    ((youtube && data.id === id && data.event === 'onReady') ||
+                        (vimeo && Number(data.player_id) === id))
+                );
+            } catch (e) {
+                // noop
+            }
         });
 
-        el.src = `${el.src}${includes(el.src, '?') ? '&' : '?'}${youtube ? 'enablejsapi=1' : `api=1&player_id=${id}`}`;
-
-    }).then(() => clearInterval(poller));
+        el.src = `${el.src}${includes(el.src, '?') ? '&' : '?'}${
+            youtube ? 'enablejsapi=1' : `api=1&player_id=${id}`
+        }`;
+    }).then(() => clearInterval(poller)));
 }

package/src/js/util/position.js

@@ -1,18 +1,26 @@
-import {offset} from './dimensions';
-import {each, endsWith, includes, toFloat} from './lang';
-import {getViewport, scrollParents} from './viewport';
+import { offset } from './dimensions';
+import { each, endsWith, includes, toFloat } from './lang';
+import { getViewport, scrollParents } from './viewport';
 
 const dirs = {
     width: ['x', 'left', 'right'],
-    height: ['y', 'top', 'bottom']
+    height: ['y', 'top', 'bottom'],
 };
 
-export function positionAt(element, target, elAttach, targetAttach, elOffset, targetOffset, flip, boundary) {
-
+export function positionAt(
+    element,
+    target,
+    elAttach,
+    targetAttach,
+    elOffset,
+    targetOffset,
+    flip,
+    boundary
+) {
     elAttach = getPos(elAttach);
     targetAttach = getPos(targetAttach);
 
-    const flipped = {element: elAttach, target: targetAttach};
+    const flipped = { element: elAttach, target: targetAttach };
 
     if (!element || !target) {
         return flipped;
@@ -35,69 +43,71 @@ export function positionAt(element, target, elAttach, targetAttach, elOffset, ta
     position.top += elOffset['y'];
 
     if (flip) {
-
         let boundaries = scrollParents(element).map(getViewport);
 
         if (boundary && !includes(boundaries, boundary)) {
             boundaries.unshift(boundary);
         }
 
-        boundaries = boundaries.map(el => offset(el));
+        boundaries = boundaries.map((el) => offset(el));
 
         each(dirs, ([dir, align, alignFlip], prop) => {
-
             if (!(flip === true || includes(flip, dir))) {
                 return;
             }
 
-            boundaries.some(boundary => {
-
-                const elemOffset = elAttach[dir] === align
-                    ? -dim[prop]
-                    : elAttach[dir] === alignFlip
+            boundaries.some((boundary) => {
+                const elemOffset =
+                    elAttach[dir] === align
+                        ? -dim[prop]
+                        : elAttach[dir] === alignFlip
                         ? dim[prop]
                         : 0;
 
-                const targetOffset = targetAttach[dir] === align
-                    ? targetDim[prop]
-                    : targetAttach[dir] === alignFlip
+                const targetOffset =
+                    targetAttach[dir] === align
+                        ? targetDim[prop]
+                        : targetAttach[dir] === alignFlip
                         ? -targetDim[prop]
                         : 0;
 
-                if (position[align] < boundary[align] || position[align] + dim[prop] > boundary[alignFlip]) {
-
+                if (
+                    position[align] < boundary[align] ||
+                    position[align] + dim[prop] > boundary[alignFlip]
+                ) {
                     const centerOffset = dim[prop] / 2;
-                    const centerTargetOffset = targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
-
-                    return elAttach[dir] === 'center' && (
-                        apply(centerOffset, centerTargetOffset)
-                        || apply(-centerOffset, -centerTargetOffset)
-                    ) || apply(elemOffset, targetOffset);
-
+                    const centerTargetOffset =
+                        targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
+
+                    return (
+                        (elAttach[dir] === 'center' &&
+                            (apply(centerOffset, centerTargetOffset) ||
+                                apply(-centerOffset, -centerTargetOffset))) ||
+                        apply(elemOffset, targetOffset)
+                    );
                 }
 
                 function apply(elemOffset, targetOffset) {
-
-                    const newVal = toFloat((position[align] + elemOffset + targetOffset - elOffset[dir] * 2).toFixed(4));
+                    const newVal = toFloat(
+                        (position[align] + elemOffset + targetOffset - elOffset[dir] * 2).toFixed(4)
+                    );
 
                     if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
                         position[align] = newVal;
 
-                        ['element', 'target'].forEach(el => {
-                            flipped[el][dir] = !elemOffset
-                                ? flipped[el][dir]
-                                : flipped[el][dir] === dirs[prop][1]
-                                    ? dirs[prop][2]
-                                    : dirs[prop][1];
-                        });
+                        for (const el of ['element', 'target']) {
+                            if (elemOffset) {
+                                flipped[el][dir] =
+                                    flipped[el][dir] === dirs[prop][1]
+                                        ? dirs[prop][2]
+                                        : dirs[prop][1];
+                            }
+                        }
 
                         return true;
                     }
-
                 }
-
             });
-
         });
     }
 
@@ -111,13 +121,12 @@ function moveTo(position, attach, dim, factor) {
         if (attach[dir] === alignFlip) {
             position[align] += dim[prop] * factor;
         } else if (attach[dir] === 'center') {
-            position[align] += dim[prop] * factor / 2;
+            position[align] += (dim[prop] * factor) / 2;
         }
     });
 }
 
 function getPos(pos) {
-
     const x = /left|center|right/;
     const y = /top|center|bottom/;
 
@@ -127,22 +136,21 @@ function getPos(pos) {
         pos = x.test(pos[0])
             ? pos.concat('center')
             : y.test(pos[0])
-                ? ['center'].concat(pos)
-                : ['center', 'center'];
+            ? ['center'].concat(pos)
+            : ['center', 'center'];
     }
 
     return {
         x: x.test(pos[0]) ? pos[0] : 'center',
-        y: y.test(pos[1]) ? pos[1] : 'center'
+        y: y.test(pos[1]) ? pos[1] : 'center',
     };
 }
 
 function getOffsets(offsets, width, height) {
-
     const [x, y] = (offsets || '').split(' ');
 
     return {
         x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
-        y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0
+        y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0,
     };
 }

package/src/js/util/promise.js

@@ -1,191 +0,0 @@
-/* global setImmediate */
-import {inBrowser} from './env';
-import {isFunction, isObject} from './lang';
-
-export const Promise = inBrowser && window.Promise || PromiseFn;
-
-export class Deferred {
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this.reject = reject;
-            this.resolve = resolve;
-        });
-    }
-}
-
-/**
- * Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
- */
-
-const RESOLVED = 0;
-const REJECTED = 1;
-const PENDING = 2;
-
-const async = inBrowser && window.setImmediate || setTimeout;
-
-function PromiseFn(executor) {
-
-    this.state = PENDING;
-    this.value = undefined;
-    this.deferred = [];
-
-    const promise = this;
-
-    try {
-        executor(
-            x => {
-                promise.resolve(x);
-            },
-            r => {
-                promise.reject(r);
-            }
-        );
-    } catch (e) {
-        promise.reject(e);
-    }
-}
-
-PromiseFn.reject = function (r) {
-    return new PromiseFn((resolve, reject) => {
-        reject(r);
-    });
-};
-
-PromiseFn.resolve = function (x) {
-    return new PromiseFn((resolve, reject) => {
-        resolve(x);
-    });
-};
-
-PromiseFn.all = function all(iterable) {
-    return new PromiseFn((resolve, reject) => {
-        const result = [];
-        let count = 0;
-
-        if (iterable.length === 0) {
-            resolve(result);
-        }
-
-        function resolver(i) {
-            return function (x) {
-                result[i] = x;
-                count += 1;
-
-                if (count === iterable.length) {
-                    resolve(result);
-                }
-            };
-        }
-
-        for (let i = 0; i < iterable.length; i += 1) {
-            PromiseFn.resolve(iterable[i]).then(resolver(i), reject);
-        }
-    });
-};
-
-PromiseFn.race = function race(iterable) {
-    return new PromiseFn((resolve, reject) => {
-        for (let i = 0; i < iterable.length; i += 1) {
-            PromiseFn.resolve(iterable[i]).then(resolve, reject);
-        }
-    });
-};
-
-const p = PromiseFn.prototype;
-
-p.resolve = function resolve(x) {
-    const promise = this;
-
-    if (promise.state === PENDING) {
-        if (x === promise) {
-            throw new TypeError('Promise settled with itself.');
-        }
-
-        let called = false;
-
-        try {
-            const then = x && x.then;
-
-            if (x !== null && isObject(x) && isFunction(then)) {
-                then.call(
-                    x,
-                    x => {
-                        if (!called) {
-                            promise.resolve(x);
-                        }
-                        called = true;
-                    },
-                    r => {
-                        if (!called) {
-                            promise.reject(r);
-                        }
-                        called = true;
-                    }
-                );
-                return;
-            }
-        } catch (e) {
-            if (!called) {
-                promise.reject(e);
-            }
-            return;
-        }
-
-        promise.state = RESOLVED;
-        promise.value = x;
-        promise.notify();
-    }
-};
-
-p.reject = function reject(reason) {
-    const promise = this;
-
-    if (promise.state === PENDING) {
-        if (reason === promise) {
-            throw new TypeError('Promise settled with itself.');
-        }
-
-        promise.state = REJECTED;
-        promise.value = reason;
-        promise.notify();
-    }
-};
-
-p.notify = function notify() {
-    async(() => {
-        if (this.state !== PENDING) {
-            while (this.deferred.length) {
-                const [onResolved, onRejected, resolve, reject] = this.deferred.shift();
-
-                try {
-                    if (this.state === RESOLVED) {
-                        if (isFunction(onResolved)) {
-                            resolve(onResolved.call(undefined, this.value));
-                        } else {
-                            resolve(this.value);
-                        }
-                    } else if (this.state === REJECTED) {
-                        if (isFunction(onRejected)) {
-                            resolve(onRejected.call(undefined, this.value));
-                        } else {
-                            reject(this.value);
-                        }
-                    }
-                } catch (e) {
-                    reject(e);
-                }
-            }
-        }
-    });
-};
-
-p.then = function then(onResolved, onRejected) {
-    return new PromiseFn((resolve, reject) => {
-        this.deferred.push([onResolved, onRejected, resolve, reject]);
-        this.notify();
-    });
-};
-
-p.catch = function (onRejected) {
-    return this.then(undefined, onRejected);
-};