@webalternatif/js-core 1.2.0 → 1.3.0

package/dist/cjs/dom.js

@@ -4,26 +4,51 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
 function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-import { isArray, isArrayLike, isObject, isString } from "./is.js";
+import { isArray, isArrayLike, isFunction, isObject, isPlainObject, isString } from "./is.js";
 import { camelCase } from "./string.js";
 import { each, foreach, map } from "./traversal.js";
 import { inArray } from "./array.js";
 var cssNumber = ['animationIterationCount', 'aspectRatio', 'borderImageSlice', 'columnCount', 'flexGrow', 'flexShrink', 'fontWeight', 'gridArea', 'gridColumn', 'gridColumnEnd', 'gridColumnStart', 'gridRow', 'gridRowEnd', 'gridRowStart', 'lineHeight', 'opacity', 'order', 'orphans', 'scale', 'widows', 'zIndex', 'zoom', 'fillOpacity', 'floodOpacity', 'stopOpacity', 'strokeMiterlimit', 'strokeOpacity'];
+var LISTENERS = new WeakMap();
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 export var isWindow = function isWindow(o) {
   return !!o && o === o.window;
 };
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
+export var isDocument = function isDocument(o) {
+  return !!o && o.nodeType === 9;
+};
+
+/**
+ * @param {any} o
+ * @returns {boolean}
+ */
 export var isDomElement = function isDomElement(o) {
   return isObject(o) && o instanceof HTMLElement;
 };
-export var getStyle = function getStyle(elem, cssRule) {
-  if (!isDomElement(elem)) {
+
+/**
+ * @param {Element} el
+ * @param {string} cssRule
+ * @returns {string}
+ */
+export var getStyle = function getStyle(el, cssRule) {
+  if (!isDomElement(el)) {
     return '';
   }
   if (window.getComputedStyle) {
-    var computedStyle = window.getComputedStyle(elem, null);
+    var computedStyle = window.getComputedStyle(el, null);
     return computedStyle.getPropertyValue(cssRule) || computedStyle[camelCase(cssRule)] || '';
   }
-  return elem.style[camelCase(cssRule)] || '';
+  return el.style[camelCase(cssRule)] || '';
 };
 export default {
   /**
@@ -74,6 +99,26 @@ export default {
     }
     return Array.from(refEl.querySelectorAll(selector));
   },
+  /**
+   * @param {Element} el
+   * @param {string} data
+   * @param {string} value
+   * @returns {Element|null}
+   */
+  findOneByData: function findOneByData(el, data, value) {
+    var _this$findByData$;
+    return (_this$findByData$ = this.findByData(el, data, value)[0]) !== null && _this$findByData$ !== void 0 ? _this$findByData$ : null;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} data
+   * @param {string} value
+   * @returns {Element[]}
+   */
+  findByData: function findByData(el, data, value) {
+    var escapeValue = CSS.escape(value);
+    return this.find(el, "[data-".concat(data, "=\"").concat(escapeValue, "\"]"));
+  },
   /**
    * @param {Element|NodeList|Array<Element>} el
    * @param {string} className
@@ -147,26 +192,38 @@ export default {
   },
   /**
    * @param {Node} node
-   * @param {...Node} children
+   * @param {...(Node|string)} children
    * @returns {Node}
    */
   append: function append(node) {
+    var _this = this;
     for (var _len = arguments.length, children = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       children[_key - 1] = arguments[_key];
     }
-    node.append.apply(node, children);
+    foreach(children, function (child) {
+      if (isString(child)) {
+        child = _this.create(child);
+      }
+      child && node.append(child);
+    });
     return node;
   },
   /**
    * @param {Node} node
-   * @param {...Node} children
+   * @param {...(Node|string)} children
    * @returns {Node}
    */
   prepend: function prepend(node) {
+    var _this2 = this;
     for (var _len2 = arguments.length, children = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
       children[_key2 - 1] = arguments[_key2];
     }
-    node.prepend.apply(node, children);
+    foreach(children, function (child) {
+      if (isString(child)) {
+        child = _this2.create(child);
+      }
+      child && node.prepend(child);
+    });
     return node;
   },
   /**
@@ -174,7 +231,7 @@ export default {
    * @returns {void}
    */
   remove: function remove() {
-    var _this = this;
+    var _this3 = this;
     for (var _len3 = arguments.length, els = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       els[_key3] = arguments[_key3];
     }
@@ -186,7 +243,7 @@ export default {
           return e.remove();
         });
       } else {
-        _this.remove(_this.find(el));
+        _this3.remove(_this3.find(el));
       }
     });
   },
