@splendidlabz/utils 1.6.0 → 1.8.1

package/dist/esm/dom/keyboard.js

@@ -0,0 +1,23 @@
+// src/dom/keyboard.js
+function isTab(event) {
+  return !event.shiftKey && event.key === "Tab";
+}
+function isShiftTab(event) {
+  return event.shiftKey && event.key === "Tab";
+}
+function isTabKey(key) {
+  return key === "Tab";
+}
+function isArrowKey(key) {
+  return ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(key);
+}
+function isEscapeKey(key) {
+  return key === "Escape";
+}
+export {
+  isArrowKey,
+  isEscapeKey,
+  isShiftTab,
+  isTab,
+  isTabKey
+};

package/dist/esm/dom/local-store.js

@@ -0,0 +1,55 @@
+// src/dom/local-store.js
+var localStore = {
+  /**
+   * Retrieves a value from localStorage
+   * @param {string} key - The key to retrieve from localStorage
+   * @returns {any} The stored value. Returns parsed JSON if the value was stored as JSON. Returns the original string if not JSON, or undefined if key doesn't exist
+   */
+  get(key) {
+    const value = localStorage.getItem(key);
+    if (!value) return;
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      return value;
+    }
+  },
+  /**
+   * Stores a value in localStorage
+   * @param {string} key - The key to store the value under
+   * @param {any} value - The value to store. Objects will be stringified to JSON
+   */
+  set(key, value) {
+    if (typeof value === "string") {
+      localStorage.setItem(key, value);
+    } else {
+      localStorage.setItem(key, JSON.stringify(value));
+    }
+  },
+  /**
+   * Stores multiple key-value pairs in localStorage
+   * @param {Object|Map} data - An object or Map containing key-value pairs to store
+   */
+  setMultiple(data) {
+    for (const [key, value] of Object.entries(data)) {
+      this.set(key, value);
+    }
+  },
+  /**
+   * Removes a value from localStorage
+   * @param {string} key - The key to remove from localStorage
+   */
+  remove(key) {
+    localStorage.removeItem(key);
+  },
+  /**
+   * Removes multiple keys from localStorage
+   * @param {string[]} keys - Array of keys to remove from localStorage
+   */
+  removeMultiple(keys) {
+    keys.forEach((key) => this.remove(key));
+  }
+};
+export {
+  localStore
+};

package/dist/esm/dom/media.js

@@ -0,0 +1,33 @@
+// src/dom/media.js
+async function imagesLoaded(node) {
+  const images = Array.from(node.querySelectorAll("img"));
+  const promises = images.map((img) => {
+    return new Promise((resolve, reject) => {
+      if (img.complete) return resolve();
+      img.onload = resolve;
+      img.onerror = (e) => {
+        reject("Image failed to load");
+      };
+    });
+  });
+  return Promise.all(promises);
+}
+async function videosLoaded(node) {
+  const videos = Array.from(node.querySelectorAll("video"));
+  const promises = videos.map((video) => {
+    return new Promise((resolve, reject) => {
+      if (video.readyState === 4) return resolve();
+      video.onloadedmetadata = resolve;
+      video.onerror = reject;
+    });
+  });
+  return Promise.all(promises);
+}
+async function mediaLoaded(node) {
+  return Promise.all([imagesLoaded(node), videosLoaded(node)]);
+}
+export {
+  imagesLoaded,
+  mediaLoaded,
+  videosLoaded
+};

package/dist/esm/dom/observers/index.js

@@ -0,0 +1,128 @@
+// 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.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()
+  };
+}
+export {
+  intersectionObserver,
+  mutationObserver,
+  resizeObserver
+};

package/dist/esm/dom/observers/intersection-observer.js

@@ -0,0 +1,65 @@
+// 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();
+    }
+  };
+}
+export {
+  intersectionObserver
+};

package/dist/esm/dom/observers/mutation-observer.js

@@ -0,0 +1,69 @@
+// 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
+};
+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();
+    }
+  };
+}
+export {
+  mutationObserver
+};

package/dist/esm/dom/observers/observer.js

@@ -0,0 +1,22 @@
+// 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));
+  }
+}
+export {
+  useObserverMethodOnTarget
+};

package/dist/esm/dom/observers/resize-observer.js

@@ -0,0 +1,56 @@
+// 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()
+  };
+}
+export {
+  resizeObserver
+};

package/dist/esm/dom/pkce.js

@@ -0,0 +1,27 @@
+// 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(/=+$/, "");
+}
+export {
+  PKCE
+};

package/dist/esm/dom/query-params.js

@@ -0,0 +1,14 @@
+// src/dom/query-params.js
+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();
+  }
+};
+export {
+  queryParams
+};

package/dist/esm/dom/random-string.js

@@ -0,0 +1,13 @@
+// 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;
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+export {
+  randomString,
+  uuid
+};

package/dist/esm/dom/sanitize.js

@@ -0,0 +1,31 @@
+// src/dom/sanitize.js
+import DOMPurify from "dompurify";
+
+// 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: DOMPurify.sanitize, ...options });
+}
+export {
+  sanitize2 as sanitize
+};

package/dist/esm/dom/session-store.js

@@ -0,0 +1,25 @@
+// src/dom/session-store.js
+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);
+  }
+};
+export {
+  sessionStore
+};

package/dist/esm/dom/spam-prevention.js

@@ -0,0 +1,26 @@
+// src/dom/spam-prevention.js
+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;
+  };
+}
+export {
+  preventSpam
+};