@webalternatif/js-core 1.0.0

package/dist/cjs/utils.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.throttle = exports.strParseFloat = exports.sizeOf = exports.noop = exports.flatten = exports.equals = exports.debounce = void 0;
+var _traversal = require("./traversal.js");
+var _is = require("./is.js");
+const equals = function (o1, o2, seen = new WeakMap()) {
+  if (o1 === o2) return true;
+  if (typeof o1 !== typeof o2 || o1 == null || o2 == null) {
+    return false;
+  }
+  if ((0, _is.isObject)(o1)) {
+    if (seen.has(o1)) {
+      return seen.get(o1) === o2;
+    }
+    seen.set(o1, o2);
+    const keys1 = Object.keys(o1),
+      keys2 = Object.keys(o2);
+    if (keys1.length !== keys2.length) {
+      return false;
+    }
+    return keys1.every(key => equals(o1[key], o2[key], seen));
+  }
+  return false;
+};
+exports.equals = equals;
+const noop = function () {};
+exports.noop = noop;
+const sizeOf = function (o) {
+  return (0, _traversal.map)(o, noop).length;
+};
+
+/**
+ * Recursively flattens an object or array into a single-level array.
+ *
+ * @param {Object|Array} o - The object or array to flatten.
+ * @returns {Array} A flattened array containing all the values from the input object or array.
+ *
+ * @example <caption>Flatten an array of arrays</caption>
+ * const result = flatten([1, [2, [3, 4]], 5]);
+ * console.log(result);
+ * // Output: [1, 2, 3, 4, 5]
+ *
+ * @example <caption>Flatten an object</caption>
+ * const result = flatten({ a: 1, b: [2, { c: 3 }], d: 4 });
+ * console.log(result);
+ * // Output: [1, 2, 3, 4]
+ */
+exports.sizeOf = sizeOf;
+const flatten = function (o) {
+  if ((0, _is.isObject)(o) || (0, _is.isArray)(o)) {
+    return [].concat.apply([], (0, _traversal.map)(o, (i, val) => flatten(val)));
+  }
+  return o;
+};
+exports.flatten = flatten;
+const strParseFloat = function (val) {
+  if (!val) return 0;
+  return parseFloat((val + '').replace(/\s/g, '').replace(',', '.'));
+};
+exports.strParseFloat = strParseFloat;
+const throttle = function (func, wait, leading = true, trailing = true, context = null) {
+  let timeout = null;
+  let lastCall = 0;
+  return function (...args) {
+    const now = Date.now();
+    if (!lastCall && !leading) {
+      lastCall = now;
+    }
+    const remaining = wait - (now - lastCall);
+    if (remaining <= 0 || remaining > wait) {
+      lastCall = now;
+      func.apply(context || this, args);
+    } else if (!timeout && trailing) {
+      timeout = setTimeout(() => {
+        timeout = null;
+        lastCall = leading ? Date.now() : 0;
+        func.apply(context || this, args);
+      }, remaining);
+    }
+  };
+};
+
+/**
+ * Creates a debounced function that delays the invocation of `func` until after `wait` milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ *
+ * @param {Function} func - The function to debounce.
+ * @param {number} wait - The number of milliseconds to delay.
+ * @param {boolean} [immediate=false] - If true, execute `func` on the leading edge instead of the trailing.
+ * @param {Object} [context=null] - The context to bind to `func`.
+ * @returns {Function} The debounced function.
+ */
+exports.throttle = throttle;
+const debounce = function (func, wait, immediate = false, context = null) {
+  let timeout = null;
+  let lastCall = 0;
+  return function (...args) {
+    const now = Date.now();
+    if (immediate) {
+      if (!lastCall) {
+        lastCall = now;
+        func.apply(context || this, args);
+      }
+    }
+    clearTimeout(timeout);
+    timeout = null;
+    timeout = setTimeout(() => {
+      lastCall = now;
+      clearTimeout(timeout);
+      timeout = null;
+      func.apply(context || this, args);
+    }, wait);
+  };
+};
+exports.debounce = debounce;