@@ -411,13 +468,13 @@ export default {
    * @returns {Element|DOMStringMap}
    */
   data: function data(el, name, value) {
-    var _this2 = this;
+    var _this4 = this;
     if (undefined === name && undefined === value) {
       return el.dataset;
     }
-    if (webf.isPlainObject(name)) {
-      webf.each(name, function (k, v) {
-        return _this2.data(el, k, v);
+    if (isPlainObject(name)) {
+      each(name, function (k, v) {
+        return _this4.data(el, k, v);
       });
       return el;
     }
@@ -443,25 +500,94 @@ export default {
   },
   /**
    * @param {Element|Document|Window} el
-   * @param {string} event
-   * @param {function} handler
-   * @param {AddEventListenerOptions|false} options
+   * @param {string} events
+   * @param {string|Element|function} selector
+   * @param {function|AddEventListenerOptions|boolean} [handler]
+   * @param {AddEventListenerOptions|boolean} [options]
    * @returns {Element}
    */
-  on: function on(el, event, handler) {
-    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    el.addEventListener(event, handler, options);
+  on: function on(el, events, selector, handler, options) {
+    var _this5 = this;
+    if (isFunction(selector)) {
+      options = handler;
+      handler = selector;
+      selector = null;
+    }
+    foreach(events.split(' '), function (event) {
+      var listener = function listener(ev) {
+        if (!selector) {
+          handler.call(el, ev);
+          return;
+        }
+        var currentTarget = ev.target;
+        while (currentTarget && currentTarget !== el) {
+          if (_this5.matches(currentTarget, selector)) {
+            var wrappedEv = Object.assign({}, ev, {
+              originalEvent: ev,
+              type: ev.type,
+              currentTarget: currentTarget,
+              target: ev.target,
+              relatedTarget: ev.relatedTarget,
+              button: ev.button,
+              pageX: ev.pageX,
+              pageY: ev.pageY,
+              preventDefault: function preventDefault() {
+                return ev.preventDefault.apply(ev, arguments);
+              },
+              stopPropagation: function stopPropagation() {
+                return ev.stopPropagation.apply(ev, arguments);
+              },
+              stopImmediatePropagation: function stopImmediatePropagation() {
+                return ev.stopImmediatePropagation.apply(ev, arguments);
+              }
+            });
+            handler.call(currentTarget, wrappedEv);
+            break;
+          }
+          currentTarget = currentTarget.parentElement;
+        }
+      };
+      var store = LISTENERS.get(el);
+      if (!store) {
+        store = [];
+        LISTENERS.set(el, store);
+      }
+      store.push({
+        event: event,
+        handler: handler,
+        selector: selector,
+        listener: listener,
+        options: options
+      });
+      el.addEventListener(event, listener, options);
+    });
     return el;
   },
   /**
    * @param {Element|Document|Window} el
-   * @param {string} event
-   * @param {function} handler
-   * @param {Object} options
+   * @param {string} events
+   * @param {string|Element|function} selector
+   * @param {function|AddEventListenerOptions|boolean} [handler]
+   * @param {AddEventListenerOptions|boolean} [options]
    * @returns {Element}
    */
-  off: function off(el, event, handler, options) {
-    el.removeEventListener(event, handler, options);
+  off: function off(el, events, selector, handler, options) {
+    if (isFunction(selector)) {
+      options = handler;
+      handler = selector;
+      selector = null;
+    }
+    var store = LISTENERS.get(el);
+    if (!store) return el;
+    foreach(events.split(' '), function (event) {
+      each(_toConsumableArray(store).reverse(), function (i, l) {
+        if (l.event === event && l.handler === handler && l.selector === selector && (options === undefined || l.options === options)) {
+          el.removeEventListener(event, l.listener, l.options);
+          var index = store.indexOf(l);
+          index !== -1 && store.splice(index, 1);
+        }
+      });
+    });
     return el;
   },
   /**
@@ -471,7 +597,7 @@ export default {
    * @returns {Element}
    */
   css: function css(el, style, value) {
-    var _this3 = this;
+    var _this6 = this;
     if (isString(style)) {
       var prop = style.startsWith('--') ? style : camelCase(style);
       if (undefined === value) {
@@ -485,7 +611,7 @@ export default {
       }
     } else {
       each(style, function (name, v) {
-        _this3.css(el, name, v);
+        _this6.css(el, name, v);
       });
     }
     return el;
@@ -517,19 +643,22 @@ export default {
     return null;
   },
   /**
-   * @param {NodeList} nodeList
+   * @param {NodeList|Element|Array<Element>} nodeList
    * @returns {Element|null}
    */
   first: function first(nodeList) {
-    return nodeList !== null && nodeList !== void 0 && nodeList.length ? nodeList.item(0) : null;
+    var _Array$from$;
+    if (nodeList instanceof Element) return nodeList;
+    return (_Array$from$ = Array.from(nodeList)[0]) !== null && _Array$from$ !== void 0 ? _Array$from$ : null;
   },
   /**
    * @param {NodeList|Array<Element>} nodeList
    * @returns {Element|null}
    */
   last: function last(nodeList) {
-    var arr = Array.from(nodeList)[0];
-    return arr[arr.length - 1];
+    var _arr;
+    var arr = Array.from(nodeList);
+    return (_arr = arr[arr.length - 1]) !== null && _arr !== void 0 ? _arr : null;
   },
   /**
    * @param {string} html
@@ -542,32 +671,42 @@ export default {
     return (_tpl$content$firstEle = tpl.content.firstElementChild) !== null && _tpl$content$firstEle !== void 0 ? _tpl$content$firstEle : null;
   },
   /**
-   * @param {NodeList} nodeList
+   * @param {NodeList|Array<Element>} nodeList
    * @param {number} [index=0]
    * @returns {Element|null}
    */
   eq: function eq(nodeList) {
+    var _nodeList$index;
     var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    nodeList = Array.from(nodeList);
     if (Math.abs(index) >= nodeList.length) return null;
     if (index < 0) {
       index = nodeList.length + index;
     }
-    return nodeList.item(index);
+    return (_nodeList$index = nodeList[index]) !== null && _nodeList$index !== void 0 ? _nodeList$index : null;
   },
   /**
    * @param {Element} el
-   * @param {Element} newEl
-   * @returns {Element}
+   * @param {Element|string} newEl
+   * @returns {Element|null}
    */
   after: function after(el, newEl) {
+    if (!el.parentElement) return null;
+    if (isString(newEl)) {
+      newEl = this.create(newEl);
+    }
     return el.parentElement.insertBefore(newEl, el.nextElementSibling);
   },
   /**
    * @param {Element} el
-   * @param {Element} newEl
-   * @returns {Element}
+   * @param {Element|string} newEl
+   * @returns {Element|null}
    */
   before: function before(el, newEl) {
+    if (!el.parentElement) return null;
+    if (isString(newEl)) {
+      newEl = this.create(newEl);
+    }
     return el.parentElement.insertBefore(newEl, el);
   },
   /**
@@ -592,5 +731,65 @@ export default {
       if (!(e instanceof Element)) return false;
       return selectorIsString ? !e.matches(selector) : e !== selector;
     });
+  },
+  /**
+   * @param {Element} elem1
+   * @param {Element} elem2
+   * @returns {boolean}
+   */
+  collide: function collide(elem1, elem2) {
+    var rect1 = elem1.getBoundingClientRect();
+    var rect2 = elem2.getBoundingClientRect();
+    return rect1.x < rect2.x + rect2.width && rect1.x + rect1.width > rect2.x && rect1.y < rect2.y + rect2.height && rect1.y + rect1.height > rect2.y;
+  },
+  /**
+   * @param {Element} el
+   * @param {string|Element} selector
+   */
+  matches: function matches(el, selector) {
+    return selector instanceof Element ? selector === el : el.matches(selector);
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} child
+   * @param {Element} oldChild
+   */
+  replaceChild: function replaceChild(el, child, oldChild) {
+    return el.replaceChild(child, oldChild);
+  },
+  /**
+   * @param {Element} el
+   * @param {Element[]} children
+   * @returns {Element}
+   */
+  replaceChildren: function replaceChildren(el) {
+    for (var _len4 = arguments.length, children = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      children[_key4 - 1] = arguments[_key4];
+    }
+    el.replaceChildren.apply(el, children);
+    return el;
+  },
+  /**
+   * @param {Element|Document|Window} el
+   * @returns {{top: number, left: number}}
+   */
+  offset: function offset(el) {
+    if (isWindow(el)) {
+      return {
+        top: el.scrollY,
+        left: el.scrollX
+      };
+    } else if (isDocument(el)) {
+      return {
+        top: el.documentElement.scrollTop,
+        left: el.documentElement.scrollLeft
+      };
+    }
+    var rect = el.getBoundingClientRect();
+    var wOffset = this.offset(window);
+    return {
+      top: rect.top + wOffset.top,
+      left: rect.left + wOffset.left
+    };
   }
 };

package/dist/cjs/index.js

@@ -7,19 +7,22 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import * as stringFunctions from './string.js';
 import './stringPrototype.js';
 import * as arrayFunctions from './array.js';
+import * as is from './is.js';
+import * as random from './random.js';
 import * as traversal from './traversal.js';
-import dom, { getStyle, isDomElement, isWindow } from './dom.js';
+import dom, { getStyle, isDomElement, isWindow, isDocument } from './dom.js';
 import * as math from './math.js';
 import * as utils from './utils.js';
 import * as i18n from './i18n.js';
 import eventDispatcher from './eventDispatcher.js';
-var webf = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, stringFunctions), arrayFunctions), traversal), {}, {
+var webf = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, stringFunctions), arrayFunctions), traversal), is), random), {}, {
   dom: dom,
   isWindow: isWindow,
+  isDocument: isDocument,
   isDomElement: isDomElement,
   getStyle: getStyle
 }, math), utils), i18n), {}, {
   eventDispatcher: eventDispatcher
 });
 export default webf;
