@webalternatif/js-core 1.1.1 → 1.1.2

package/dist/cjs/dom.js

@@ -8,6 +8,7 @@ var _is = require("./is.js");
 var _string = require("./string.js");
 var _traversal = require("./traversal.js");
 var _array = require("./array.js");
+const 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'];
 const isWindow = function (o) {
   return !!o && o === o.window;
 };
@@ -45,56 +46,66 @@ var _default = exports.default = {
     return this.first(this.children(el, selector));
   },
   /**
-   * @param {Element|Document|string} refEl
-   * @param {string} [selector='*']
-   * @returns {NodeList}
+   * @param {Element|Document} refEl
+   * @param {string|Element|NodeList|Array<Element>} [selector]
+   * @returns {Element|null}
    */
-  find(refEl, selector = '*') {
-    if ((0, _is.isString)(refEl)) {
-      selector = refEl;
-      refEl = document;
-    }
-    try {
-      return refEl.querySelectorAll(selector);
-    } catch (e) {
-      return document.querySelectorAll(':not(*)');
-    }
+  findOne(refEl, selector) {
+    return this.find(refEl, selector)[0] ?? null;
   },
   /**
-   * @param {Element|Document|string} refEl
-   * @param {string} [selector='*']
-   * @returns {Element|null}
+   * @param {Element|Document} refEl
+   * @param {string|Element|NodeList|Array<Element>} selector
+   * @returns {Array<Element>}
    */
-  findOne(refEl, selector = '*') {
-    if ((0, _is.isString)(refEl)) {
+  find(refEl, selector) {
+    if (undefined === selector) {
       selector = refEl;
       refEl = document;
     }
-    try {
-      return refEl.querySelector(selector);
-    } catch (e) {
-      return null;
+    if (selector instanceof Element) {
+      selector = [selector];
+    }
+    if ((0, _is.isArrayLike)(selector)) {
+      return (0, _traversal.map)(Array.from(selector), (i, el) => {
+        if (el instanceof Element) {
+          return refEl === el || refEl.contains(el) ? el : null;
+        }
+        return null;
+      });
     }
+    return Array.from(refEl.querySelectorAll(selector));
   },
   /**
-   * @param {Element} el
+   * @param {Element|NodeList|Array<Element>} el
    * @param {string} className
-   * @returns {Element}
+   * @returns {Element|NodeList|Array<Element>}
    */
   addClass(el, className) {
     if (!className) return el;
     const classNames = className.split(' ').map(c => c.trim()).filter(Boolean);
-    el.classList.add(...classNames);
+    const elements = el instanceof Element ? [el] : Array.from(el);
+    elements.forEach(e => {
+      if (e instanceof Element) {
+        e.classList.add(...classNames);
+      }
+    });
     return el;
   },
   /**
-   * @param {Element} el
-   * @param {string} classNames
-   * @returns {Element}
+   * @param {Element|NodeList|Array<Element>} el
+   * @param {string} className
+   * @returns {Element|NodeList|Array<Element>}
    */
-  removeClass(el, classNames) {
-    if (!classNames) return el;
-    el.classList.remove(...classNames.split(' ').map(c => c.trim()).filter(Boolean));
+  removeClass(el, className) {
+    if (!className) return;
+    const classNames = className.split(' ').map(c => c.trim()).filter(Boolean);
+    const elements = el instanceof Element ? [el] : Array.from(el);
+    elements.forEach(e => {
+      if (e instanceof Element) {
+        e.classList.remove(...classNames);
+      }
+    });
     return el;
   },
   /**
@@ -104,7 +115,7 @@ var _default = exports.default = {
    * @returns {Element}
    */
   toggleClass(el, classNames, force) {
-    (0, _traversal.each)(classNames.split(' ').map(c => c.trim()).filter(Boolean), (i, c) => el.classList.toggle(c, force));
+    (0, _traversal.foreach)(classNames.split(' ').map(c => c.trim()).filter(Boolean), c => el.classList.toggle(c, force));
     return el;
   },
   /**
@@ -113,39 +124,69 @@ var _default = exports.default = {
    * @returns {boolean}
    */
   hasClass(el, classNames) {
-    return (0, _array.compareArray)([...el.classList], classNames.split(' ').map(c => c.trim()).filter(Boolean));
+    if (!classNames) return false;
+    let foundClasses = true;
+    (0, _traversal.foreach)(classNames.split(' ').map(c => c.trim()).filter(Boolean), c => {
+      if (el.classList.contains(c)) {
+        return true;
+      }
+      foundClasses = false;
+      return false;
+    });
+    return foundClasses;
   },
   /**
-   * @param {Element} el
-   * @param {Element} child
-   * @returns {Element}
+   * @param {Node} node
+   * @param {...Node} children
+   * @returns {Node}
    */
-  append(el, child) {
-    el.append(child);
-    return el;
+  append(node, ...children) {
+    node.append(...children);
+    return node;
   },
   /**
-   * @param {Element} el
-   * @param {Element} child
-   * @returns {Element}
+   * @param {Node} node
+   * @param {...Node} children
+   * @returns {Node}
    */
-  prepend(el, child) {
-    el.prepend(child);
-    return el;
+  prepend(node, ...children) {
+    node.prepend(...children);
+    return node;
   },
   /**
-   * @param {Element} el
+   * @param {Element|NodeList|Array<Element>|string} els
    * @returns {void}
    */
-  remove(el) {
-    el.remove();
+  remove(...els) {
+    els.forEach(el => {
+      if (el instanceof Element) {
+        el.remove();
+      } else if (el instanceof NodeList || (0, _is.isArray)(el)) {
+        Array.from(el).forEach(e => e.remove());
+      } else {
+        this.remove(this.find(el));
+      }
+    });
   },
   /**
    * @param {Element} el
-   * @param {string} [selector]
+   * @param {string|Element} selector
    * @returns {Element|null}
    */
   closest(el, selector) {
+    if (selector instanceof Element) {
+      if (el === selector) {
+        return el;
+      }
+      let parentEl = el.parentElement;
+      while (parentEl) {
+        if (parentEl === selector) {
+          return parentEl;
+        }
+        parentEl = parentEl.parentElement;
+      }
+      return null;
+    }
     return el.closest(selector);
   },
   /**
@@ -159,7 +200,7 @@ var _default = exports.default = {
     if (sibling && sibling.matches(selector)) {
       return sibling;
     }
-    return sibling;
+    return null;
   },
   /**
    * @param {Element} el
@@ -206,6 +247,46 @@ var _default = exports.default = {
     }
     return siblings;
   },
+  /**
+   * @param {Element} el
+   * @param {Element|string} selector
+   * @returns {Element[]}
+   */
+  nextUntil(el, selector) {
+    let selectorIsElement = false;
+    const list = [];
+    if (selector instanceof Element) {
+      selectorIsElement = true;
+    }
+    let nextSibling = el.nextElementSibling;
+    while (nextSibling) {
+      const found = selectorIsElement ? nextSibling === selector : nextSibling.matches(selector);
+      if (found) break;
+      list.push(nextSibling);
+      nextSibling = nextSibling.nextElementSibling;
+    }
+    return list;
+  },
+  /**
+   * @param {Element} el
+   * @param {Element|string} selector
+   * @returns {Element[]}
+   */
+  prevUntil(el, selector) {
+    let selectorIsElement = false;
+    const list = [];
+    if (selector instanceof Element) {
+      selectorIsElement = true;
+    }
+    let prevSibling = el.previousElementSibling;
+    while (prevSibling) {
+      const found = selectorIsElement ? prevSibling === selector : prevSibling.matches(selector);
+      if (found) break;
+      list.push(prevSibling);
+      prevSibling = prevSibling.previousElementSibling;
+    }
+    return list;
+  },
   /**
    * @param {Element} el
    * @param {Element} wrappingElement
@@ -303,17 +384,23 @@ var _default = exports.default = {
    * @param {Element} el
    * @param {Object<string, string>|string} name
    * @param {string} [value]
-   * @returns {Element}
+   * @returns {Element|DOMStringMap}
    */
   data(el, name, value) {
-    if ((0, _is.isPlainObject)(name)) {
-      (0, _traversal.each)(name, (k, v) => this.data(el, k, v));
+    if (undefined === name && undefined === value) {
+      return el.dataset;
+    }
+    if (webf.isPlainObject(name)) {
+      webf.each(name, (k, v) => this.data(el, k, v));
       return el;
     }
     const isAttr = /^data-/.test(name + '');
     const key = (0, _string.camelCase)(isAttr ? (name + '').replace(/^data-/, '') : name + '');
     if (undefined === value) return el.dataset[key];
-    if (null === value) this.removeData(el, key);
+    if (null === value) {
+      this.removeData(el, key);
+      return el;
+    }
     el.dataset[key] = value;
     return el;
   },
@@ -323,7 +410,7 @@ var _default = exports.default = {
    * @returns {Element|*}
    */
   removeData(el, name) {
-    const key = (name + '').replace(/^data-/, '').camelCase();
+    const key = (0, _string.camelCase)((name + '').replace(/^data-/, ''));
     delete el.dataset[key];
     return el;
   },
@@ -351,29 +438,27 @@ var _default = exports.default = {
   },
   /**
    * @param {HTMLElement} el
-   * @param {Object<string, string>|string} styles
+   * @param {Object<string, string>|string} style
    * @param {string} [value]
    * @returns {Element}
    */
-  css(el, styles, value) {
-    if ((0, _is.isString)(styles)) {
+  css(el, style, value) {
+    if ((0, _is.isString)(style)) {
+      const prop = style.startsWith('--') ? style : (0, _string.camelCase)(style);
       if (undefined === value) {
-        return styles.startsWith('--') ? el.style.getPropertyValue(styles) : el.style[styles];
+        return getStyle(el, prop);
       }
-      if (styles.startsWith('--')) {
-        el.style.setProperty(styles, String(value));
+      if (prop.startsWith('--')) {
+        el.style.setProperty(prop, String(value));
       } else {
-        el.style[styles] = value;
+        if (typeof value === "number" && !(0, _array.inArray)(prop, cssNumber)) value += 'px';
+        el.style[prop] = value;
       }
-      return el;
+    } else {
+      (0, _traversal.each)(style, (name, v) => {
+        this.css(el, name, v);
+      });
     }
-    (0, _traversal.each)(styles, (name, v) => {
-      if (name.startsWith('--')) {
-        el.style.setProperty(name, String(v));
-      } else {
-        el.style[name] = v;
-      }
-    });
     return el;
   },
   /**
@@ -410,20 +495,21 @@ var _default = exports.default = {
     return nodeList?.length ? nodeList.item(0) : null;
   },
   /**
-   * @param {NodeList} nodeList
+   * @param {NodeList|Array<Element>} nodeList
    * @returns {Element|null}
    */
   last(nodeList) {
-    return nodeList.length ? nodeList.item(nodeList.length - 1) : null;
+    const arr = Array.from(nodeList)[0];
+    return arr[arr.length - 1];
   },
   /**
    * @param {string} html
-   * @returns {Element}
+   * @returns {Element|null}
    */
   create(html) {
     const tpl = document.createElement('template');
     tpl.innerHTML = html.trim();
-    return tpl.content.firstElementChild;
+    return tpl.content.firstElementChild ?? null;
   },
   /**
    * @param {NodeList} nodeList
@@ -462,5 +548,18 @@ var _default = exports.default = {
       el.removeChild(el.firstChild);
     }
     return el;
+  },
+  /**
+   * @param {Element|NodeList} el
+   * @param {string|Element} selector
+   * @return {Element[]}
+   */
+  not(el, selector) {
+    const elements = el instanceof Element ? [el] : Array.from(el);
+    const selectorIsString = webf.isString(selector);
+    return elements.filter(e => {
+      if (!(e instanceof Element)) return false;
+      return selectorIsString ? !e.matches(selector) : e !== selector;
+    });
   }
 };

package/dist/cjs/is.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isUndefined = exports.isTouchDevice = exports.isString = exports.isScalar = exports.isPlainObject = exports.isObject = exports.isInteger = exports.isInt = exports.isFunction = exports.isFloat = exports.isEventSupported = exports.isEvent = exports.isDate = exports.isBoolean = exports.isBool = exports.isArray = void 0;
+exports.isUndefined = exports.isTouchDevice = exports.isString = exports.isScalar = exports.isPlainObject = exports.isObject = exports.isInteger = exports.isInt = exports.isFunction = exports.isFloat = exports.isEventSupported = exports.isEvent = exports.isDate = exports.isBoolean = exports.isBool = exports.isArrayLike = exports.isArray = void 0;
 var _array = require("./array.js");
 const isString = function (str) {
   return typeof str == 'string' || Object.prototype.toString.call(str) === '[object String]';
@@ -34,6 +34,10 @@ const isUndefined = function (v) {
   return typeof v === 'undefined';
 };
 exports.isUndefined = isUndefined;
+const isArrayLike = function (o) {
+  return null !== o && !isString(o) && !isFunction(o) && isInt(o.length) && o.length >= 0 && Number.isFinite(o.length);
+};
+exports.isArrayLike = isArrayLike;
 const isArray = function (a) {
   return Array.isArray(a);
 };

package/dist/cjs/traversal.js

@@ -7,54 +7,128 @@ exports.reduce = exports.merge = exports.map = exports.foreach = exports.extend
 var _is = require("./is.js");
 var _dom = require("./dom.js");
 var _utils = require("./utils.js");
+/**
+ * @template T
+ * @typedef {Array<T> | Set<T> | Map<any, T> | Object<string, T> | string} Collection
+ */
+
+/**
+ * Iterates over Arrays, Strings, Maps, Sets and plain Objects.
+ *
+ * The callback receives:
+ *   (keyOrIndex, value, o, index)
+ *
+ * If the callback returns `false`, the iteration stops.
+ *
+ * @template T
+ * @param {Collection<T>} o
+ * @param {(key: number|string, value: T, o: Collection<T>, index: number) => (void|boolean)} callback
+ * @param {any} [context] Optional "this" binding for the callback
+ * @returns {typeof o} Returns the original input
+ */
 const each = function (o, callback, context) {
-  const oToString = Object.prototype.toString.call(o);
-  if (oToString === '[object Set]') {
-    o = [...o];
-  } else if (oToString === '[object Map]') {
-    o = Object.fromEntries(o);
-  }
-  if ((0, _is.isArray)(o)) {
-    for (let i = 0; i < o.length; i++) if (false === callback.call(context || o[i], i, o[i], o, i)) return;
-  } else if ((0, _is.isObject)(o)) {
+  if ((0, _is.isPlainObject)(o)) {
     let index = -1;
-    for (let i in o) if (o.hasOwnProperty(i) && false === callback.call(context || o[i], i, o[i], o, ++index)) return;
+    for (let i in o) if (o.hasOwnProperty(i) && false === callback.call(context ?? o[i], i, o[i], o, ++index)) return;
   } else if ((0, _is.isString)(o)) {
     const arr = o.split('');
-    for (let i = 0; i < arr.length; i++) if (false === callback.call(context || arr[i], i, arr[i], o, i)) return;
+    for (let i = 0; i < arr.length; i++) if (false === callback.call(context ?? arr[i], i, arr[i], o, i)) return;
+    return o;
+  } else if (o instanceof Map) {
+    let index = 0;
+    for (const [key, value] of o.entries()) {
+      if (false === callback.call(context ?? value, key, value, o, index++)) return;
+    }
+  } else if (o instanceof Set) {
+    let index = 0;
+    for (const value of o.values()) {
+      if (false === callback.call(context ?? value, index, value, o, index)) return;
+      index++;
+    }
+  } else if ((0, _is.isArrayLike)(o)) {
+    o = Array.from(o);
+    for (let i = 0; i < o.length; i++) if (false === callback.call(context || o[i], i, o[i], o, i)) return;
   }
   return o;
 };
+
+/**
+ * Same as each except that key and value are reversed in callback
+ *
+ * The callback receives:
+ *   (value, keyOrIndex, o, index)
+ *
+ * @template T
+ * @param {Collection<T>} o
+ * @param {(value: T, key: number|string, o: Collection<T>, index: number) => (void|boolean)} callback
+ * @param {any} [context] Optional "this" binding for the callback
+ * @returns {typeof o} Returns the original input
+ */
 exports.each = each;
 const foreach = function (o, callback, context) {
   return each(o, (key, value, o, index) => callback.apply(context || value, [value, key, o, index]), context);
 };
+
+/**
+ * Iterates over Arrays, Strings, Maps, Sets and plain Objects.
+ * Returns an array from the callback results.
+ * Values strictly equal to `null` are skipped.
+ * Values strictly equal to `false` stops the iteration.
+ *
+ * The callback receives:
+ *   (keyOrIndex, value, o, index)
+ *
+ * @template T,R
+ * @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
+ */
 exports.foreach = foreach;
 const map = function (o, callback, context) {
   let results = [];
   each(o, function (index, value, o, i) {
     const response = callback.call(context, index, value, o, i);
-    if (response !== null) {
-      results.push(response);
-    }
+    if (false === response) return false;
+    if (null !== response) results.push(response);
   });
   return results;
 };
+
+/**
+ * Reduces a collection to a single value
+ *
+ * The reducer receives:
+ *    (accumulator, value, index, source)
+ *
+ * @template T,R
+ * @param {Collection<T>} o
+ * @param {(accumulator: R|T, value: T, key: any, index: number, o: Collection<T>) => R} callback
+ * @param {R} [initialValue] la valeur initiale
+ * @returns {R} Returns the accumulated value
+ */
 exports.map = map;
 const reduce = function (o, callback, initialValue) {
   const isInitialValueDefined = !(0, _is.isUndefined)(initialValue);
   if (!(0, _utils.sizeOf)(o) && !isInitialValueDefined) {
     throw new Error('Nothing to reduce and no initial value');
   }
-  let accumulator = !isInitialValueDefined ? map(o, (i, v) => i === 0 ? v : null)[0] : initialValue;
-  each(o, (i, v) => {
-    if (i === 0 && !isInitialValueDefined) {
-      return true;
-    }
-    accumulator = callback(accumulator, v, i, o);
+  let accumulator = !isInitialValueDefined ? map(o, (key, v, o, i) => i === 0 ? v : null)[0] : initialValue;
+  each(o, (key, v, o, i) => {
+    if (i === 0 && !isInitialValueDefined) return;
+    accumulator = callback(accumulator, v, key, i, o);
   });
   return accumulator;
 };
+
+/**
+ * Creates a shallow or deep copy of one or more objects or arrays
+ * If the first argument is `true`, nested plain objects are merged recursively.
+ *
+ * @template T
+ * @param {...(boolean|T)} args
+ * @returns {T} A copy of the merged result
+ */
 exports.reduce = reduce;
 const extend = function (...args) {
   let deep = false;
@@ -68,9 +142,9 @@ const extend = function (...args) {
   if (!(0, _is.isObject)(dest)) {
     args[0] = dest = {};
   }
-  each(args.slice(1), (i, src) => {
+  foreach(args.slice(1), src => {
     if ((0, _is.isObject)(src)) {
-      for (let name in src) {
+      for (const name in src) {
         if (deep && (0, _is.isPlainObject)(src[name])) {
           dest[name] = extend(true, {}, dest[name], src[name]);
         } else {
@@ -81,21 +155,39 @@ const extend = function (...args) {
   });
   return dest;
 };
+
+/**
+ * Creates a deep copy of an Object or Array
+ *
+ * @template T
+ * @param {T} o
+ * @returns {T} The copy of o
+ */
 exports.extend = extend;
 const clone = function (o) {
   if (!(0, _is.isObject)(o) && !(0, _is.isArray)(o) || (0, _dom.isWindow)(o)) {
     return o;
   }
   const c = (0, _is.isObject)(o) ? {} : [];
-  each(o, (i, value) => {
+  each(o, (key, value) => {
     if ((0, _is.isObject)(value)) {
-      c[i] = clone(value);
+      c[key] = clone(value);
     } else {
-      c[i] = value;
+      c[key] = value;
     }
   });
   return c;
 };
+
+/**
+ * Merge multiple collections into a single array
+ *
+ * @template T
+ * @param {Collection<T>} first
+ * @param {Collection<T>} [second]
+ * @param {...Collection<T>} args Remaining collections to merge
+ * @returns {Array<T>} the resulted merged array
+ */
 exports.clone = clone;
 const merge = function (first, second = [], ...args) {
   const result = map(first, (i, elem) => elem);