@maxax/hooks 1.0.0

package/dist/index.mjs

@@ -0,0 +1,846 @@
+// src/use-boolean.ts
+import { ref } from "vue";
+function useBoolean(initValue = false) {
+  const bool = ref(initValue);
+  function setBool(value) {
+    bool.value = value;
+  }
+  function setTrue() {
+    setBool(true);
+  }
+  function setFalse() {
+    setBool(false);
+  }
+  function toggle() {
+    setBool(!bool.value);
+  }
+  return {
+    bool,
+    setBool,
+    setTrue,
+    setFalse,
+    toggle
+  };
+}
+
+// src/use-breakpoint.ts
+import { computed, ref as ref3, unref as unref2 } from "vue";
+
+// src/enum/breakpointEnum.ts
+var SizeEnum = /* @__PURE__ */ ((SizeEnum2) => {
+  SizeEnum2["XS"] = "XS";
+  SizeEnum2["SM"] = "SM";
+  SizeEnum2["MD"] = "MD";
+  SizeEnum2["LG"] = "LG";
+  SizeEnum2["XL"] = "XL";
+  SizeEnum2["XXL"] = "XXL";
+  return SizeEnum2;
+})(SizeEnum || {});
+var ScreenEnum = /* @__PURE__ */ ((ScreenEnum2) => {
+  ScreenEnum2[ScreenEnum2["XS"] = 320] = "XS";
+  ScreenEnum2[ScreenEnum2["SM"] = 640] = "SM";
+  ScreenEnum2[ScreenEnum2["MD"] = 768] = "MD";
+  ScreenEnum2[ScreenEnum2["LG"] = 960] = "LG";
+  ScreenEnum2[ScreenEnum2["XL"] = 1280] = "XL";
+  ScreenEnum2[ScreenEnum2["XXL"] = 1536] = "XXL";
+  return ScreenEnum2;
+})(ScreenEnum || {});
+var screenMap = /* @__PURE__ */ new Map();
+screenMap.set("XS" /* XS */, 320 /* XS */);
+screenMap.set("SM" /* SM */, 640 /* SM */);
+screenMap.set("MD" /* MD */, 768 /* MD */);
+screenMap.set("LG" /* LG */, 960 /* LG */);
+screenMap.set("XL" /* XL */, 1280 /* XL */);
+screenMap.set("XXL" /* XXL */, 1536 /* XXL */);
+
+// src/use-event-listener.ts
+import { ref as ref2, unref, watch } from "vue";
+import { useDebounceFn, useThrottleFn } from "@vueuse/core";
+function useEventListener({ el = window, name, listener, options, autoRemove = true, isDebounce = true, wait = 80 }) {
+  let remove = () => {
+  };
+  const isAddRef = ref2(false);
+  if (el) {
+    const element = ref2(el);
+    const handler = isDebounce ? useDebounceFn(listener, wait) : useThrottleFn(listener, wait);
+    const realHandler = wait ? handler : listener;
+    const removeEventListener = (e) => {
+      isAddRef.value = true;
+      e.removeEventListener(name, realHandler, options);
+    };
+    const addEventListener = (e) => e.addEventListener(name, realHandler, options);
+    const removeWatch = watch(
+      element,
+      (v, _ov, cleanUp) => {
+        if (v) {
+          !unref(isAddRef) && addEventListener(v);
+          cleanUp(() => {
+            autoRemove && removeEventListener(v);
+          });
+        }
+      },
+      { immediate: true }
+    );
+    remove = () => {
+      removeEventListener(element.value);
+      removeWatch();
+    };
+  }
+  return { removeEvent: remove };
+}
+
+// src/use-breakpoint.ts
+var globalScreenRef;
+var globalWidthRef;
+var globalRealWidthRef;
+function useBreakpoint() {
+  return {
+    screenRef: computed(() => unref2(globalScreenRef)),
+    widthRef: globalWidthRef,
+    screenEnum: ScreenEnum,
+    realWidthRef: globalRealWidthRef
+  };
+}
+function createBreakpointListen(fn) {
+  const screenRef = ref3("XL" /* XL */);
+  const realWidthRef = ref3(window.innerWidth);
+  function getWindowWidth() {
+    const width = document.body.clientWidth;
+    const xs = screenMap.get("XS" /* XS */);
+    const sm = screenMap.get("SM" /* SM */);
+    const md = screenMap.get("MD" /* MD */);
+    const lg = screenMap.get("LG" /* LG */);
+    const xl = screenMap.get("XL" /* XL */);
+    if (width < xs) {
+      screenRef.value = "XS" /* XS */;
+    } else if (width < sm) {
+      screenRef.value = "SM" /* SM */;
+    } else if (width < md) {
+      screenRef.value = "MD" /* MD */;
+    } else if (width < lg) {
+      screenRef.value = "LG" /* LG */;
+    } else if (width < xl) {
+      screenRef.value = "XL" /* XL */;
+    } else {
+      screenRef.value = "XXL" /* XXL */;
+    }
+    realWidthRef.value = width;
+  }
+  useEventListener({
+    el: window,
+    name: "resize",
+    listener: () => {
+      getWindowWidth();
+      resizeFn();
+    }
+    // Wait: 100,
+  });
+  getWindowWidth();
+  globalScreenRef = computed(() => unref2(screenRef));
+  globalWidthRef = computed(() => screenMap.get(unref2(screenRef)));
+  globalRealWidthRef = computed(() => unref2(realWidthRef));
+  function resizeFn() {
+    fn == null ? void 0 : fn({
+      screen: globalScreenRef,
+      width: globalWidthRef,
+      realWidth: globalRealWidthRef,
+      screenEnum: ScreenEnum,
+      screenMap,
+      sizeEnum: SizeEnum
+    });
+  }
+  resizeFn();
+  return {
+    screenRef: globalScreenRef,
+    screenEnum: ScreenEnum,
+    widthRef: globalWidthRef,
+    realWidthRef: globalRealWidthRef
+  };
+}
+
+// src/use-browser-location.ts
+import { onMounted, onUnmounted, ref as ref4 } from "vue";
+var isBrowser = typeof document !== "undefined" && typeof window !== "undefined";
+function useBrowserLocation(customWindow = isBrowser ? window : null) {
+  const getWindowLocation = () => {
+    const { hash, host, hostname, href, origin, pathname, port, protocol, search } = (customWindow == null ? void 0 : customWindow.location) || {};
+    return {
+      hash,
+      host,
+      hostname,
+      href,
+      origin,
+      pathname,
+      port,
+      protocol,
+      search
+    };
+  };
+  const locationState = ref4(getWindowLocation());
+  const updateLocation = () => {
+    locationState.value = getWindowLocation();
+  };
+  onMounted(() => {
+    if (customWindow) {
+      customWindow.addEventListener("popstate", updateLocation);
+      customWindow.addEventListener("hashchange", updateLocation);
+    }
+  });
+  onUnmounted(() => {
+    if (customWindow) {
+      customWindow.removeEventListener("popstate", updateLocation);
+      customWindow.removeEventListener("hashchange", updateLocation);
+    }
+  });
+  return locationState;
+}
+
+// src/use-collection.ts
+import { getCurrentInstance, inject, onBeforeUnmount, onMounted as onMounted2, watch as watch2 } from "vue";
+function useInjectionInstanceCollection(injectionName, collectionKey, registerKeyRef) {
+  var _a;
+  const injection = inject(injectionName, null);
+  if (injection === null) return;
+  const vm = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;
+  watch2(registerKeyRef, registerInstance);
+  registerInstance(registerKeyRef.value);
+  onBeforeUnmount(() => {
+    registerInstance(void 0, registerKeyRef.value);
+  });
+  function registerInstance(key, oldKey) {
+    if (!injection) return;
+    const collection = injection[collectionKey];
+    if (oldKey !== void 0) removeInstance(collection, oldKey);
+    if (key !== void 0) addInstance(collection, key);
+  }
+  function removeInstance(collection, key) {
+    if (!collection[key]) collection[key] = [];
+    collection[key].splice(
+      collection[key].findIndex((instance) => instance === vm),
+      1
+    );
+  }
+  function addInstance(collection, key) {
+    if (!collection[key]) collection[key] = [];
+    if (!~collection[key].findIndex((instance) => instance === vm)) {
+      collection[key].push(vm);
+    }
+  }
+}
+function useInjectionCollection(injectionName, collectionKey, valueRef) {
+  const injection = inject(injectionName, null);
+  if (injection === null) return;
+  if (!(collectionKey in injection)) {
+    injection[collectionKey] = [];
+  }
+  injection[collectionKey].push(valueRef.value);
+  watch2(valueRef, (value, prevValue) => {
+    const collectionArray = injection[collectionKey];
+    const index = collectionArray.findIndex((collectionValue) => collectionValue === prevValue);
+    if (~index) collectionArray.splice(index, 1);
+    collectionArray.push(value);
+  });
+  onBeforeUnmount(() => {
+    const collectionArray = injection[collectionKey];
+    const index = collectionArray.findIndex((collectionValue) => collectionValue === valueRef.value);
+    if (~index) collectionArray.splice(index, 1);
+  });
+}
+function useInjectionElementCollection(injectionName, collectionKey, getElement) {
+  const injection = inject(injectionName, null);
+  if (injection === null) return;
+  if (!(collectionKey in injection)) {
+    injection[collectionKey] = [];
+  }
+  onMounted2(() => {
+    const el = getElement();
+    if (!el) return;
+    injection[collectionKey].push(el);
+  });
+  onBeforeUnmount(() => {
+    const collectionArray = injection[collectionKey];
+    const element = getElement();
+    const index = collectionArray.findIndex((collectionElement) => collectionElement === element);
+    if (~index) collectionArray.splice(index, 1);
+  });
+}
+
+// src/use-context.ts
+import { inject as inject2, provide } from "vue";
+function useContext(contextName, fn) {
+  const { useProvide, useInject: useStore } = createContext(contextName);
+  function setupStore(...args) {
+    const context = fn(...args);
+    return useProvide(context);
+  }
+  return {
+    /** Setup store in the parent component */
+    setupStore,
+    /** Use store in the child component */
+    useStore
+  };
+}
+function createContext(contextName) {
+  const injectKey = Symbol(contextName);
+  function useProvide(context) {
+    provide(injectKey, context);
+    return context;
+  }
+  function useInject() {
+    return inject2(injectKey);
+  }
+  return {
+    useProvide,
+    useInject
+  };
+}
+
+// src/use-count-down.ts
+import { computed as computed2, onScopeDispose, ref as ref5 } from "vue";
+import { useRafFn } from "@vueuse/core";
+function useCountDown(seconds) {
+  const FPS_PER_SECOND = 60;
+  const fps = ref5(0);
+  const count = computed2(() => Math.ceil(fps.value / FPS_PER_SECOND));
+  const isCounting = computed2(() => fps.value > 0);
+  const { pause, resume } = useRafFn(
+    () => {
+      if (fps.value > 0) {
+        fps.value -= 1;
+      } else {
+        pause();
+      }
+    },
+    { immediate: false }
+  );
+  function start(updateSeconds = seconds) {
+    fps.value = FPS_PER_SECOND * updateSeconds;
+    resume();
+  }
+  function stop() {
+    fps.value = 0;
+    pause();
+  }
+  onScopeDispose(() => {
+    pause();
+  });
+  return {
+    count,
+    isCounting,
+    start,
+    stop
+  };
+}
+
+// src/use-deferred-true.ts
+import { ref as ref6, watch as watch3 } from "vue";
+function useDeferredTrue(valueRef, delay, shouldDelayRef) {
+  if (!delay) return valueRef;
+  const delayedRef = ref6(valueRef.value);
+  let timerId = null;
+  watch3(valueRef, (value) => {
+    if (timerId !== null) window.clearTimeout(timerId);
+    if (value === true) {
+      if (shouldDelayRef && !shouldDelayRef.value) {
+        delayedRef.value = true;
+      } else {
+        timerId = window.setTimeout(() => {
+          delayedRef.value = true;
+        }, delay);
+      }
+    } else {
+      delayedRef.value = false;
+    }
+  });
+  return delayedRef;
+}
+
+// src/use-is-composing.ts
+import { onBeforeMount, onBeforeUnmount as onBeforeUnmount2, ref as ref7 } from "vue";
+var isComposingRef = ref7(false);
+function compositionStartHandler() {
+  isComposingRef.value = true;
+}
+function compositionEndHandler() {
+  isComposingRef.value = false;
+}
+var mountedCount = 0;
+function useIsComposing() {
+  if (document && window) {
+    onBeforeMount(() => {
+      if (!mountedCount) {
+        window.addEventListener("compositionstart", compositionStartHandler);
+        window.addEventListener("compositionend", compositionEndHandler);
+      }
+      mountedCount++;
+    });
+    onBeforeUnmount2(() => {
+      if (mountedCount <= 1) {
+        window.removeEventListener("compositionstart", compositionStartHandler);
+        window.removeEventListener("compositionend", compositionEndHandler);
+        mountedCount = 0;
+      } else {
+        mountedCount--;
+      }
+    });
+  }
+  return isComposingRef;
+}
+
+// src/use-layout-style.ts
+import { computed as computed3, onMounted as onMounted3, onUnmounted as onUnmounted2, ref as ref8 } from "vue";
+import { useCssVar, useDebounceFn as useDebounceFn2 } from "@vueuse/core";
+import { getElementVisibleRect } from "@maxax/utils";
+
+// src/const/index.ts
+var CSS_VARIABLE_LAYOUT_CONTENT_HEIGHT = "--max-content-height";
+var CSS_VARIABLE_LAYOUT_CONTENT_WIDTH = "--max-content-width";
+var CSS_VARIABLE_LAYOUT_HEADER_HEIGHT = "--max-header-height";
+var CSS_VARIABLE_LAYOUT_FOOTER_HEIGHT = "--max-footer-height";
+
+// src/use-layout-style.ts
+function useLayoutContentStyle(diffHeight = 0) {
+  let resizeObserver = null;
+  const contentElement = ref8(null);
+  const visibleDomRect = ref8(null);
+  const contentHeight = useCssVar(CSS_VARIABLE_LAYOUT_CONTENT_HEIGHT);
+  const contentWidth = useCssVar(CSS_VARIABLE_LAYOUT_CONTENT_WIDTH);
+  const overlayStyle = computed3(() => {
+    var _a;
+    const { height, left, top, width } = (_a = visibleDomRect.value) != null ? _a : {};
+    return {
+      height: `${height}px`,
+      left: `${left}px`,
+      position: "fixed",
+      top: `${top}px`,
+      width: `${width}px`,
+      zIndex: 150
+    };
+  });
+  const debouncedCalcHeight = useDebounceFn2((_entries) => {
+    visibleDomRect.value = getElementVisibleRect(contentElement.value);
+    contentHeight.value = `${visibleDomRect.value.height - diffHeight}px`;
+    contentWidth.value = `${visibleDomRect.value.width}px`;
+  }, 16);
+  onMounted3(() => {
+    if (contentElement.value && !resizeObserver) {
+      resizeObserver = new ResizeObserver(debouncedCalcHeight);
+      resizeObserver.observe(contentElement.value);
+    }
+  });
+  onUnmounted2(() => {
+    resizeObserver == null ? void 0 : resizeObserver.disconnect();
+    resizeObserver = null;
+  });
+  return { contentElement, overlayStyle, visibleDomRect };
+}
+function useLayoutHeaderStyle() {
+  const headerHeight = useCssVar(CSS_VARIABLE_LAYOUT_HEADER_HEIGHT);
+  return {
+    getLayoutHeaderHeight: () => {
+      return Number.parseInt(`${headerHeight.value}`, 10);
+    },
+    setLayoutHeaderHeight: (height) => {
+      headerHeight.value = `${height}px`;
+    }
+  };
+}
+function useLayoutFooterStyle() {
+  const footerHeight = useCssVar(CSS_VARIABLE_LAYOUT_FOOTER_HEIGHT);
+  return {
+    getLayoutFooterHeight: () => {
+      return Number.parseInt(`${footerHeight.value}`, 10);
+    },
+    setLayoutFooterHeight: (height) => {
+      footerHeight.value = `${height}px`;
+    }
+  };
+}
+
+// src/use-loading.ts
+function useLoading(initValue = false) {
+  const { bool: loading, setTrue: startLoading, setFalse: endLoading } = useBoolean(initValue);
+  return {
+    loading,
+    startLoading,
+    endLoading
+  };
+}
+
+// src/use-local-page.ts
+import { computed as computed4, ref as ref9, unref as unref3 } from "vue";
+function pagination(list, pageNo, pageSize) {
+  const offset = (pageNo - 1) * Number(pageSize);
+  const ret = offset + Number(pageSize) >= list.length ? list.slice(offset, list.length) : list.slice(offset, offset + Number(pageSize));
+  return ret;
+}
+function useLocalPage(list, pageSize) {
+  const currentPage = ref9(1);
+  const pageSizeRef = ref9(pageSize);
+  const listRef = ref9(list);
+  const getPaginationList = computed4(() => {
+    return pagination(unref3(listRef), unref3(currentPage), unref3(pageSizeRef));
+  });
+  const getTotal = computed4(() => {
+    return unref3(listRef).length;
+  });
+  function setCurrentPage(page) {
+    currentPage.value = page;
+  }
+  function setPageSize(size) {
+    pageSizeRef.value = size;
+  }
+  function setPagination(page) {
+    setCurrentPage(page.currentPage);
+    setPageSize(page.pageSize);
+  }
+  function getPageList() {
+    return pagination(unref3(listRef), unref3(currentPage), unref3(pageSizeRef));
+  }
+  return { setCurrentPage, getTotal, setPageSize, getPaginationList, setPagination, getPageList };
+}
+
+// src/use-lock-html-scroll.ts
+import { onBeforeUnmount as onBeforeUnmount3, onMounted as onMounted4, ref as ref10, watch as watch4 } from "vue";
+var lockCount = 0;
+var originalMarginRight = "";
+var originalOverflow = "";
+var originalOverflowX = "";
+var originalOverflowY = "";
+var lockHtmlScrollRightCompensationRef = ref10("0px");
+function useLockHtmlScroll(lockRef) {
+  if (typeof document === "undefined") return;
+  const el = document.documentElement;
+  let watchStopHandle;
+  let activated = false;
+  const unlock = () => {
+    el.style.marginRight = originalMarginRight;
+    el.style.overflow = originalOverflow;
+    el.style.overflowX = originalOverflowX;
+    el.style.overflowY = originalOverflowY;
+    lockHtmlScrollRightCompensationRef.value = "0px";
+  };
+  onMounted4(() => {
+    watchStopHandle = watch4(
+      lockRef,
+      (value) => {
+        if (value) {
+          if (!lockCount) {
+            const scrollbarWidth = window.innerWidth - el.offsetWidth;
+            if (scrollbarWidth > 0) {
+              originalMarginRight = el.style.marginRight;
+              el.style.marginRight = `${scrollbarWidth}px`;
+              lockHtmlScrollRightCompensationRef.value = `${scrollbarWidth}px`;
+            }
+            originalOverflow = el.style.overflow;
+            originalOverflowX = el.style.overflowX;
+            originalOverflowY = el.style.overflowY;
+            el.style.overflow = "hidden";
+            el.style.overflowX = "hidden";
+            el.style.overflowY = "hidden";
+          }
+          activated = true;
+          lockCount++;
+        } else {
+          lockCount--;
+          if (!lockCount) {
+            unlock();
+          }
+          activated = false;
+        }
+      },
+      {
+        immediate: true
+      }
+    );
+  });
+  onBeforeUnmount3(() => {
+    watchStopHandle == null ? void 0 : watchStopHandle();
+    if (activated) {
+      lockCount--;
+      if (!lockCount) {
+        unlock();
+      }
+      activated = false;
+    }
+  });
+}
+
+// src/use-memo.ts
+import { computed as computed5, ref as ref11, watch as watch5 } from "vue";
+function useMemo(getterOrOptions) {
+  const computedValueRef = computed5(getterOrOptions);
+  const valueRef = ref11(computedValueRef.value);
+  watch5(computedValueRef, (value) => {
+    valueRef.value = value;
+  });
+  if (typeof getterOrOptions === "function") {
+    return valueRef;
+  }
+  return {
+    __v_isRef: true,
+    get value() {
+      return valueRef.value;
+    },
+    set value(v) {
+      ;
+      getterOrOptions.set(v);
+    }
+  };
+}
+
+// src/use-merged-state.ts
+import { computed as computed6, watch as watch6 } from "vue";
+function useMergedState(controlledStateRef, uncontrolledStateRef) {
+  watch6(controlledStateRef, (value) => {
+    if (value !== void 0) {
+      uncontrolledStateRef.value = value;
+    }
+  });
+  return computed6(() => {
+    if (controlledStateRef.value === void 0) {
+      return uncontrolledStateRef.value;
+    }
+    return controlledStateRef.value;
+  });
+}
+
+// src/use-script.ts
+import { onMounted as onMounted5, onUnmounted as onUnmounted3, ref as ref12 } from "vue";
+function useScript(opts) {
+  const isLoading = ref12(false);
+  const error = ref12(false);
+  const success = ref12(false);
+  let script;
+  const promise = new Promise((resolve, reject) => {
+    onMounted5(() => {
+      script = document.createElement("script");
+      script.type = "text/javascript";
+      script.onload = () => {
+        isLoading.value = false;
+        success.value = true;
+        error.value = false;
+        resolve("");
+      };
+      script.onerror = (err) => {
+        isLoading.value = false;
+        success.value = false;
+        error.value = true;
+        reject(err);
+      };
+      script.src = opts.src;
+      document.head.appendChild(script);
+    });
+  });
+  onUnmounted3(() => {
+    script && script.remove();
+  });
+  return {
+    isLoading,
+    error,
+    success,
+    toPromise: () => promise
+  };
+}
+
+// src/use-scroll.ts
+import { onMounted as onMounted6, onUnmounted as onUnmounted4, ref as ref13, watch as watch7 } from "vue";
+import { useThrottleFn as useThrottleFn2 } from "@vueuse/core";
+import { isObject, isWindow } from "@maxax/utils";
+function useScroll(refEl, options) {
+  const refX = ref13(0);
+  const refY = ref13(0);
+  let handler = () => {
+    if (isWindow(refEl.value)) {
+      refX.value = refEl.value.scrollX;
+      refY.value = refEl.value.scrollY;
+    } else if (refEl.value) {
+      refX.value = refEl.value.scrollLeft;
+      refY.value = refEl.value.scrollTop;
+    }
+  };
+  if (isObject(options)) {
+    let wait = 0;
+    if (options && options.wait && options.wait > 0) {
+      wait = options.wait;
+      Reflect.deleteProperty(options, "wait");
+    }
+    handler = useThrottleFn2(handler, wait);
+  }
+  let stopWatch;
+  onMounted6(() => {
+    stopWatch = watch7(
+      refEl,
+      (el, prevEl, onCleanup) => {
+        if (el) {
+          el.addEventListener("scroll", handler);
+        } else if (prevEl) {
+          prevEl.removeEventListener("scroll", handler);
+        }
+        onCleanup(() => {
+          refX.value = 0;
+          refY.value = 0;
+          el && el.removeEventListener("scroll", handler);
+        });
+      },
+      { immediate: true }
+    );
+  });
+  onUnmounted4(() => {
+    refEl.value && refEl.value.removeEventListener("scroll", handler);
+  });
+  function stop() {
+    stopWatch && stopWatch();
+  }
+  return { refX, refY, stop };
+}
+
+// src/use-signal.ts
+import { computed as computed7, ref as ref14, shallowRef, triggerRef } from "vue";
+function useSignal(initialValue, options) {
+  const { useRef } = options || {};
+  const state = useRef ? ref14(initialValue) : shallowRef(initialValue);
+  return createSignal(state);
+}
+function useComputed(getterOrOptions, debugOptions) {
+  const isGetter = typeof getterOrOptions === "function";
+  const computedValue = computed7(getterOrOptions, debugOptions);
+  if (isGetter) {
+    return () => computedValue.value;
+  }
+  return createSignal(computedValue);
+}
+function createSignal(state) {
+  const signal = () => state.value;
+  signal.set = (value) => {
+    state.value = value;
+  };
+  signal.update = (updater) => {
+    state.value = updater(state.value);
+  };
+  signal.mutate = (mutator) => {
+    mutator(state.value);
+    triggerRef(state);
+  };
+  signal.getRef = () => state;
+  return signal;
+}
+
+// src/use-svg-icon-render.ts
+import { h } from "vue";
+function useSvgIconRender(SvgIcon) {
+  const SvgIconVNode = (config) => {
+    const { color, fontSize, icon, localIcon } = config;
+    const style = {};
+    if (color) {
+      style.color = color;
+    }
+    if (fontSize) {
+      style.fontSize = `${fontSize}px`;
+    }
+    if (!icon && !localIcon) {
+      return void 0;
+    }
+    return () => h(SvgIcon, { icon, localIcon, style });
+  };
+  return {
+    SvgIconVNode
+  };
+}
+
+// src/use-table.ts
+import { computed as computed8, reactive, ref as ref15 } from "vue";
+import { jsonClone } from "@maxax/utils";
+function useHookTable(config) {
+  const { loading, startLoading, endLoading } = useLoading();
+  const { bool: empty, setBool: setEmpty } = useBoolean();
+  const { apiFn, apiParams, transformer, immediate = true, getColumnChecks, getColumns } = config;
+  const searchParams = reactive(jsonClone({ ...apiParams }));
+  const allColumns = ref15(config.columns());
+  const data = ref15([]);
+  const columnChecks = ref15(getColumnChecks(config.columns()));
+  const columns = computed8(() => getColumns(allColumns.value, columnChecks.value));
+  function reloadColumns() {
+    allColumns.value = config.columns();
+    const checkMap = new Map(columnChecks.value.map((col) => [col.key, col.checked]));
+    const defaultChecks = getColumnChecks(allColumns.value);
+    columnChecks.value = defaultChecks.map((col) => {
+      var _a;
+      return {
+        ...col,
+        checked: (_a = checkMap.get(col.key)) != null ? _a : col.checked
+      };
+    });
+  }
+  async function getData() {
+    var _a;
+    startLoading();
+    const formattedParams = formatSearchParams(searchParams);
+    const response = await apiFn(formattedParams);
+    const transformed = transformer(response);
+    data.value = transformed.data;
+    setEmpty(transformed.data.length === 0);
+    await ((_a = config.onFetched) == null ? void 0 : _a.call(config, transformed));
+    endLoading();
+  }
+  function formatSearchParams(params) {
+    const formattedParams = {};
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== null && value !== void 0) {
+        formattedParams[key] = value;
+      }
+    });
+    return formattedParams;
+  }
+  function updateSearchParams(params) {
+    Object.assign(searchParams, params);
+  }
+  function resetSearchParams() {
+    Object.assign(searchParams, jsonClone(apiParams));
+  }
+  if (immediate) {
+    getData();
+  }
+  return {
+    loading,
+    empty,
+    data,
+    columns,
+    columnChecks,
+    reloadColumns,
+    getData,
+    searchParams,
+    updateSearchParams,
+    resetSearchParams
+  };
+}
+export {
+  createBreakpointListen,
+  lockHtmlScrollRightCompensationRef,
+  useBoolean,
+  useBreakpoint,
+  useBrowserLocation,
+  useComputed,
+  useContext,
+  useCountDown,
+  useDeferredTrue,
+  useEventListener,
+  useHookTable,
+  useInjectionCollection,
+  useInjectionElementCollection,
+  useInjectionInstanceCollection,
+  useIsComposing,
+  useLayoutContentStyle,
+  useLayoutFooterStyle,
+  useLayoutHeaderStyle,
+  useLoading,
+  useLocalPage,
+  useLockHtmlScroll,
+  useMemo,
+  useMergedState,
+  useScript,
+  useScroll,
+  useSignal,
+  useSvgIconRender
+};
+//# sourceMappingURL=index.mjs.map