-export { stringFunctions, arrayFunctions, traversal, getStyle, dom, math, utils, eventDispatcher };
+export { stringFunctions, arrayFunctions, traversal, is, random, getStyle, dom, math, utils, eventDispatcher };

package/dist/cjs/random.js

@@ -1,20 +1,17 @@
-export var uniqid = function uniqid() {
-  return randAlpha(10);
-};
 export var randAlpha = function randAlpha(n) {
-  return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
+  return rand("abcdefghijklmnopqrstuvwxyz".split(''), n);
 };
 export var randAlphaCs = function randAlphaCs(n) {
-  return rand("a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
+  return rand("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".split(''), n);
 };
 export var randAlphaNum = function randAlphaNum(n) {
-  return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z".split(','), n);
+  return rand("0123456789abcdefghijklmnopqrstuvwxyz".split(''), n);
 };
 export var randAlphaNumCs = function randAlphaNumCs(n) {
-  return rand("0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','), n);
+  return rand("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".split(''), n);
 };
 export var randNum = function randNum(n) {
-  return rand("0,1,2,3,4,5,6,7,8,9".split(','), n);
+  return rand("0123456789".split(''), n);
 };
 export var rand = function rand(range, n) {
   var rand = "";
@@ -22,4 +19,12 @@ export var rand = function rand(range, n) {
     rand += range[Math.floor(Math.random() * 1000) % range.length];
   }
   return rand;
-};
+};
+export var uniqid = function () {
+  var uid = 0;
+  return function () {
+    var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    uid++;
+    return "".concat(prefix).concat(Date.now().toString(36), "_").concat(uid.toString(36), "_").concat(randAlphaNum(5));
+  };
+}();

package/dist/cjs/string.js

@@ -318,13 +318,41 @@ export var escapeRegex = function escapeRegex(str) {
   return str.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&").replace(/[\n\t]/g, " ");
 };
 export var camelCase = function camelCase(str) {
-  foreach('-_', function (_char5) {
-    str = trim(str, _char5).replace(new RegExp("".concat(_char5, "+"), 'g'), _char5);
-  });
-  str = trim(str).replace(/\s+/g, '-');
-  return str.toLowerCase().replace(/[_-](\w)/g, function (match, p1) {
-    return p1.toUpperCase();
-  });
+  if (!str) return '';
+  var prev = '';
+  var prevReplaced = false;
+  var prevIsSeparator = false;
+  var prevIsUpperCase = false;
+  str = trim(str);
+  str = trim(str, '_');
+  str = trim(str, '-');
+  var isUpperCase = function isUpperCase(c) {
+    return c === c.toUpperCase() && c !== c.toLowerCase();
+  };
+  var isSeparator = function isSeparator(c) {
+    return c === '-' || c === '_' || c === ' ';
+  };
+  return map(str, function (i, c) {
+    prevIsSeparator = isSeparator(prev);
+    prevIsUpperCase = isUpperCase(prev);
+    prev = c;
+    if (isSeparator(c)) {
+      return null;
+    } else if (prevIsSeparator) {
+      c = c.toUpperCase();
+      prevReplaced = true;
+    } else if (isUpperCase(c)) {
+      if (i === 0) {
+        c = c.toLowerCase();
+      } else if (prevIsUpperCase && !prevReplaced) {
+        c = c.toLowerCase();
+      }
+      prevReplaced = false;
+    } else {
+      prevReplaced = false;
+    }
+    return c;
+  }).join('');
 };
 export var format = function format(str) {
   for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {

package/dist/cjs/traversal.js

@@ -36,7 +36,7 @@ export var each = function each(o, callback, context) {
     var arr = o.split('');
     for (var _i = 0; _i < arr.length; _i++) if (false === callback.call(context !== null && context !== void 0 ? context : arr[_i], _i, arr[_i], o, _i)) return;
     return o;
-  } else if (o instanceof Map) {
+  } else if (o instanceof Map || o instanceof WeakMap) {
     var _index = 0;
     var _iterator = _createForOfIteratorHelper(o.entries()),
       _step;
@@ -105,7 +105,7 @@ export var foreach = function foreach(o, callback, context) {
  * @param {Collection<T>} o
  * @param {(key: number|string, value: T, o: Collection<T>, index: number) => (R|null|false)} callback
  * @param {any} [context] Optional "this" binding for the callback
- * @returns {Array} Returns the resulted array
+ * @returns {Array<R>} Returns the resulted array
  */
 export var map = function map(o, callback, context) {
   var results = [];