@webalternatif/js-core 1.0.0

package/.babelrc

@@ -0,0 +1,12 @@
+{
+    "presets": [
+        [
+            "@babel/preset-env",
+            {
+                "targets": {
+                    "node": "current"
+                }
+            }
+        ]
+    ]
+}

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,12 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="GrazieInspection" enabled="false" level="GRAMMAR_ERROR" enabled_by_default="false" />
+    <inspection_tool class="LanguageDetectionInspection" enabled="false" level="WARNING" enabled_by_default="false" />
+    <inspection_tool class="SpellCheckingInspection" enabled="false" level="TYPO" enabled_by_default="false">
+      <option name="processCode" value="true" />
+      <option name="processLiterals" value="true" />
+      <option name="processComments" value="true" />
+    </inspection_tool>
+  </profile>
+</component>

package/.idea/js-core.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/js-core.iml" filepath="$PROJECT_DIR$/.idea/js-core.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/php.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="MessDetectorOptionsConfiguration">
+    <option name="transferred" value="true" />
+  </component>
+  <component name="PHPCSFixerOptionsConfiguration">
+    <option name="transferred" value="true" />
+  </component>
+  <component name="PHPCodeSnifferOptionsConfiguration">
+    <option name="highlightLevel" value="WARNING" />
+    <option name="transferred" value="true" />
+  </component>
+  <component name="PhpProjectSharedConfiguration" php_language_level="8.2" />
+  <component name="PhpStanOptionsConfiguration">
+    <option name="transferred" value="true" />
+  </component>
+  <component name="PsalmOptionsConfiguration">
+    <option name="transferred" value="true" />
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 webalternatif
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# js-core
+A set of Javascript utility functions.
+
+## Functions
+
+## Tests
+

package/dist/cjs/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/cjs/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;
+  }
+};