@webalternatif/js-core 1.1.1 → 1.1.2

package/dist/esm/array.js

@@ -1,13 +1,8 @@
-"use strict";
+import { each } from "./traversal.js";
+import { isArray, isInteger, isObject, isString, isUndefined } from "./is.js";
+import { round } from "./math.js";
+import { equals } from "./utils.js";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.range = exports.indexOf = exports.inArray = exports.compareArray = exports.array_unique = exports.array_diff = exports.arrayUnique = exports.arrayDiff = void 0;
-var _traversal = require("./traversal.js");
-var _is = require("./is.js");
-var _math = require("./math.js");
-var _utils = require("./utils.js");
 /**
  * Checks if a value exists in an array or an object
  *
@@ -29,9 +24,9 @@ var _utils = require("./utils.js");
  * inArray(5, [1, 2, 3])
  * // → false
  */
-const inArray = function (value, arr, index = 0, strict = false) {
+export const inArray = function (value, arr, index = 0, strict = false) {
   let ret = false;
-  (0, _traversal.each)(arr, (i, val) => {
+  each(arr, (i, val) => {
     if (i >= index) {
       if (strict) {
         if (val === value) {
@@ -39,10 +34,10 @@ const inArray = function (value, arr, index = 0, strict = false) {
           return false;
         }
       } else {
-        if ((0, _is.isObject)(value) && (0, _is.isObject)(val)) {
-          ret = (0, _utils.equals)(val, value);
+        if (isObject(value) && isObject(val)) {
+          ret = equals(val, value);
           return false;
-        } else if ((0, _is.isArray)(value) && (0, _is.isObject)(val)) {
+        } else if (isArray(value) && isObject(val)) {
           ret = compareArray(val, value);
           return false;
         } else if (val == value) {
@@ -54,8 +49,7 @@ const inArray = function (value, arr, index = 0, strict = false) {
   });
   return ret;
 };
-exports.inArray = inArray;
-const indexOf = function (arr, elt, from = 0) {
+export const indexOf = function (arr, elt, from = 0) {
   from = from < 0 ? Math.ceil(from) + arr.length : Math.floor(from);
   for (; from < arr.length; from++) {
     if (from in arr && arr[from] === elt) {
@@ -64,14 +58,13 @@ const indexOf = function (arr, elt, from = 0) {
   }
   return -1;
 };
-exports.indexOf = indexOf;
-const compareArray = function (a1, a2) {
+export const compareArray = function (a1, a2) {
   if (a1.length !== a2.length) {
     return false;
   } else {
     for (let i = 0; i < a1.length; i++) {
-      if ((0, _is.isArray)(a1[i])) {
-        if (!(0, _is.isArray)(a2[i])) {
+      if (isArray(a1[i])) {
+        if (!isArray(a2[i])) {
           return false;
         }
         return compareArray(a1[i], a2[i]);
@@ -82,35 +75,31 @@ const compareArray = function (a1, a2) {
   }
   return true;
 };
-exports.compareArray = compareArray;
-const arrayUnique = function (arr) {
+export const arrayUnique = function (arr) {
   return arr.filter((el, index, arr) => index === indexOf(arr, el));
 };
-exports.arrayUnique = arrayUnique;
-const array_unique = exports.array_unique = arrayUnique;
-const arrayDiff = (array1, array2, strict = false) => {
+export const array_unique = arrayUnique;
+export const arrayDiff = (array1, array2, strict = false) => {
   return array1.filter(item => !inArray(item, array2, 0, strict));
 };
-exports.arrayDiff = arrayDiff;
-const array_diff = exports.array_diff = arrayUnique;
-const range = function (size, startAt = 0, step = 1) {
-  size = (0, _math.round)(size);
-  step = (0, _math.round)(step);
+export const array_diff = arrayUnique;
+export const range = function (size, startAt = 0, step = 1) {
+  size = round(size);
+  step = round(step);
   const rng = [];
-  if ((0, _is.isUndefined)(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
+  if (isUndefined(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
     return rng;
   }
   const end = size * step;
-  if ((0, _is.isString)(startAt)) {
+  if (isString(startAt)) {
     startAt = startAt.charCodeAt(0);
     for (let i = 0; step > 0 ? i < end : i > end; i += step) {
       rng.push(String.fromCharCode(startAt + i));
     }
-  } else if ((0, _is.isInteger)(startAt)) {
+  } else if (isInteger(startAt)) {
     for (let i = 0; step > 0 ? i < end : i > end; i += step) {
       rng.push(startAt + i);
     }
   }
   return rng;
-};
-exports.range = range;
+};

package/dist/esm/dom.js

@@ -1,33 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isWindow = exports.isDomElement = exports.getStyle = exports.default = void 0;
-var _is = require("./is.js");
-var _string = require("./string.js");
-var _traversal = require("./traversal.js");
-var _array = require("./array.js");
-const isWindow = function (o) {
+import { isArray, isArrayLike, isObject, isString } from "./is.js";
+import { camelCase } from "./string.js";
+import { each, foreach, map } from "./traversal.js";
+import { inArray } from "./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'];
+export const isWindow = function (o) {
   return !!o && o === o.window;
 };
-exports.isWindow = isWindow;
-const isDomElement = function (o) {
-  return (0, _is.isObject)(o) && o instanceof HTMLElement;
+export const isDomElement = function (o) {
+  return isObject(o) && o instanceof HTMLElement;
 };
-exports.isDomElement = isDomElement;
-const getStyle = function (elem, cssRule) {
+export const getStyle = function (elem, cssRule) {
   if (!isDomElement(elem)) {
     return '';
   }
   if (window.getComputedStyle) {
     const computedStyle = window.getComputedStyle(elem, null);
-    return computedStyle.getPropertyValue(cssRule) || computedStyle[(0, _string.camelCase)(cssRule)] || '';
+    return computedStyle.getPropertyValue(cssRule) || computedStyle[camelCase(cssRule)] || '';
   }
-  return elem.style[(0, _string.camelCase)(cssRule)] || '';
+  return elem.style[camelCase(cssRule)] || '';
 };
-exports.getStyle = getStyle;
-var _default = exports.default = {
+export default {
   /**
    * @param {Element} el
    * @param {string} [selector]
@@ -45,56 +37,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 (isArrayLike(selector)) {
+      return 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 +106,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));
+    foreach(classNames.split(' ').map(c => c.trim()).filter(Boolean), c => el.classList.toggle(c, force));
     return el;
   },
   /**
@@ -113,39 +115,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;
+    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 || 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 +191,7 @@ var _default = exports.default = {
     if (sibling && sibling.matches(selector)) {
       return sibling;
     }
-    return sibling;
+    return null;
   },
   /**
    * @param {Element} el
@@ -206,6 +238,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 +375,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 + '');
+    const key = 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 +401,7 @@ var _default = exports.default = {
    * @returns {Element|*}
    */
   removeData(el, name) {
-    const key = (name + '').replace(/^data-/, '').camelCase();
+    const key = camelCase((name + '').replace(/^data-/, ''));
     delete el.dataset[key];
     return el;
   },
@@ -351,29 +429,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 (isString(style)) {
+      const prop = style.startsWith('--') ? style : 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" && !inArray(prop, cssNumber)) value += 'px';
+        el.style[prop] = value;
       }
-      return el;
+    } else {
+      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 +486,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 +539,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/esm/eventDispatcher.js

@@ -1,18 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _is = require("./is.js");
-var _traversal = require("./traversal.js");
+import { isFunction, isString, isUndefined } from "./is.js";
+import { each, map } from "./traversal.js";
 class EventDispatcher {
   #listeners = {};
   addListener(eventsName, callback, context, ...args) {
-    if (!(0, _is.isFunction)(callback)) {
+    if (!isFunction(callback)) {
       throw new Error('Callback must be a function.');
     }
-    if (!(0, _is.isString)(eventsName)) {
+    if (!isString(eventsName)) {
       throw new Error('Events name must be a string separated by comma.');
     }
     const listener = {
@@ -20,7 +14,7 @@ class EventDispatcher {
       context,
       args
     };
-    (0, _traversal.each)(eventsName.split(','), (i, eventName) => {
+    each(eventsName.split(','), (i, eventName) => {
       if (!eventName) return true; // continue
 
       eventName = eventName.trim();
@@ -33,7 +27,7 @@ class EventDispatcher {
     return this;
   }
   addListenerOnce(eventsName, callback, context, ...listenerArgs) {
-    (0, _traversal.each)(eventsName.split(','), (i, eventName) => {
+    each(eventsName.split(','), (i, eventName) => {
       eventName = eventName.trim();
       if (!eventName) return true; // continue
 
@@ -46,10 +40,10 @@ class EventDispatcher {
     return this;
   }
   dispatch(eventsName, ...args) {
-    if (!(0, _is.isString)(eventsName)) {
+    if (!isString(eventsName)) {
       throw new Error('Events name must be a string seperated by comma.');
     }
-    (0, _traversal.each)(eventsName.split(','), (i, eventName) => {
+    each(eventsName.split(','), (i, eventName) => {
       eventName = eventName.trim();
       if (!eventName) return true; // continue
 
@@ -57,26 +51,26 @@ class EventDispatcher {
         console.warn(`No listeners found for event: ${eventName}`);
         return true; // continue
       }
-      (0, _traversal.each)(this.#listeners[eventName], (i, listener) => {
+      each(this.#listeners[eventName], (i, listener) => {
         listener.callback.apply(listener.context, [eventName].concat(listener.args).concat(args));
       });
     });
     return this;
   }
   hasListener(eventName, callback, context) {
-    if ((0, _is.isUndefined)(callback)) {
-      return !(0, _is.isUndefined)(this.#listeners[eventName]);
+    if (isUndefined(callback)) {
+      return !isUndefined(this.#listeners[eventName]);
     }
-    return !!(0, _traversal.map)(this.#listeners[eventName], (i, listener) => {
+    return !!map(this.#listeners[eventName], (i, listener) => {
       return listener.callback === callback && listener.context === context ? true : null;
     }).length;
   }
   removeListener(eventName, callback, context) {
     if (this.hasListener(eventName, callback, context)) {
-      if ((0, _is.isUndefined)(callback)) {
+      if (isUndefined(callback)) {
         this.#listeners[eventName].splice(0);
       } else {
-        (0, _traversal.each)(this.#listeners[eventName], i => {
+        each(this.#listeners[eventName], i => {
           this.#listeners[eventName].splice(i, 1);
           delete this.#listeners[eventName];
           return false; // break
@@ -93,4 +87,4 @@ class EventDispatcher {
   }
 }
 const eventDispatcher = new EventDispatcher();
-var _default = exports.default = eventDispatcher;
+export default eventDispatcher;