cisse-vue-ui 0.7.3 → 0.7.5

package/dist/index-D1x3TH9k.cjs

@@ -0,0 +1,401 @@
+"use strict";
+const vue = require("vue");
+const useId = require("./useId-nxrBaIC9.cjs");
+const _hoisted_1 = ["id", "checked", "disabled", "indeterminate", "aria-describedby"];
+const _hoisted_2 = {
+  key: 0,
+  class: "flex flex-col"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "text-sm font-medium text-gray-900 dark:text-white"
+};
+const _hoisted_4 = ["id"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "Checkbox",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    label: {},
+    description: {},
+    disabled: { type: Boolean },
+    indeterminate: { type: Boolean },
+    id: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { id: generatedId, related } = useId.useId({ prefix: "checkbox", id: props.id });
+    const inputId = vue.computed(() => props.id ?? generatedId.value);
+    const descriptionId = vue.computed(() => related("description"));
+    const toggle = (event) => {
+      const target = event.target;
+      emit("update:modelValue", target.checked);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("label", {
+        class: vue.normalizeClass(["inline-flex items-start gap-3", __props.disabled ? "cursor-not-allowed opacity-50" : "cursor-pointer"])
+      }, [
+        vue.createElementVNode("input", {
+          id: inputId.value,
+          type: "checkbox",
+          checked: __props.modelValue,
+          disabled: __props.disabled,
+          indeterminate: __props.indeterminate,
+          "aria-describedby": __props.description ? descriptionId.value : void 0,
+          class: "mt-0.5 size-4 rounded border-gray-300 text-primary/90 focus:ring-2 focus:ring-primary focus:ring-offset-2 disabled:cursor-not-allowed dark:border-gray-600 dark:bg-gray-800 dark:focus:ring-offset-gray-900",
+          onChange: toggle
+        }, null, 40, _hoisted_1),
+        __props.label || __props.description ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          __props.label ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3, vue.toDisplayString(__props.label), 1)) : vue.createCommentVNode("", true),
+          __props.description ? (vue.openBlock(), vue.createElementBlock("span", {
+            key: 1,
+            id: descriptionId.value,
+            class: "text-sm text-gray-500 dark:text-gray-400"
+          }, vue.toDisplayString(__props.description), 9, _hoisted_4)) : vue.createCommentVNode("", true)
+        ])) : vue.createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+  var _getCurrentInstance;
+  const key = args[0];
+  const instance = (_getCurrentInstance = vue.getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : vue.getCurrentScope();
+  if (owner == null && !vue.hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+  if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+  return vue.inject(...args);
+};
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const noop = () => {
+};
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(filter(() => fn.apply(this, args), {
+        fn,
+        thisArg: this,
+        args
+      })).then(resolve).catch(reject);
+    });
+  }
+  return wrapper;
+}
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastRejector = noop;
+  const _clearTimeout = (timer$1) => {
+    clearTimeout(timer$1);
+    lastRejector();
+    lastRejector = noop;
+  };
+  let lastInvoker;
+  const filter = (invoke$1) => {
+    const duration = vue.toValue(ms);
+    const maxDuration = vue.toValue(options.maxWait);
+    if (timer) _clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        _clearTimeout(maxTimer);
+        maxTimer = void 0;
+      }
+      return Promise.resolve(invoke$1());
+    }
+    return new Promise((resolve, reject) => {
+      lastRejector = options.rejectOnCancel ? reject : resolve;
+      lastInvoker = invoke$1;
+      if (maxDuration && !maxTimer) maxTimer = setTimeout(() => {
+        if (timer) _clearTimeout(timer);
+        maxTimer = void 0;
+        resolve(lastInvoker());
+      }, maxDuration);
+      timer = setTimeout(() => {
+        if (maxTimer) _clearTimeout(maxTimer);
+        maxTimer = void 0;
+        resolve(invoke$1());
+      }, duration);
+    });
+  };
+  return filter;
+}
+function increaseWithUnit(target, delta) {
+  var _target$match;
+  if (typeof target === "number") return target + delta;
+  const value = ((_target$match = target.match(/^-?\d+\.?\d*/)) === null || _target$match === void 0 ? void 0 : _target$match[0]) || "";
+  const unit = target.slice(value.length);
+  const result = Number.parseFloat(value) + delta;
+  if (Number.isNaN(result)) return target;
+  return result + unit;
+}
+function pxValue(px) {
+  return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function getLifeCycleTarget(target) {
+  return vue.getCurrentInstance();
+}
+// @__NO_SIDE_EFFECTS__
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(debounceFilter(ms, options), fn);
+}
+function tryOnMounted(fn, sync = true, target) {
+  if (getLifeCycleTarget()) vue.onMounted(fn, target);
+  else if (sync) fn();
+  else vue.nextTick(fn);
+}
+function watchImmediate(source, cb, options) {
+  return vue.watch(source, cb, {
+    ...options,
+    immediate: true
+  });
+}
+const defaultWindow = isClient ? window : void 0;
+function unrefElement(elRef) {
+  var _$el;
+  const plain = vue.toValue(elRef);
+  return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
+}
+function useEventListener(...args) {
+  const register = (el, event, listener, options) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
+  };
+  const firstParamTargets = vue.computed(() => {
+    const test = toArray(vue.toValue(args[0])).filter((e) => e != null);
+    return test.every((e) => typeof e !== "string") ? test : void 0;
+  });
+  return watchImmediate(() => {
+    var _firstParamTargets$va, _firstParamTargets$va2;
+    return [
+      (_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
+      toArray(vue.toValue(firstParamTargets.value ? args[1] : args[0])),
+      toArray(vue.unref(firstParamTargets.value ? args[2] : args[1])),
+      vue.toValue(firstParamTargets.value ? args[3] : args[2])
+    ];
+  }, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+    if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+    const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+    const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+    onCleanup(() => {
+      cleanups.forEach((fn) => fn());
+    });
+  }, { flush: "post" });
+}
+function onClickOutside(target, handler, options = {}) {
+  const { window: window$1 = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
+  if (!window$1) return controls ? {
+    stop: noop,
+    cancel: noop,
+    trigger: noop
+  } : noop;
+  let shouldListen = true;
+  const shouldIgnore = (event) => {
+    return vue.toValue(ignore).some((target$1) => {
+      if (typeof target$1 === "string") return Array.from(window$1.document.querySelectorAll(target$1)).some((el) => el === event.target || event.composedPath().includes(el));
+      else {
+        const el = unrefElement(target$1);
+        return el && (event.target === el || event.composedPath().includes(el));
+      }
+    });
+  };
+  function hasMultipleRoots(target$1) {
+    const vm = vue.toValue(target$1);
+    return vm && vm.$.subTree.shapeFlag === 16;
+  }
+  function checkMultipleRoots(target$1, event) {
+    const vm = vue.toValue(target$1);
+    const children = vm.$.subTree && vm.$.subTree.children;
+    if (children == null || !Array.isArray(children)) return false;
+    return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+  }
+  const listener = (event) => {
+    const el = unrefElement(target);
+    if (event.target == null) return;
+    if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) return;
+    if (!el || el === event.target || event.composedPath().includes(el)) return;
+    if ("detail" in event && event.detail === 0) shouldListen = !shouldIgnore(event);
+    if (!shouldListen) {
+      shouldListen = true;
+      return;
+    }
+    handler(event);
+  };
+  let isProcessingClick = false;
+  const cleanup = [
+    useEventListener(window$1, "click", (event) => {
+      if (!isProcessingClick) {
+        isProcessingClick = true;
+        setTimeout(() => {
+          isProcessingClick = false;
+        }, 0);
+        listener(event);
+      }
+    }, {
+      passive: true,
+      capture
+    }),
+    useEventListener(window$1, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+    }, { passive: true }),
+    detectIframe && useEventListener(window$1, "blur", (event) => {
+      setTimeout(() => {
+        var _window$document$acti;
+        const el = unrefElement(target);
+        if (((_window$document$acti = window$1.document.activeElement) === null || _window$document$acti === void 0 ? void 0 : _window$document$acti.tagName) === "IFRAME" && !(el === null || el === void 0 ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+      }, 0);
+    }, { passive: true })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  if (controls) return {
+    stop,
+    cancel: () => {
+      shouldListen = false;
+    },
+    trigger: (event) => {
+      shouldListen = true;
+      listener(event);
+      shouldListen = false;
+    }
+  };
+  return stop;
+}
+// @__NO_SIDE_EFFECTS__
+function useMounted() {
+  const isMounted = vue.shallowRef(false);
+  const instance = vue.getCurrentInstance();
+  if (instance) vue.onMounted(() => {
+    isMounted.value = true;
+  }, instance);
+  return isMounted;
+}
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = /* @__PURE__ */ useMounted();
+  return vue.computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+const ssrWidthSymbol = Symbol("vueuse-ssr-width");
+// @__NO_SIDE_EFFECTS__
+function useSSRWidth() {
+  const ssrWidth = vue.hasInjectionContext() ? /* @__PURE__ */ injectLocal(ssrWidthSymbol, null) : null;
+  return typeof ssrWidth === "number" ? ssrWidth : void 0;
+}
+function useMediaQuery(query, options = {}) {
+  const { window: window$1 = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+  const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "matchMedia" in window$1 && typeof window$1.matchMedia === "function");
+  const ssrSupport = vue.shallowRef(typeof ssrWidth === "number");
+  const mediaQuery = vue.shallowRef();
+  const matches = vue.shallowRef(false);
+  const handler = (event) => {
+    matches.value = event.matches;
+  };
+  vue.watchEffect(() => {
+    if (ssrSupport.value) {
+      ssrSupport.value = !isSupported.value;
+      matches.value = vue.toValue(query).split(",").some((queryString) => {
+        const not = queryString.includes("not all");
+        const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        let res = Boolean(minWidth || maxWidth);
+        if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
+        if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
+        return not ? !res : res;
+      });
+      return;
+    }
+    if (!isSupported.value) return;
+    mediaQuery.value = window$1.matchMedia(vue.toValue(query));
+    matches.value = mediaQuery.value.matches;
+  });
+  useEventListener(mediaQuery, "change", handler, { passive: true });
+  return vue.computed(() => matches.value);
+}
+// @__NO_SIDE_EFFECTS__
+function useBreakpoints(breakpoints, options = {}) {
+  function getValue$1(k, delta) {
+    let v = vue.toValue(breakpoints[vue.toValue(k)]);
+    if (delta != null) v = increaseWithUnit(v, delta);
+    if (typeof v === "number") v = `${v}px`;
+    return v;
+  }
+  const { window: window$1 = defaultWindow, strategy = "min-width", ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+  const ssrSupport = typeof ssrWidth === "number";
+  const mounted = ssrSupport ? vue.shallowRef(false) : { value: true };
+  if (ssrSupport) tryOnMounted(() => mounted.value = !!window$1);
+  function match(query, size) {
+    if (!mounted.value && ssrSupport) return query === "min" ? ssrWidth >= pxValue(size) : ssrWidth <= pxValue(size);
+    if (!window$1) return false;
+    return window$1.matchMedia(`(${query}-width: ${size})`).matches;
+  }
+  const greaterOrEqual = (k) => {
+    return useMediaQuery(() => `(min-width: ${getValue$1(k)})`, options);
+  };
+  const smallerOrEqual = (k) => {
+    return useMediaQuery(() => `(max-width: ${getValue$1(k)})`, options);
+  };
+  const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {
+    Object.defineProperty(shortcuts, k, {
+      get: () => strategy === "min-width" ? greaterOrEqual(k) : smallerOrEqual(k),
+      enumerable: true,
+      configurable: true
+    });
+    return shortcuts;
+  }, {});
+  function current() {
+    const points = Object.keys(breakpoints).map((k) => [
+      k,
+      shortcutMethods[k],
+      pxValue(getValue$1(k))
+    ]).sort((a, b) => a[2] - b[2]);
+    return vue.computed(() => points.filter(([, v]) => v.value).map(([k]) => k));
+  }
+  return Object.assign(shortcutMethods, {
+    greaterOrEqual,
+    smallerOrEqual,
+    greater(k) {
+      return useMediaQuery(() => `(min-width: ${getValue$1(k, 0.1)})`, options);
+    },
+    smaller(k) {
+      return useMediaQuery(() => `(max-width: ${getValue$1(k, -0.1)})`, options);
+    },
+    between(a, b) {
+      return useMediaQuery(() => `(min-width: ${getValue$1(a)}) and (max-width: ${getValue$1(b, -0.1)})`, options);
+    },
+    isGreater(k) {
+      return match("min", getValue$1(k, 0.1));
+    },
+    isGreaterOrEqual(k) {
+      return match("min", getValue$1(k));
+    },
+    isSmaller(k) {
+      return match("max", getValue$1(k, -0.1));
+    },
+    isSmallerOrEqual(k) {
+      return match("max", getValue$1(k));
+    },
+    isInBetween(a, b) {
+      return match("min", getValue$1(a)) && match("max", getValue$1(b, -0.1));
+    },
+    current,
+    active() {
+      const bps = current();
+      return vue.computed(() => bps.value.length === 0 ? "" : bps.value.at(strategy === "min-width" ? -1 : 0));
+    }
+  });
+}
+exports._sfc_main = _sfc_main;
+exports.onClickOutside = onClickOutside;
+exports.useBreakpoints = useBreakpoints;
+exports.useDebounceFn = useDebounceFn;
+//# sourceMappingURL=index-D1x3TH9k.cjs.map