@splendidlabz/utils 1.11.2 → 1.11.4

package/dist/cjs/dom/keyboard.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/keyboard.js
 var keyboard_exports = {};
 __export(keyboard_exports, {
   isArrowKey: () => isArrowKey,

package/dist/cjs/dom/local-store.cjs

@@ -15,12 +15,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/local-store.js
 var local_store_exports = {};
 __export(local_store_exports, {
   localStore: () => localStore
 });
 module.exports = __toCommonJS(local_store_exports);
-const localStore = {
+var localStore = {
   /**
    * Retrieves a value from localStorage
    * @param {string} key - The key to retrieve from localStorage

package/dist/cjs/dom/media.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/media.js
 var media_exports = {};
 __export(media_exports, {
   imagesLoaded: () => imagesLoaded,

package/dist/cjs/dom/observers/index.cjs

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -10,18 +14,240 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/index.js
 var observers_exports = {};
+__export(observers_exports, {
+  intersectionObserver: () => intersectionObserver,
+  mutationObserver: () => mutationObserver,
+  resizeObserver: () => resizeObserver,
+  scrollObserver: () => scrollObserver
+});
 module.exports = __toCommonJS(observers_exports);
-__reExport(observers_exports, require("./intersection-observer.js"), module.exports);
-__reExport(observers_exports, require("./mutation-observer.js"), module.exports);
-__reExport(observers_exports, require("./resize-observer.js"), module.exports);
-__reExport(observers_exports, require("./scroll-observer.js"), module.exports);
+
+// src/dom/events.js
+function dispatchEvent(node, eventName, detail, options = {}) {
+  node.dispatchEvent(
+    new CustomEvent(eventName, {
+      ...options,
+      detail
+    })
+  );
+}
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
+function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
+  const targetType = getNodeType(target);
+  if (targetType === "element") observer[method](target, options);
+  if (targetType === "nodelist") {
+    const elements = Array.from(target);
+    elements.forEach((element) => observer[method](element, options));
+  }
+  if (targetType === "array") {
+    target.forEach((element) => observer[method](element, options));
+  }
+}
+
+// src/dom/observers/intersection-observer.js
+function intersectionObserver(target, options = {}) {
+  const { callback, ...opts } = options;
+  const observer = new IntersectionObserver(observerFn, opts);
+  useObserverMethodOnTarget(target, observer, "observe");
+  function observerFn(entries) {
+    for (const entry of entries) {
+      if (callback) callback({ entry, entries, observer });
+      else dispatchEvent(target, "intersect", { entry, entries, observer });
+    }
+  }
+  return {
+    observer,
+    observe(target2) {
+      useObserverMethodOnTarget(target2, observer, "observe", options);
+    },
+    unobserve(target2) {
+      useObserverMethodOnTarget(target2, observer, "unobserve");
+    },
+    takeRecords() {
+      return observer.takeRecords();
+    },
+    disconnect() {
+      const records = observer.takeRecords();
+      observer.disconnect();
+      if (records.length > 0) observerFn(records);
+    },
+    destroy() {
+      observer.disconnect();
+    }
+  };
+}
+
+// src/dom/observers/mutation-observer.js
+var defaultOptions = {
+  attributes: false,
+  childList: false,
+  subtree: false
+};
+function mutationObserver(target, options) {
+  options = { ...defaultOptions, ...options };
+  const { callback, ...opts } = options;
+  const observer = new MutationObserver(observerFn);
+  if (target === window) target = document.body;
+  useObserverMethodOnTarget(target, observer, "observe", opts);
+  function observerFn(entries) {
+    for (const entry of entries) {
+      if (callback) callback({ entry, entries, observer });
+      else dispatchEvent(target, "mutate", { entry, entries, observer });
+    }
+  }
+  return {
+    observer,
+    observe(target2) {
+      useObserverMethodOnTarget(target2, observer, "observe", options);
+    },
+    takeRecords() {
+      return observer.takeRecords();
+    },
+    disconnect() {
+      const records = observer.takeRecords();
+      observer.disconnect();
+      if (records.length > 0) observerFn(records);
+    },
+    destroy() {
+      observer.disconnect();
+    }
+  };
+}
+
+// src/dom/observers/resize-observer.js
+function resizeObserver(target, options) {
+  const { callback, ...opts } = options;
+  const observer = new ResizeObserver(observerFn);
+  if (target === window || target === document)
+    target = document.documentElement;
+  useObserverMethodOnTarget(target, observer, "observe", opts);
+  function observerFn(entries) {
+    for (const entry of entries) {
+      if (callback) callback({ entry, entries, observer });
+      else
+        dispatchEvent(entry.target, "resize-obs", { entry, entries, observer });
+    }
+  }
+  return {
+    observe(target2) {
+      useObserverMethodOnTarget(target2, observer, "observe", options);
+    },
+    unobserve(target2) {
+      useObserverMethodOnTarget(target2, observer, "unobserve");
+    },
+    disconnect: (_) => observer.disconnect(),
+    destroy: (_) => observer.disconnect()
+  };
+}
+
+// src/dom/observers/scroll-observer.js
+var defaultOptions2 = {
+  threshold: 0,
+  // Float between 0 to 1.
+  tolerance: 0.1,
+  // Float between 0 to 1. Tolerance for event firing
+  once: false
+  // Only fire threshold callback once
+};
+function getScrollElement(node) {
+  if (node === document || node === window || node === document.documentElement) {
+    return document.documentElement;
+  }
+  return (
+    /** @type {Element} */
+    node
+  );
+}
+function scrollObserver(node, options = {}) {
+  const { callback, onScrollDown, onScrollUp, onEnterThreshold, ...userOpts } = options;
+  const opts = { ...defaultOptions2, ...userOpts };
+  const { threshold, tolerance, once } = opts;
+  let prevScrollDirection = null;
+  let prevScrollTop = 0;
+  let prevScrollPercent = 0;
+  let thresholdFired = false;
+  let rafId = null;
+  const isDocumentScroll = node === document || node === window || node === document.documentElement;
+  const scrollElement = getScrollElement(node);
+  const eventTarget = isDocumentScroll ? window : node;
+  let cachedScrollHeight = 0;
+  let cachedClientHeight = 0;
+  updateCache();
+  const cacheObserver = resizeObserver(scrollElement, {
+    callback: updateCache
+  });
+  eventTarget.addEventListener("scroll", throttledObserve, { passive: true });
+  function throttledObserve() {
+    rafId = requestAnimationFrame(observe);
+  }
+  function updateCache() {
+    cachedScrollHeight = scrollElement.scrollHeight;
+    cachedClientHeight = scrollElement.clientHeight;
+  }
+  function observe() {
+    const scrollTop = scrollElement.scrollTop;
+    if (Math.abs(scrollTop - prevScrollTop) < 1) return;
+    const scrollDirection = scrollTop > prevScrollTop ? "down" : "up";
+    const maxScroll = Math.max(1, cachedScrollHeight - cachedClientHeight);
+    const scrollPercent = Math.min(1, Math.max(0, scrollTop / maxScroll));
+    const thresholdMin = threshold - tolerance / 2;
+    const thresholdMax = threshold + tolerance / 2;
+    const wasInThreshold = prevScrollPercent >= thresholdMin && prevScrollPercent <= thresholdMax;
+    const isInThreshold = scrollPercent >= thresholdMin && scrollPercent <= thresholdMax;
+    const hasEnteredThreshold = !wasInThreshold && isInThreshold && (!once || !thresholdFired);
+    if (hasEnteredThreshold && once) {
+      thresholdFired = true;
+    }
+    const callbackData = {
+      scrollTop,
+      scrollDirection,
+      scrollPercent,
+      directionChanged: scrollDirection !== prevScrollDirection,
+      hasEnteredThreshold,
+      isInThreshold
+    };
+    if (typeof callback === "function") {
+      callback(callbackData);
+    }
+    if (scrollDirection !== prevScrollDirection) {
+      if (scrollDirection === "down" && typeof onScrollDown === "function") {
+        onScrollDown(callbackData);
+      }
+      if (scrollDirection === "up" && typeof onScrollUp === "function") {
+        onScrollUp(callbackData);
+      }
+    }
+    if (hasEnteredThreshold && typeof onEnterThreshold === "function") {
+      onEnterThreshold(callbackData);
+    }
+    prevScrollTop = scrollTop;
+    prevScrollPercent = scrollPercent;
+    prevScrollDirection = scrollDirection;
+  }
+  return {
+    destroy() {
+      eventTarget.removeEventListener("scroll", throttledObserve);
+      if (rafId) cancelAnimationFrame(rafId);
+      cacheObserver.destroy();
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./intersection-observer.js"),
-  ...require("./mutation-observer.js"),
-  ...require("./resize-observer.js"),
-  ...require("./scroll-observer.js")
+  intersectionObserver,
+  mutationObserver,
+  resizeObserver,
+  scrollObserver
 });

package/dist/cjs/dom/observers/intersection-observer.cjs

@@ -15,30 +15,62 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/intersection-observer.js
 var intersection_observer_exports = {};
 __export(intersection_observer_exports, {
   intersectionObserver: () => intersectionObserver
 });
 module.exports = __toCommonJS(intersection_observer_exports);
-var import_events = require("../events.js");
-var import_observer = require("./observer.js");
+
+// src/dom/events.js
+function dispatchEvent(node, eventName, detail, options = {}) {
+  node.dispatchEvent(
+    new CustomEvent(eventName, {
+      ...options,
+      detail
+    })
+  );
+}
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
+function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
+  const targetType = getNodeType(target);
+  if (targetType === "element") observer[method](target, options);
+  if (targetType === "nodelist") {
+    const elements = Array.from(target);
+    elements.forEach((element) => observer[method](element, options));
+  }
+  if (targetType === "array") {
+    target.forEach((element) => observer[method](element, options));
+  }
+}
+
+// src/dom/observers/intersection-observer.js
 function intersectionObserver(target, options = {}) {
   const { callback, ...opts } = options;
   const observer = new IntersectionObserver(observerFn, opts);
-  (0, import_observer.useObserverMethodOnTarget)(target, observer, "observe");
+  useObserverMethodOnTarget(target, observer, "observe");
   function observerFn(entries) {
     for (const entry of entries) {
       if (callback) callback({ entry, entries, observer });
-      else (0, import_events.dispatchEvent)(target, "intersect", { entry, entries, observer });
+      else dispatchEvent(target, "intersect", { entry, entries, observer });
     }
   }
   return {
     observer,
     observe(target2) {
-      (0, import_observer.useObserverMethodOnTarget)(target2, observer, "observe", options);
+      useObserverMethodOnTarget(target2, observer, "observe", options);
     },
     unobserve(target2) {
-      (0, import_observer.useObserverMethodOnTarget)(target2, observer, "unobserve");
+      useObserverMethodOnTarget(target2, observer, "unobserve");
     },
     takeRecords() {
       return observer.takeRecords();

package/dist/cjs/dom/observers/mutation-observer.cjs

@@ -15,14 +15,46 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/mutation-observer.js
 var mutation_observer_exports = {};
 __export(mutation_observer_exports, {
   mutationObserver: () => mutationObserver
 });
 module.exports = __toCommonJS(mutation_observer_exports);
-var import_events = require("../events.js");
-var import_observer = require("./observer.js");
-const defaultOptions = {
+
+// src/dom/events.js
+function dispatchEvent(node, eventName, detail, options = {}) {
+  node.dispatchEvent(
+    new CustomEvent(eventName, {
+      ...options,
+      detail
+    })
+  );
+}
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
+function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
+  const targetType = getNodeType(target);
+  if (targetType === "element") observer[method](target, options);
+  if (targetType === "nodelist") {
+    const elements = Array.from(target);
+    elements.forEach((element) => observer[method](element, options));
+  }
+  if (targetType === "array") {
+    target.forEach((element) => observer[method](element, options));
+  }
+}
+
+// src/dom/observers/mutation-observer.js
+var defaultOptions = {
   attributes: false,
   childList: false,
   subtree: false
@@ -32,17 +64,17 @@ function mutationObserver(target, options) {
   const { callback, ...opts } = options;
   const observer = new MutationObserver(observerFn);
   if (target === window) target = document.body;
-  (0, import_observer.useObserverMethodOnTarget)(target, observer, "observe", opts);
+  useObserverMethodOnTarget(target, observer, "observe", opts);
   function observerFn(entries) {
     for (const entry of entries) {
       if (callback) callback({ entry, entries, observer });
-      else (0, import_events.dispatchEvent)(target, "mutate", { entry, entries, observer });
+      else dispatchEvent(target, "mutate", { entry, entries, observer });
     }
   }
   return {
     observer,
     observe(target2) {
-      (0, import_observer.useObserverMethodOnTarget)(target2, observer, "observe", options);
+      useObserverMethodOnTarget(target2, observer, "observe", options);
     },
     takeRecords() {
       return observer.takeRecords();

package/dist/cjs/dom/observers/observer.cjs

@@ -15,14 +15,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/observer.js
 var observer_exports = {};
 __export(observer_exports, {
   useObserverMethodOnTarget: () => useObserverMethodOnTarget
 });
 module.exports = __toCommonJS(observer_exports);
-var import_get_element = require("../get-element.js");
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
 function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
-  const targetType = (0, import_get_element.getNodeType)(target);
+  const targetType = getNodeType(target);
   if (targetType === "element") observer[method](target, options);
   if (targetType === "nodelist") {
     const elements = Array.from(target);

package/dist/cjs/dom/observers/resize-observer.cjs

@@ -15,32 +15,64 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/resize-observer.js
 var resize_observer_exports = {};
 __export(resize_observer_exports, {
   resizeObserver: () => resizeObserver
 });
 module.exports = __toCommonJS(resize_observer_exports);
-var import_events = require("../events.js");
-var import_observer = require("./observer.js");
+
+// src/dom/events.js
+function dispatchEvent(node, eventName, detail, options = {}) {
+  node.dispatchEvent(
+    new CustomEvent(eventName, {
+      ...options,
+      detail
+    })
+  );
+}
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
+function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
+  const targetType = getNodeType(target);
+  if (targetType === "element") observer[method](target, options);
+  if (targetType === "nodelist") {
+    const elements = Array.from(target);
+    elements.forEach((element) => observer[method](element, options));
+  }
+  if (targetType === "array") {
+    target.forEach((element) => observer[method](element, options));
+  }
+}
+
+// src/dom/observers/resize-observer.js
 function resizeObserver(target, options) {
   const { callback, ...opts } = options;
   const observer = new ResizeObserver(observerFn);
   if (target === window || target === document)
     target = document.documentElement;
-  (0, import_observer.useObserverMethodOnTarget)(target, observer, "observe", opts);
+  useObserverMethodOnTarget(target, observer, "observe", opts);
   function observerFn(entries) {
     for (const entry of entries) {
       if (callback) callback({ entry, entries, observer });
       else
-        (0, import_events.dispatchEvent)(entry.target, "resize-obs", { entry, entries, observer });
+        dispatchEvent(entry.target, "resize-obs", { entry, entries, observer });
     }
   }
   return {
     observe(target2) {
-      (0, import_observer.useObserverMethodOnTarget)(target2, observer, "observe", options);
+      useObserverMethodOnTarget(target2, observer, "observe", options);
     },
     unobserve(target2) {
-      (0, import_observer.useObserverMethodOnTarget)(target2, observer, "unobserve");
+      useObserverMethodOnTarget(target2, observer, "unobserve");
     },
     disconnect: (_) => observer.disconnect(),
     destroy: (_) => observer.disconnect()

package/dist/cjs/dom/observers/scroll-observer.cjs

@@ -15,13 +15,72 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/observers/scroll-observer.js
 var scroll_observer_exports = {};
 __export(scroll_observer_exports, {
   scrollObserver: () => scrollObserver
 });
 module.exports = __toCommonJS(scroll_observer_exports);
-var import_resize_observer = require("./resize-observer.js");
-const defaultOptions = {
+
+// src/dom/events.js
+function dispatchEvent(node, eventName, detail, options = {}) {
+  node.dispatchEvent(
+    new CustomEvent(eventName, {
+      ...options,
+      detail
+    })
+  );
+}
+
+// src/dom/get-element.js
+function getNodeType(node) {
+  if (node instanceof Element) return "element";
+  if (node instanceof NodeList) return "nodelist";
+  if (Array.isArray(node)) return "array";
+}
+
+// src/dom/observers/observer.js
+function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
+  const targetType = getNodeType(target);
+  if (targetType === "element") observer[method](target, options);
+  if (targetType === "nodelist") {
+    const elements = Array.from(target);
+    elements.forEach((element) => observer[method](element, options));
+  }
+  if (targetType === "array") {
+    target.forEach((element) => observer[method](element, options));
+  }
+}
+
+// src/dom/observers/resize-observer.js
+function resizeObserver(target, options) {
+  const { callback, ...opts } = options;
+  const observer = new ResizeObserver(observerFn);
+  if (target === window || target === document)
+    target = document.documentElement;
+  useObserverMethodOnTarget(target, observer, "observe", opts);
+  function observerFn(entries) {
+    for (const entry of entries) {
+      if (callback) callback({ entry, entries, observer });
+      else
+        dispatchEvent(entry.target, "resize-obs", { entry, entries, observer });
+    }
+  }
+  return {
+    observe(target2) {
+      useObserverMethodOnTarget(target2, observer, "observe", options);
+    },
+    unobserve(target2) {
+      useObserverMethodOnTarget(target2, observer, "unobserve");
+    },
+    disconnect: (_) => observer.disconnect(),
+    destroy: (_) => observer.disconnect()
+  };
+}
+
+// src/dom/observers/scroll-observer.js
+var defaultOptions = {
   threshold: 0,
   // Float between 0 to 1.
   tolerance: 0.1,
@@ -53,7 +112,7 @@ function scrollObserver(node, options = {}) {
   let cachedScrollHeight = 0;
   let cachedClientHeight = 0;
   updateCache();
-  const cacheObserver = (0, import_resize_observer.resizeObserver)(scrollElement, {
+  const cacheObserver = resizeObserver(scrollElement, {
     callback: updateCache
   });
   eventTarget.addEventListener("scroll", throttledObserve, { passive: true });

package/dist/cjs/dom/pkce.cjs

@@ -15,17 +15,27 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/pkce.js
 var pkce_exports = {};
 __export(pkce_exports, {
   PKCE: () => PKCE
 });
 module.exports = __toCommonJS(pkce_exports);
-var import_random_string = require("./random-string.js");
+
+// src/dom/random-string.js
+function randomString(length = 10) {
+  const firstLetter = String.fromCharCode(65 + Math.floor(Math.random() * 26));
+  const others = Math.random().toString(36).substring(2, 2 + length - 1);
+  return firstLetter + others;
+}
+
+// src/dom/pkce.js
 async function PKCE() {
-  const codeVerifier = await (0, import_random_string.randomString)();
+  const codeVerifier = await randomString();
   const codeChallenge = await getCodeChallenge(codeVerifier);
   return {
-    state: await (0, import_random_string.randomString)(),
+    state: await randomString(),
     code_verifier: codeVerifier,
     code_challenge: codeChallenge,
     code_challenge_method: "S256"

package/dist/cjs/dom/query-params.cjs

@@ -15,12 +15,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/query-params.js
 var query_params_exports = {};
 __export(query_params_exports, {
   queryParams: () => queryParams
 });
 module.exports = __toCommonJS(query_params_exports);
-const queryParams = {
+var queryParams = {
   get(key) {
     const searchParams = new URLSearchParams(location.search);
     return searchParams.get(key);

package/dist/cjs/dom/random-string.cjs

@@ -15,6 +15,8 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/random-string.js
 var random_string_exports = {};
 __export(random_string_exports, {
   randomString: () => randomString,