lazy-js-utils/dist/chunk-7P2KG5TJ.mjs

A collection of lazy-loaded JavaScript utilities for efficient development

import {
  isArray,
  isBool,
  isNull,
  isStr
} from "./chunk-4N54TZJJ.mjs";

// src/event/findElement.ts
function findElement(selector, all = false, currentNode = document) {
  if (isNull(all))
    return;
  if (!isBool(all)) {
    currentNode = all;
    all = false;
  }
  if (isArray(selector)) {
    return selector.reduce((result, c) => {
      const item = all ? currentNode.querySelectorAll(c) : currentNode.querySelector(c);
      if (!item)
        return result;
      return result = all ? [...result, ...item] : [...result, item];
    }, []);
  }
  return all ? currentNode.querySelectorAll(selector) : currentNode.querySelector(selector);
}

// src/utils/mount.ts
function mount(...args) {
  const len = args.length;
  const params = [...args];
  const elements = params.slice(0, len - 1);
  const callback = params.slice(-1)[0];
  let isMounted = false;
  let hasMounted = false;
  update();
  document.addEventListener("DOMContentLoaded", update);
  setTimeout(() => document.removeEventListener("DOMContentLoaded", update));
  function update() {
    if (hasMounted)
      return;
    elements.forEach(
      (element, index) => isStr(element) && (elements[index] = findElement(element) || element)
    );
    if (!isMounted && elements.some(isStr))
      return isMounted = true;
    if (elements.some(isStr)) {
      throw new Error(
        `${elements.filter(isStr).join(", ")} is not a HTMLElement`
      );
    }
    callback == null ? void 0 : callback(...elements);
    hasMounted = true;
  }
}

// src/utils/unmount.ts
function unmount(callback) {
  const fn = window.onunload || function() {
  };
  window.onunload = function(ev) {
    callback == null ? void 0 : callback(ev);
    fn.call(this, ev);
  };
  return callback;
}

// src/event/createElement.ts
function createElement(tag, attributes, innerHTML, options) {
  const el = document.createElement(tag, options);
  if (!attributes)
    return el;
  for (const key in attributes) el.setAttribute(key, attributes[key]);
  if (innerHTML)
    el.innerHTML = innerHTML;
  return el;
}

// src/event/useMutationObserver.ts
function useMutationObserver(element, callback, options = { childList: true }) {
  if (!element)
    return;
  let stopped = false;
  let stop;
  mount(element, (element2) => {
    const mutationObserver = new MutationObserver(callback);
    mutationObserver.observe(element2, options);
    stop = () => mutationObserver.disconnect();
    if (stopped)
      stop();
  });
  unmount(() => stop == null ? void 0 : stop());
  return () => {
    if (!stop)
      return stopped = true;
    stop == null ? void 0 : stop();
  };
}

export {
  findElement,
  mount,
  unmount,
  createElement,
  useMutationObserver
};