@splendidlabz/utils 1.11.3 → 1.11.5

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

@@ -0,0 +1,84 @@
+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/resize-observer.js
+var resize_observer_exports = {};
+__export(resize_observer_exports, {
+  resizeObserver: () => resizeObserver
+});
+module.exports = __toCommonJS(resize_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)
+    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()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resizeObserver
+});

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

@@ -0,0 +1,177 @@
+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)
+    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,
+  // 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 = { ...defaultOptions, ...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 = {
+  scrollObserver
+});

package/dist/cjs/dom/pkce.cjs

@@ -0,0 +1,53 @@
+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/pkce.js
+var pkce_exports = {};
+__export(pkce_exports, {
+  PKCE: () => PKCE
+});
+module.exports = __toCommonJS(pkce_exports);
+
+// 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 randomString();
+  const codeChallenge = await getCodeChallenge(codeVerifier);
+  return {
+    state: await randomString(),
+    code_verifier: codeVerifier,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  };
+}
+async function getCodeChallenge(verifier) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(verifier);
+  const hashed = await window.crypto.subtle.digest("SHA-256", data);
+  return window.btoa(String.fromCharCode.apply(null, new Uint8Array(hashed))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PKCE
+});

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

@@ -0,0 +1,38 @@
+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/query-params.js
+var query_params_exports = {};
+__export(query_params_exports, {
+  queryParams: () => queryParams
+});
+module.exports = __toCommonJS(query_params_exports);
+var queryParams = {
+  get(key) {
+    const searchParams = new URLSearchParams(location.search);
+    return searchParams.get(key);
+  },
+  stringify(params) {
+    const searchParams = new URLSearchParams(location.search);
+    return searchParams.toString();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  queryParams
+});

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

@@ -0,0 +1,38 @@
+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/random-string.js
+var random_string_exports = {};
+__export(random_string_exports, {
+  randomString: () => randomString,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(random_string_exports);
+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;
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  randomString,
+  uuid
+});

package/dist/cjs/dom/sanitize.cjs

@@ -0,0 +1,65 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dom/sanitize.js
+var sanitize_exports = {};
+__export(sanitize_exports, {
+  sanitize: () => sanitize2
+});
+module.exports = __toCommonJS(sanitize_exports);
+var import_dompurify = __toESM(require("dompurify"), 1);
+
+// src/lib/form/sanitize.js
+function sanitize(value, options = {}) {
+  const { sanitizer, ...rest } = options;
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (typeof value === "string") return sanitizer(value, rest);
+  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        sanitize(val, { sanitizer, ...rest })
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeArray(arr, { sanitizer, ...rest }) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
+}
+
+// src/dom/sanitize.js
+function sanitize2(value, options = {}) {
+  return sanitize(value, { sanitizer: import_dompurify.default.sanitize, ...options });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sanitize
+});

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

@@ -0,0 +1,49 @@
+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/session-store.js
+var session_store_exports = {};
+__export(session_store_exports, {
+  sessionStore: () => sessionStore
+});
+module.exports = __toCommonJS(session_store_exports);
+var sessionStore = {
+  get(key) {
+    const value = sessionStorage.getItem(key);
+    if (!value) return;
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      return value;
+    }
+  },
+  set(key, value) {
+    if (typeof value === "string") {
+      sessionStorage.setItem(key, value);
+    } else {
+      sessionStorage.setItem(key, JSON.stringify(value));
+    }
+  },
+  remove(key) {
+    sessionStorage.removeItem(key);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sessionStore
+});

package/dist/cjs/dom/spam-prevention.cjs

@@ -0,0 +1,50 @@
+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/spam-prevention.js
+var spam_prevention_exports = {};
+__export(spam_prevention_exports, {
+  preventSpam: () => preventSpam
+});
+module.exports = __toCommonJS(spam_prevention_exports);
+function preventSpam(form, { honeypotField = "hp", honeypotDuration = 2e3 } = {}) {
+  const startTime = Date.now();
+  let hasInteraction = false;
+  function checkForInteraction() {
+    hasInteraction = true;
+  }
+  const events = ["keydown", "mousemove", "touchstart", "click"];
+  events.forEach((event) => {
+    form.addEventListener(event, checkForInteraction, { once: true });
+  });
+  form.containsSpam = function() {
+    const fillTime = Date.now() - startTime;
+    const isTooFast = fillTime < honeypotDuration;
+    const honeypotInput = form.querySelector(`[name="${honeypotField}"]`);
+    const hasHoneypotValue = honeypotInput?.value?.trim();
+    const noInteraction = !hasInteraction;
+    events.forEach(
+      (event) => form.removeEventListener(event, checkForInteraction)
+    );
+    return isTooFast || !!hasHoneypotValue || noInteraction;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  preventSpam
+});