package/dist/esm/array.js

@@ -0,0 +1,116 @@
+"use strict";
+
+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
+ *
+ * @param {*} value the searched value
+ * @param {Object|Array} arr the array
+ * @param {number} [index=0] if provided, search from this index
+ * @param {boolean} [strict=false] if true, search is done with strict equality
+ * @returns {boolean}
+ *
+ * @example
+ * inArray(2, [1, 2, 3])
+ * // → true
+ *
+ * @example
+ * inArray({a: 1}, {a: 1, b: 2})
+ * // → true
+ *
+ * @example
+ * inArray(5, [1, 2, 3])
+ * // → false
+ */
+const inArray = function (value, arr, index = 0, strict = false) {
+  let ret = false;
+  (0, _traversal.each)(arr, (i, val) => {
+    if (i >= index) {
+      if (strict) {
+        if (val === value) {
+          ret = true;
+          return false;
+        }
+      } else {
+        if ((0, _is.isObject)(value) && (0, _is.isObject)(val)) {
+          ret = (0, _utils.equals)(val, value);
+          return false;
+        } else if ((0, _is.isArray)(value) && (0, _is.isObject)(val)) {
+          ret = compareArray(val, value);
+          return false;
+        } else if (val == value) {
+          ret = true;
+          return false;
+        }
+      }
+    }
+  });
+  return ret;
+};
+exports.inArray = inArray;
+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) {
+      return from;
+    }
+  }
+  return -1;
+};
+exports.indexOf = indexOf;
+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])) {
+          return false;
+        }
+        return compareArray(a1[i], a2[i]);
+      } else if (a1[i] !== a2[i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+exports.compareArray = compareArray;
+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) => {
+  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);
+  const rng = [];
+  if ((0, _is.isUndefined)(startAt) || size < 1 || step === 0 || size < Math.abs(step)) {
+    return rng;
+  }
+  const end = size * step;
+  if ((0, _is.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)) {
+    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

@@ -0,0 +1,466 @@
+"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) {
+  return !!o && o === o.window;
+};
+exports.isWindow = isWindow;
+const isDomElement = function (o) {
+  return (0, _is.isObject)(o) && o instanceof HTMLElement;
+};
+exports.isDomElement = isDomElement;
+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 elem.style[(0, _string.camelCase)(cssRule)] || '';
+};
+exports.getStyle = getStyle;
+var _default = exports.default = {
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {NodeList}
+   */
+  children(el, selector) {
+    return selector ? this.find(el, `:scope > ${selector}`) : el.children;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {Element|null}
+   */
+  child(el, selector) {
+    return this.first(this.children(el, selector));
+  },
+  /**
+   * @param {Element|Document|string} refEl
+   * @param {string} [selector='*']
+   * @returns {NodeList}
+   */
+  find(refEl, selector = '*') {
+    if ((0, _is.isString)(refEl)) {
+      selector = refEl;
+      refEl = document;
+    }
+    try {
+      return refEl.querySelectorAll(selector);
+    } catch (e) {
+      return document.querySelectorAll(':not(*)');
+    }
+  },
+  /**
+   * @param {Element|Document|string} refEl
+   * @param {string} [selector='*']
+   * @returns {Element|null}
+   */
+  findOne(refEl, selector = '*') {
+    if ((0, _is.isString)(refEl)) {
+      selector = refEl;
+      refEl = document;
+    }
+    try {
+      return refEl.querySelector(selector);
+    } catch (e) {
+      return null;
+    }
+  },
+  /**
+   * @param {Element} el
+   * @param {string} className
+   * @returns {Element}
+   */
+  addClass(el, className) {
+    if (!className) return el;
+    const classNames = className.split(' ').map(c => c.trim()).filter(Boolean);
+    el.classList.add(...classNames);
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} classNames
+   * @returns {Element}
+   */
+  removeClass(el, classNames) {
+    if (!classNames) return el;
+    el.classList.remove(...classNames.split(' ').map(c => c.trim()).filter(Boolean));
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} classNames
+   * @param {boolean} [force]
+   * @returns {Element}
+   */
+  toggleClass(el, classNames, force) {
+    (0, _traversal.each)(classNames.split(' ').map(c => c.trim()).filter(Boolean), (i, c) => el.classList.toggle(c, force));
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} classNames
+   * @returns {boolean}
+   */
+  hasClass(el, classNames) {
+    return (0, _array.compareArray)([...el.classList], classNames.split(' ').map(c => c.trim()).filter(Boolean));
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} child
+   * @returns {Element}
+   */
+  append(el, child) {
+    el.append(child);
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} child
+   * @returns {Element}
+   */
+  prepend(el, child) {
+    el.prepend(child);
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @returns {void}
+   */
+  remove(el) {
+    el.remove();
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {Element|null}
+   */
+  closest(el, selector) {
+    return el.closest(selector);
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {Element|null}
+   */
+  next(el, selector = null) {
+    let sibling = el.nextElementSibling;
+    if (!selector) return sibling;
+    if (sibling && sibling.matches(selector)) {
+      return sibling;
+    }
+    return sibling;
+  },
+  /**
+   * @param {Element} el
+   * @param {string|null} [selector]
+   * @returns {Element|null}
+   */
+  prev(el, selector = null) {
+    let sibling = el.previousElementSibling;
+    if (!selector) return sibling;
+    if (sibling && sibling.matches(selector)) {
+      return sibling;
+    }
+    return null;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {Element[]}
+   */
+  nextAll(el, selector) {
+    const siblings = [];
+    let sibling = el.nextElementSibling;
+    while (sibling) {
+      if (undefined === selector || sibling.matches(selector)) {
+        siblings.push(sibling);
+      }
+      sibling = sibling.nextElementSibling;
+    }
+    return siblings;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [selector]
+   * @returns {Element[]}
+   */
+  prevAll(el, selector) {
+    const siblings = [];
+    let sibling = el.previousElementSibling;
+    while (sibling) {
+      if (undefined === selector || sibling.matches(selector)) {
+        siblings.push(sibling);
+      }
+      sibling = sibling.previousElementSibling;
+    }
+    return siblings;
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} wrappingElement
+   * @returns {Element}
+   */
+  wrap(el, wrappingElement) {
+    if (!wrappingElement.isConnected) {
+      el.parentNode.insertBefore(wrappingElement, el);
+    }
+    this.append(wrappingElement, el);
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} name
+   * @param {*} [value]
+   * @returns {Element|*}
+   */
+  attr(el, name, value) {
+    if (undefined === value) return el.getAttribute(name);
+    if (null === value) {
+      el.removeAttribute(name);
+    } else {
+      el.setAttribute(name, value);
+    }
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} name
+   * @param {*} [value]
+   * @returns {*|Element}
+   */
+  prop(el, name, value) {
+    if (undefined === value) {
+      return el[name];
+    }
+    el[name] = value;
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [html]
+   * @returns {Element|*}
+   */
+  html(el, html) {
+    if (undefined === html) return el.innerHTML;
+    el.innerHTML = html;
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} [text]
+   * @returns {Element|*}
+   */
+  text(el, text) {
+    if (undefined === text) return el.innerText;
+    el.innerText = text;
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @returns {Element}
+   */
+  hide(el) {
+    if (undefined === this.data(el, '__display__')) {
+      const display = getComputedStyle(el).display;
+      this.data(el, '__display__', display);
+    }
+    el.style.display = 'none';
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @returns {Element}
+   */
+  show(el) {
+    const dataDisplay = this.data(el, '__display__');
+    if (undefined === dataDisplay) {
+      el.style.removeProperty('display');
+    } else {
+      el.style.display = dataDisplay;
+      this.removeData(el, '__display__');
+    }
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @returns {Element}
+   */
+  toggle(el) {
+    return 'none' === el.style.display ? this.show(el) : this.hide(el);
+  },
+  /**
+   * @param {Element} el
+   * @param {Object<string, string>|string} name
+   * @param {string} [value]
+   * @returns {Element}
+   */
+  data(el, name, value) {
+    if ((0, _is.isPlainObject)(name)) {
+      (0, _traversal.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);
+    el.dataset[key] = value;
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} name
+   * @returns {Element|*}
+   */
+  removeData(el, name) {
+    const key = (name + '').replace(/^data-/, '').camelCase();
+    delete el.dataset[key];
+    return el;
+  },
+  /**
+   * @param {Element|Document|Window} el
+   * @param {string} event
+   * @param {function} handler
+   * @param {AddEventListenerOptions|false} options
+   * @returns {Element}
+   */
+  on(el, event, handler, options = false) {
+    el.addEventListener(event, handler, options);
+    return el;
+  },
+  /**
+   * @param {Element|Document|Window} el
+   * @param {string} event
+   * @param {function} handler
+   * @param {Object} options
+   * @returns {Element}
+   */
+  off(el, event, handler, options) {
+    el.removeEventListener(event, handler, options);
+    return el;
+  },
+  /**
+   * @param {HTMLElement} el
+   * @param {Object<string, string>|string} styles
+   * @param {string} [value]
+   * @returns {Element}
+   */
+  css(el, styles, value) {
+    if ((0, _is.isString)(styles)) {
+      if (undefined === value) {
+        return styles.startsWith('--') ? el.style.getPropertyValue(styles) : el.style[styles];
+      }
+      if (styles.startsWith('--')) {
+        el.style.setProperty(styles, String(value));
+      } else {
+        el.style[styles] = value;
+      }
+      return el;
+    }
+    (0, _traversal.each)(styles, (name, v) => {
+      if (name.startsWith('--')) {
+        el.style.setProperty(name, String(v));
+      } else {
+        el.style[name] = v;
+      }
+    });
+    return el;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} selectorClosest
+   * @param {string} selectorFind
+   * @returns {NodeList|null}
+   */
+  closestFind(el, selectorClosest, selectorFind) {
+    const closest = this.closest(el, selectorClosest);
+    if (closest) {
+      return this.find(closest, selectorFind);
+    }
+    return null;
+  },
+  /**
+   * @param {Element} el
+   * @param {string} selectorClosest
+   * @param {string} selectorFindOne
+   * @returns {Element|null}
+   */
+  closestFindOne(el, selectorClosest, selectorFindOne) {
+    const closest = this.closest(el, selectorClosest);
+    if (closest) {
+      return this.findOne(closest, selectorFindOne);
+    }
+    return null;
+  },
+  /**
+   * @param {NodeList} nodeList
+   * @returns {Element|null}
+   */
+  first(nodeList) {
+    return nodeList?.length ? nodeList.item(0) : null;
+  },
+  /**
+   * @param {NodeList} nodeList
+   * @returns {Element|null}
+   */
+  last(nodeList) {
+    return nodeList.length ? nodeList.item(nodeList.length - 1) : null;
+  },
+  /**
+   * @param {string} html
+   * @returns {Element}
+   */
+  create(html) {
+    const tpl = document.createElement('template');
+    tpl.innerHTML = html.trim();
+    return tpl.content.firstElementChild;
+  },
+  /**
+   * @param {NodeList} nodeList
+   * @param {number} [index=0]
+   * @returns {Element|null}
+   */
+  eq(nodeList, index = 0) {
+    if (Math.abs(index) >= nodeList.length) return null;
+    if (index < 0) {
+      index = nodeList.length + index;
+    }
+    return nodeList.item(index);
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} newEl
+   * @returns {Element}
+   */
+  after(el, newEl) {
+    return el.parentElement.insertBefore(newEl, el.nextElementSibling);
+  },
+  /**
+   * @param {Element} el
+   * @param {Element} newEl
+   * @returns {Element}
+   */
+  before(el, newEl) {
+    return el.parentElement.insertBefore(newEl, el);
+  },
+  /**
+   * @param {Element} el
+   * @returns {Element}
+   */
+  empty(el) {
+    while (el.firstChild) {
+      el.removeChild(el.firstChild);
+    }
+    return el;
+  }
+};