uikit 3.11.2-dev.57792c7e7 → 3.11.2-dev.72dbb9a19

package/src/js/util/event.js

@@ -1,19 +1,15 @@
-import {isIE} from './env';
-import {findAll} from './selector';
-import {closest, within} from './filter';
-import {isArray, isBoolean, isFunction, isString, toNode, toNodes} from './lang';
+import { findAll } from './selector';
+import { closest, within } from './filter';
+import { isArray, isFunction, isString, toNode, toNodes } from './lang';
 
 export function on(...args) {
-
-    let [targets, type, selector, listener, useCapture] = getArgs(args);
-
-    targets = toEventTargets(targets);
+    let [targets, types, selector, listener, useCapture = false] = getArgs(args);
 
     if (listener.length > 1) {
         listener = detail(listener);
     }
 
-    if (useCapture && useCapture.self) {
+    if (useCapture?.self) {
         listener = selfFilter(listener);
     }
 
@@ -21,80 +17,92 @@ export function on(...args) {
         listener = delegate(selector, listener);
     }
 
-    useCapture = useCaptureFilter(useCapture);
+    for (const type of types) {
+        for (const target of targets) {
+            target.addEventListener(type, listener, useCapture);
+        }
+    }
 
-    type.split(' ').forEach(type =>
-        targets.forEach(target =>
-            target.addEventListener(type, listener, useCapture)
-        )
-    );
-    return () => off(targets, type, listener, useCapture);
+    return () => off(targets, types, listener, useCapture);
 }
 
-export function off(targets, type, listener, useCapture = false) {
-    useCapture = useCaptureFilter(useCapture);
-    targets = toEventTargets(targets);
-    type.split(' ').forEach(type =>
-        targets.forEach(target =>
-            target.removeEventListener(type, listener, useCapture)
-        )
-    );
+export function off(...args) {
+    let [targets, types, , listener, useCapture = false] = getArgs(args);
+    for (const type of types) {
+        for (const target of targets) {
+            target.removeEventListener(type, listener, useCapture);
+        }
+    }
 }
 
 export function once(...args) {
-
-    const [element, type, selector, listener, useCapture, condition] = getArgs(args);
-    const off = on(element, type, selector, e => {
-        const result = !condition || condition(e);
-        if (result) {
-            off();
-            listener(e, result);
-        }
-    }, useCapture);
+    const [element, types, selector, listener, useCapture = false, condition] = getArgs(args);
+    const off = on(
+        element,
+        types,
+        selector,
+        (e) => {
+            const result = !condition || condition(e);
+            if (result) {
+                off();
+                listener(e, result);
+            }
+        },
+        useCapture
+    );
 
     return off;
 }
 
 export function trigger(targets, event, detail) {
-    return toEventTargets(targets).reduce((notCanceled, target) =>
-            notCanceled && target.dispatchEvent(createEvent(event, true, true, detail))
-        , true);
+    return toEventTargets(targets).every((target) =>
+        target.dispatchEvent(createEvent(event, true, true, detail))
+    );
 }
 
 export function createEvent(e, bubbles = true, cancelable = false, detail) {
     if (isString(e)) {
-        const event = document.createEvent('CustomEvent'); // IE 11
-        event.initCustomEvent(e, bubbles, cancelable, detail);
-        e = event;
+        e = new CustomEvent(e, { bubbles, cancelable, detail });
     }
 
     return e;
 }
 
 function getArgs(args) {
+    // Event targets
+    args[0] = toEventTargets(args[0]);
+
+    // Event types
+    if (isString(args[1])) {
+        args[1] = args[1].split(' ');
+    }
+
+    // Delegate?
     if (isFunction(args[2])) {
         args.splice(2, 0, false);
     }
+
     return args;
 }
 
 function delegate(selector, listener) {
-    return e => {
-
-        const current = selector[0] === '>'
-            ? findAll(selector, e.currentTarget).reverse().filter(element => within(e.target, element))[0]
-            : closest(e.target, selector);
+    return (e) => {
+        const current =
+            selector[0] === '>'
+                ? findAll(selector, e.currentTarget)
+                      .reverse()
+                      .filter((element) => within(e.target, element))[0]
+                : closest(e.target, selector);
 
         if (current) {
             e.current = current;
             listener.call(this, e);
         }
-
     };
 }
 
 function detail(listener) {
-    return e => isArray(e.detail) ? listener(e, ...e.detail) : listener(e);
+    return (e) => (isArray(e.detail) ? listener(e, ...e.detail) : listener(e));
 }
 
 function selfFilter(listener) {
@@ -105,12 +113,6 @@ function selfFilter(listener) {
     };
 }
 
-function useCaptureFilter(options) {
-    return options && isIE && !isBoolean(options)
-        ? !!options.capture
-        : options;
-}
-
 function isEventTarget(target) {
     return target && 'addEventListener' in target;
 }
@@ -123,10 +125,10 @@ export function toEventTargets(target) {
     return isArray(target)
         ? target.map(toEventTarget).filter(Boolean)
         : isString(target)
-            ? findAll(target)
-            : isEventTarget(target)
-                ? [target]
-                : toNodes(target);
+        ? findAll(target)
+        : isEventTarget(target)
+        ? [target]
+        : toNodes(target);
 }
 
 export function isTouch(e) {
@@ -134,8 +136,7 @@ export function isTouch(e) {
 }
 
 export function getEventPos(e) {
-    const {touches, changedTouches} = e;
-    const {clientX: x, clientY: y} = touches && touches[0] || changedTouches && changedTouches[0] || e;
+    const { clientX: x, clientY: y } = e.touches?.[0] || e.changedTouches?.[0] || e;
 
-    return {x, y};
+    return { x, y };
 }

package/src/js/util/fastdom.js

@@ -1,4 +1,3 @@
-import {Promise} from './promise';
 /*
     Based on:
     Copyright (c) 2016 Wilson Page wilsonpage@me.com
@@ -6,7 +5,6 @@ import {Promise} from './promise';
 */
 
 export const fastdom = {
-
     reads: [],
     writes: [],
 
@@ -27,11 +25,10 @@ export const fastdom = {
         remove(this.writes, task);
     },
 
-    flush
-
+    flush,
 };
 
-function flush(recursion = 1) {
+function flush(recursion) {
     runTasks(fastdom.reads);
     runTasks(fastdom.writes.splice(0));
 
@@ -44,7 +41,6 @@ function flush(recursion = 1) {
 
 const RECURSION_LIMIT = 4;
 function scheduleFlush(recursion) {
-
     if (fastdom.scheduled) {
         return;
     }
@@ -53,9 +49,8 @@ function scheduleFlush(recursion) {
     if (recursion && recursion < RECURSION_LIMIT) {
         Promise.resolve().then(() => flush(recursion));
     } else {
-        requestAnimationFrame(() => flush());
+        requestAnimationFrame(() => flush(1));
     }
-
 }
 
 function runTasks(tasks) {

package/src/js/util/filter.js

@@ -1,5 +1,4 @@
-import {inBrowser} from './env';
-import {isDocument, isElement, isString, noop, startsWith, toNode, toNodes} from './lang';
+import { isElement, isString, startsWith, toNode, toNodes } from './lang';
 
 const voidElements = {
     area: true,
@@ -17,19 +16,21 @@ const voidElements = {
     param: true,
     source: true,
     track: true,
-    wbr: true
+    wbr: true,
 };
 export function isVoidElement(element) {
-    return toNodes(element).some(element => voidElements[element.tagName.toLowerCase()]);
+    return toNodes(element).some((element) => voidElements[element.tagName.toLowerCase()]);
 }
 
 export function isVisible(element) {
-    return toNodes(element).some(element => element.offsetWidth || element.offsetHeight || element.getClientRects().length);
+    return toNodes(element).some(
+        (element) => element.offsetWidth || element.offsetHeight || element.getClientRects().length
+    );
 }
 
 export const selInput = 'input,select,textarea,button';
 export function isInput(element) {
-    return toNodes(element).some(element => matches(element, selInput));
+    return toNodes(element).some((element) => matches(element, selInput));
 }
 
 export const selFocusable = `${selInput},a[href],[tabindex]`;
@@ -43,45 +44,29 @@ export function parent(element) {
 }
 
 export function filter(element, selector) {
-    return toNodes(element).filter(element => matches(element, selector));
+    return toNodes(element).filter((element) => matches(element, selector));
 }
 
-const elProto = inBrowser ? Element.prototype : {};
-const matchesFn = elProto.matches || elProto.webkitMatchesSelector || elProto.msMatchesSelector || noop;
-
 export function matches(element, selector) {
-    return toNodes(element).some(element => matchesFn.call(element, selector));
+    return toNodes(element).some((element) => element.matches(selector));
 }
 
-const closestFn = elProto.closest || function (selector) {
-    let ancestor = this;
-
-    do {
-
-        if (matches(ancestor, selector)) {
-            return ancestor;
-        }
-
-    } while ((ancestor = parent(ancestor)));
-};
-
 export function closest(element, selector) {
-
     if (startsWith(selector, '>')) {
         selector = selector.slice(1);
     }
 
     return isElement(element)
-        ? closestFn.call(element, selector)
-        : toNodes(element).map(element => closest(element, selector)).filter(Boolean);
+        ? element.closest(selector)
+        : toNodes(element)
+              .map((element) => closest(element, selector))
+              .filter(Boolean);
 }
 
 export function within(element, selector) {
-    return !isString(selector)
-        ? element === selector || (isDocument(selector)
-            ? selector.documentElement
-            : toNode(selector)).contains(toNode(element)) // IE 11 document does not implement contains
-        : matches(element, selector) || !!closest(element, selector);
+    return isString(selector)
+        ? matches(element, selector) || !!closest(element, selector)
+        : element === selector || toNode(selector).contains(toNode(element));
 }
 
 export function parents(element, selector) {
@@ -103,7 +88,5 @@ export function children(element, selector) {
 }
 
 export function index(element, ref) {
-    return ref
-        ? toNodes(element).indexOf(toNode(ref))
-        : children(parent(element)).indexOf(element);
+    return ref ? toNodes(element).indexOf(toNode(ref)) : children(parent(element)).indexOf(element);
 }

package/src/js/util/index.js

@@ -13,7 +13,6 @@ export * from './mouse';
 export * from './options';
 export * from './player';
 export * from './position';
-export * from './promise';
 export * from './selector';
 export * from './style';
 export * from './viewport';

package/src/js/util/lang.js

@@ -1,5 +1,4 @@
-const objPrototype = Object.prototype;
-const {hasOwnProperty} = objPrototype;
+const { hasOwnProperty, toString } = Object.prototype;
 
 export function hasOwn(obj, key) {
     return hasOwnProperty.call(obj, key);
@@ -7,18 +6,13 @@ export function hasOwn(obj, key) {
 
 const hyphenateRe = /\B([A-Z])/g;
 
-export const hyphenate = memoize(str => str
-    .replace(hyphenateRe, '-$1')
-    .toLowerCase()
-);
+export const hyphenate = memoize((str) => str.replace(hyphenateRe, '-$1').toLowerCase());
 
 const camelizeRe = /-(\w)/g;
 
-export const camelize = memoize(str =>
-    str.replace(camelizeRe, toUpper)
-);
+export const camelize = memoize((str) => str.replace(camelizeRe, toUpper));
 
-export const ucfirst = memoize(str =>
+export const ucfirst = memoize((str) =>
     str.length ? toUpper(null, str.charAt(0)) + str.slice(1) : ''
 );
 
@@ -26,43 +20,24 @@ function toUpper(_, c) {
     return c ? c.toUpperCase() : '';
 }
 
-const strPrototype = String.prototype;
-const startsWithFn = strPrototype.startsWith || function (search) { return this.lastIndexOf(search, 0) === 0; };
-
 export function startsWith(str, search) {
-    return startsWithFn.call(str, search);
+    return str.startsWith(search);
 }
 
-const endsWithFn = strPrototype.endsWith || function (search) { return this.substr(-search.length) === search; };
-
 export function endsWith(str, search) {
-    return endsWithFn.call(str, search);
+    return str.endsWith(search);
 }
 
-const arrPrototype = Array.prototype;
-
-const includesFn = function (search, i) { return !!~this.indexOf(search, i); };
-const includesStr = strPrototype.includes || includesFn;
-const includesArray = arrPrototype.includes || includesFn;
-
 export function includes(obj, search) {
-    return obj && (isString(obj) ? includesStr : includesArray).call(obj, search);
+    return obj && obj.includes(search);
 }
 
-const findIndexFn = arrPrototype.findIndex || function (predicate) {
-    for (let i = 0; i < this.length; i++) {
-        if (predicate.call(arguments[1], this[i], i, this)) {
-            return i;
-        }
-    }
-    return -1;
-};
-
 export function findIndex(array, predicate) {
-    return findIndexFn.call(array, predicate);
+    return array.findIndex(predicate);
 }
 
-export const {isArray} = Array;
+export const { isArray, from: toArray } = Array;
+export const { assign } = Object;
 
 export function isFunction(obj) {
     return typeof obj === 'function';
@@ -72,7 +47,6 @@ export function isObject(obj) {
     return obj !== null && typeof obj === 'object';
 }
 
-const {toString} = objPrototype;
 export function isPlainObject(obj) {
     return toString.call(obj) === '[object Object]';
 }
@@ -110,16 +84,11 @@ export function isNumber(value) {
 }
 
 export function isNumeric(value) {
-    return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value));
+    return isNumber(value) || (isString(value) && !isNaN(value - parseFloat(value)));
 }
 
 export function isEmpty(obj) {
-    return !(isArray(obj)
-        ? obj.length
-        : isObject(obj)
-            ? Object.keys(obj).length
-            : false
-    );
+    return !(isArray(obj) ? obj.length : isObject(obj) ? Object.keys(obj).length : false);
 }
 
 export function isUndefined(value) {
@@ -130,10 +99,10 @@ export function toBoolean(value) {
     return isBoolean(value)
         ? value
         : value === 'true' || value === '1' || value === ''
-            ? true
-            : value === 'false' || value === '0'
-                ? false
-                : value;
+        ? true
+        : value === 'false' || value === '0'
+        ? false
+        : value;
 }
 
 export function toNumber(value) {
@@ -145,14 +114,12 @@ export function toFloat(value) {
     return parseFloat(value) || 0;
 }
 
-export const toArray = Array.from || (value => arrPrototype.slice.call(value));
-
 export function toNode(element) {
     return toNodes(element)[0];
 }
 
 export function toNodes(element) {
-    return element && (isNode(element) ? [element] : toArray(element).filter(isNode)) || [];
+    return (element && (isNode(element) ? [element] : Array.from(element).filter(isNode))) || [];
 }
 
 export function toWindow(element) {
@@ -162,52 +129,27 @@ export function toWindow(element) {
 
     element = toNode(element);
 
-    return element
-        ? (isDocument(element)
-            ? element
-            : element.ownerDocument
-        ).defaultView
-        : window;
+    return element ? (isDocument(element) ? element : element.ownerDocument).defaultView : window;
 }
 
 export function toMs(time) {
-    return !time
-        ? 0
-        : endsWith(time, 'ms')
-            ? toFloat(time)
-            : toFloat(time) * 1000;
+    return time ? (endsWith(time, 'ms') ? toFloat(time) : toFloat(time) * 1000) : 0;
 }
 
 export function isEqual(value, other) {
-    return value === other
-        || isObject(value)
-        && isObject(other)
-        && Object.keys(value).length === Object.keys(other).length
-        && each(value, (val, key) => val === other[key]);
+    return (
+        value === other ||
+        (isObject(value) &&
+            isObject(other) &&
+            Object.keys(value).length === Object.keys(other).length &&
+            each(value, (val, key) => val === other[key]))
+    );
 }
 
 export function swap(value, a, b) {
-    return value.replace(
-        new RegExp(`${a}|${b}`, 'g'),
-        match => match === a ? b : a
-    );
+    return value.replace(new RegExp(`${a}|${b}`, 'g'), (match) => (match === a ? b : a));
 }
 
-export const assign = Object.assign || function (target, ...args) {
-    target = Object(target);
-    for (let i = 0; i < args.length; i++) {
-        const source = args[i];
-        if (source !== null) {
-            for (const key in source) {
-                if (hasOwn(source, key)) {
-                    target[key] = source[key];
-                }
-            }
-        }
-    }
-    return target;
-};
-
 export function last(array) {
     return array[array.length - 1];
 }
@@ -222,21 +164,16 @@ export function each(obj, cb) {
 }
 
 export function sortBy(array, prop) {
-    return array.slice().sort(({[prop]: propA = 0}, {[prop]: propB = 0}) =>
-        propA > propB
-            ? 1
-            : propB > propA
-                ? -1
-                : 0
-    );
+    return array
+        .slice()
+        .sort(({ [prop]: propA = 0 }, { [prop]: propB = 0 }) =>
+            propA > propB ? 1 : propB > propA ? -1 : 0
+        );
 }
 
 export function uniqueBy(array, prop) {
     const seen = new Set();
-    return array.filter(({[prop]: check}) => seen.has(check)
-        ? false
-        : seen.add(check) || true // IE 11 does not return the Set object
-    );
+    return array.filter(({ [prop]: check }) => (seen.has(check) ? false : seen.add(check)));
 }
 
 export function clamp(number, min = 0, max = 1) {
@@ -246,36 +183,48 @@ export function clamp(number, min = 0, max = 1) {
 export function noop() {}
 
 export function intersectRect(...rects) {
-    return [['bottom', 'top'], ['right', 'left']].every(([minProp, maxProp]) =>
-        Math.min(...rects.map(({[minProp]: min}) => min)) - Math.max(...rects.map(({[maxProp]: max}) => max)) > 0
+    return [
+        ['bottom', 'top'],
+        ['right', 'left'],
+    ].every(
+        ([minProp, maxProp]) =>
+            Math.min(...rects.map(({ [minProp]: min }) => min)) -
+                Math.max(...rects.map(({ [maxProp]: max }) => max)) >
+            0
     );
 }
 
 export function pointInRect(point, rect) {
-    return point.x <= rect.right &&
+    return (
+        point.x <= rect.right &&
         point.x >= rect.left &&
         point.y <= rect.bottom &&
-        point.y >= rect.top;
+        point.y >= rect.top
+    );
 }
 
 export const Dimensions = {
-
     ratio(dimensions, prop, value) {
-
         const aProp = prop === 'width' ? 'height' : 'width';
 
         return {
-            [aProp]: dimensions[prop] ? Math.round(value * dimensions[aProp] / dimensions[prop]) : dimensions[aProp],
-            [prop]: value
+            [aProp]: dimensions[prop]
+                ? Math.round((value * dimensions[aProp]) / dimensions[prop])
+                : dimensions[aProp],
+            [prop]: value,
         };
     },
 
     contain(dimensions, maxDimensions) {
-        dimensions = assign({}, dimensions);
-
-        each(dimensions, (_, prop) => dimensions = dimensions[prop] > maxDimensions[prop]
-            ? this.ratio(dimensions, prop, maxDimensions[prop])
-            : dimensions
+        dimensions = { ...dimensions };
+
+        each(
+            dimensions,
+            (_, prop) =>
+                (dimensions =
+                    dimensions[prop] > maxDimensions[prop]
+                        ? this.ratio(dimensions, prop, maxDimensions[prop])
+                        : dimensions)
         );
 
         return dimensions;
@@ -284,21 +233,23 @@ export const Dimensions = {
     cover(dimensions, maxDimensions) {
         dimensions = this.contain(dimensions, maxDimensions);
 
-        each(dimensions, (_, prop) => dimensions = dimensions[prop] < maxDimensions[prop]
-            ? this.ratio(dimensions, prop, maxDimensions[prop])
-            : dimensions
+        each(
+            dimensions,
+            (_, prop) =>
+                (dimensions =
+                    dimensions[prop] < maxDimensions[prop]
+                        ? this.ratio(dimensions, prop, maxDimensions[prop])
+                        : dimensions)
         );
 
         return dimensions;
-    }
-
+    },
 };
 
 export function getIndex(i, elements, current = 0, finite = false) {
-
     elements = toNodes(elements);
 
-    const {length} = elements;
+    const { length } = elements;
 
     if (!length) {
         return -1;
@@ -307,10 +258,10 @@ export function getIndex(i, elements, current = 0, finite = false) {
     i = isNumeric(i)
         ? toNumber(i)
         : i === 'next'
-            ? current + 1
-            : i === 'previous'
-                ? current - 1
-                : elements.indexOf(toNode(i));
+        ? current + 1
+        : i === 'previous'
+        ? current - 1
+        : elements.indexOf(toNode(i));
 
     if (finite) {
         return clamp(i, 0, length - 1);
@@ -323,5 +274,14 @@ export function getIndex(i, elements, current = 0, finite = false) {
 
 export function memoize(fn) {
     const cache = Object.create(null);
-    return key => cache[key] || (cache[key] = fn(key));
+    return (key) => cache[key] || (cache[key] = fn(key));
+}
+
+export class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
 }