@splendidlabz/utils 1.8.1 → 1.9.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @splendidlabz/utils
 
+## 1.9.0
+
+### Minor Changes
+
+- 8f2cb34: - 48406c69 Add JSDocs for events
+  - 304b5310 Utils: Add runCallback
+
+## 1.8.2
+
+### Patch Changes
+
+- - abd0770c Add pipeAsync and composeAsync along with tests
+
 ## 1.8.1
 
 ### Patch Changes

package/dist/cjs/dom/events.cjs

@@ -20,7 +20,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var events_exports = {};
 __export(events_exports, {
   addListeners: () => addListeners,
-  createListeners: () => createListeners,
   dispatchEvent: () => dispatchEvent,
   removeListeners: () => removeListeners,
   updateEvent: () => updateEvent
@@ -51,44 +50,9 @@ function updateEvent(event, updates) {
     ...updates
   });
 }
-function createListeners(listeners) {
-  listeners = listeners || [];
-  listeners.forEach((listener) => {
-    const { node, event, handler } = listener;
-    node.addEventListener(event, handler);
-  });
-  return {
-    get list() {
-      return listeners;
-    },
-    add({ node, event, handler }) {
-      listeners.push({ node, event, handler });
-      node.addEventListener(event, handler);
-    },
-    remove({ node, event, handler }) {
-      const index = listeners.findIndex((listener) => {
-        if (listener.node === node && listener.event === event && listener.handler === handler) {
-          return true;
-        }
-        return false;
-      });
-      if (index !== -1) {
-        listeners.splice(index, 1);
-        node.removeEventListener(event, handler);
-      }
-    },
-    clear() {
-      listeners.forEach(({ node, event, handler }) => {
-        listeners = [];
-        node.removeEventListener(event, handler);
-      });
-    }
-  };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addListeners,
-  createListeners,
   dispatchEvent,
   removeListeners,
   updateEvent

package/dist/cjs/dom/index.cjs

@@ -37,7 +37,6 @@ __export(dom_exports, {
   checkForAccessibleName: () => checkForAccessibleName,
   cookies: () => cookies,
   copyRichText: () => copyRichText,
-  createListeners: () => createListeners,
   dispatchEvent: () => dispatchEvent,
   em: () => em,
   findScrollContainer: () => findScrollContainer,
@@ -79,6 +78,7 @@ __export(dom_exports, {
   removeListeners: () => removeListeners,
   resizeObserver: () => resizeObserver,
   sanitize: () => sanitize2,
+  scrollObserver: () => scrollObserver,
   scrollToElement: () => scrollToElement,
   sessionStore: () => sessionStore,
   setCSSValue: () => setCSSValue,
@@ -230,40 +230,6 @@ function updateEvent(event, updates) {
     ...updates
   });
 }
-function createListeners(listeners) {
-  listeners = listeners || [];
-  listeners.forEach((listener) => {
-    const { node, event, handler } = listener;
-    node.addEventListener(event, handler);
-  });
-  return {
-    get list() {
-      return listeners;
-    },
-    add({ node, event, handler }) {
-      listeners.push({ node, event, handler });
-      node.addEventListener(event, handler);
-    },
-    remove({ node, event, handler }) {
-      const index = listeners.findIndex((listener) => {
-        if (listener.node === node && listener.event === event && listener.handler === handler) {
-          return true;
-        }
-        return false;
-      });
-      if (index !== -1) {
-        listeners.splice(index, 1);
-        node.removeEventListener(event, handler);
-      }
-    },
-    clear() {
-      listeners.forEach(({ node, event, handler }) => {
-        listeners = [];
-        node.removeEventListener(event, handler);
-      });
-    }
-  };
-}
 
 // src/dom/observers/observer.js
 function useObserverMethodOnTarget(target, observer, method = "observe", options = void 0) {
@@ -943,6 +909,94 @@ function mutationObserver(target, options) {
   };
 }
 
+// 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
+  throttle: 16,
+  // Throttle interval in ms (default: ~60fps)
+  once: false
+  // Only fire threshold callback once
+};
+function scrollObserver(node, options = {}) {
+  const { callback, onScrollDown, onScrollUp, onEnterThreshold, ...userOpts } = options;
+  const opts = { ...defaultOptions2, ...userOpts };
+  const { threshold, tolerance, throttle, once } = opts;
+  const prevScrollDirection = null;
+  let prevScrollTop = 0;
+  let prevScrollPercent = 0;
+  let lastThrottleTime = 0;
+  let thresholdFired = false;
+  let rafId = null;
+  const isDocumentScroll = node === document || node === window;
+  const scrollElement = isDocumentScroll ? document.documentElement : node;
+  let cachedScrollHeight = 0;
+  let cachedClientHeight = 0;
+  updateCache();
+  const cacheObserver = resizeObserver(scrollElement, {
+    callback: updateCache
+  });
+  node.addEventListener("scroll", throttledObserve, { passive: true });
+  function updateCache() {
+    cachedScrollHeight = scrollElement.scrollHeight;
+    cachedClientHeight = scrollElement.clientHeight;
+  }
+  function throttledObserve() {
+    const now = Date.now();
+    if (now - lastThrottleTime < throttle) return;
+    lastThrottleTime = now;
+    rafId = requestAnimationFrame(observe);
+  }
+  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;
+  }
+  return {
+    destroy() {
+      node.removeEventListener("scroll", throttledObserve);
+      if (rafId) cancelAnimationFrame(rafId);
+      cacheObserver.destroy();
+    }
+  };
+}
+
 // src/dom/random-string.js
 function randomString(length = 10) {
   const firstLetter = String.fromCharCode(65 + Math.floor(Math.random() * 26));
@@ -1140,7 +1194,6 @@ function scrambleText(text) {
   checkForAccessibleName,
   cookies,
   copyRichText,
-  createListeners,
   dispatchEvent,
   em,
   findScrollContainer,
@@ -1182,6 +1235,7 @@ function scrambleText(text) {
   removeListeners,
   resizeObserver,
   sanitize,
+  scrollObserver,
   scrollToElement,
   sessionStore,
   setCSSValue,

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

@@ -21,7 +21,8 @@ var observers_exports = {};
 __export(observers_exports, {
   intersectionObserver: () => intersectionObserver,
   mutationObserver: () => mutationObserver,
-  resizeObserver: () => resizeObserver
+  resizeObserver: () => resizeObserver,
+  scrollObserver: () => scrollObserver
 });
 module.exports = __toCommonJS(observers_exports);
 
@@ -148,9 +149,98 @@ function resizeObserver(target, options) {
     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
+  throttle: 16,
+  // Throttle interval in ms (default: ~60fps)
+  once: false
+  // Only fire threshold callback once
+};
+function scrollObserver(node, options = {}) {
+  const { callback, onScrollDown, onScrollUp, onEnterThreshold, ...userOpts } = options;
+  const opts = { ...defaultOptions2, ...userOpts };
+  const { threshold, tolerance, throttle, once } = opts;
+  const prevScrollDirection = null;
+  let prevScrollTop = 0;
+  let prevScrollPercent = 0;
+  let lastThrottleTime = 0;
+  let thresholdFired = false;
+  let rafId = null;
+  const isDocumentScroll = node === document || node === window;
+  const scrollElement = isDocumentScroll ? document.documentElement : node;
+  let cachedScrollHeight = 0;
+  let cachedClientHeight = 0;
+  updateCache();
+  const cacheObserver = resizeObserver(scrollElement, {
+    callback: updateCache
+  });
+  node.addEventListener("scroll", throttledObserve, { passive: true });
+  function updateCache() {
+    cachedScrollHeight = scrollElement.scrollHeight;
+    cachedClientHeight = scrollElement.clientHeight;
+  }
+  function throttledObserve() {
+    const now = Date.now();
+    if (now - lastThrottleTime < throttle) return;
+    lastThrottleTime = now;
+    rafId = requestAnimationFrame(observe);
+  }
+  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;
+  }
+  return {
+    destroy() {
+      node.removeEventListener("scroll", throttledObserve);
+      if (rafId) cancelAnimationFrame(rafId);
+      cacheObserver.destroy();
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   intersectionObserver,
   mutationObserver,
-  resizeObserver
+  resizeObserver,
+  scrollObserver
 });

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

@@ -0,0 +1,170 @@
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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);
+
+// 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.body;
+  useObserverMethodOnTarget(target, observer, "observe", opts);
+  function observerFn(entries) {
+    for (const entry of entries) {
+      if (callback) callback({ entry, entries, observer });
+      else dispatchEvent(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,
+  // Float between 0 to 1. Tolerance for event firing
+  throttle: 16,
+  // Throttle interval in ms (default: ~60fps)
+  once: false
+  // Only fire threshold callback once
+};
+function scrollObserver(node, options = {}) {
+  const { callback, onScrollDown, onScrollUp, onEnterThreshold, ...userOpts } = options;
+  const opts = { ...defaultOptions, ...userOpts };
+  const { threshold, tolerance, throttle, once } = opts;
+  const prevScrollDirection = null;
+  let prevScrollTop = 0;
+  let prevScrollPercent = 0;
+  let lastThrottleTime = 0;
+  let thresholdFired = false;
+  let rafId = null;
+  const isDocumentScroll = node === document || node === window;
+  const scrollElement = isDocumentScroll ? document.documentElement : node;
+  let cachedScrollHeight = 0;
+  let cachedClientHeight = 0;
+  updateCache();
+  const cacheObserver = resizeObserver(scrollElement, {
+    callback: updateCache
+  });
+  node.addEventListener("scroll", throttledObserve, { passive: true });
+  function updateCache() {
+    cachedScrollHeight = scrollElement.scrollHeight;
+    cachedClientHeight = scrollElement.clientHeight;
+  }
+  function throttledObserve() {
+    const now = Date.now();
+    if (now - lastThrottleTime < throttle) return;
+    lastThrottleTime = now;
+    rafId = requestAnimationFrame(observe);
+  }
+  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;
+  }
+  return {
+    destroy() {
+      node.removeEventListener("scroll", throttledObserve);
+      if (rafId) cancelAnimationFrame(rafId);
+      cacheObserver.destroy();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scrollObserver
+});

package/dist/cjs/lib/functions/callback.cjs

@@ -0,0 +1,31 @@
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/functions/callback.js
+var callback_exports = {};
+__export(callback_exports, {
+  runCallback: () => runCallback
+});
+module.exports = __toCommonJS(callback_exports);
+function runCallback(fn, ...data) {
+  if (typeof fn === "function") fn(data);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCallback
+});

package/dist/cjs/lib/functions/functional.cjs

@@ -20,8 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var functional_exports = {};
 __export(functional_exports, {
   compose: () => compose,
+  composeAsync: () => composeAsync,
   curry: () => curry,
   pipe: () => pipe,
+  pipeAsync: () => pipeAsync,
   times: () => times
 });
 module.exports = __toCommonJS(functional_exports);
@@ -41,11 +43,27 @@ function compose(...fns) {
     return fns.reduceRight((acc, fn) => fn(acc), value);
   };
 }
+function composeAsync(...fns) {
+  return async function(value) {
+    return fns.reduceRight(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
 function pipe(...fns) {
   return function(value) {
     return fns.reduce((acc, fn) => fn(acc), value);
   };
 }
+function pipeAsync(...fns) {
+  return async function(value) {
+    return fns.reduce(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
 function times(fn, n) {
   const result = [];
   for (let i = 0; i < n; i++) {
@@ -56,7 +74,9 @@ function times(fn, n) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compose,
+  composeAsync,
   curry,
   pipe,
+  pipeAsync,
   times
 });

package/dist/cjs/lib/functions/index.cjs

@@ -20,11 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var functions_exports = {};
 __export(functions_exports, {
   compose: () => compose,
+  composeAsync: () => composeAsync,
   curry: () => curry,
   debounce: () => debounce,
   delay: () => delay,
   getEnv: () => getEnv,
   pipe: () => pipe,
+  pipeAsync: () => pipeAsync,
   throttle: () => throttle,
   timeout: () => timeout,
   times: () => times,
@@ -72,11 +74,27 @@ function compose(...fns) {
     return fns.reduceRight((acc, fn) => fn(acc), value);
   };
 }
+function composeAsync(...fns) {
+  return async function(value) {
+    return fns.reduceRight(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
 function pipe(...fns) {
   return function(value) {
     return fns.reduce((acc, fn) => fn(acc), value);
   };
 }
+function pipeAsync(...fns) {
+  return async function(value) {
+    return fns.reduce(async (acc, fn) => {
+      const result = await acc;
+      return await fn(result);
+    }, value);
+  };
+}
 function times(fn, n) {
   const result = [];
   for (let i = 0; i < n; i++) {
@@ -110,11 +128,13 @@ function wait(ms) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compose,
+  composeAsync,
   curry,
   debounce,
   delay,
   getEnv,
   pipe,
+  pipeAsync,
   throttle,
   timeout,
   times,