uniapp-dyckui 4.1.1

package/dist/index.cjs.js

@@ -0,0 +1,1380 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const _withScopeId$4 = (n) => (vue.pushScopeId("data-v-02c23a30"), n = n(), vue.popScopeId(), n);
+const _hoisted_1$a = ["disabled"];
+const _hoisted_2$9 = {
+  key: 0,
+  class: "sw-button__loading"
+};
+const _hoisted_3$9 = /* @__PURE__ */ _withScopeId$4(() => /* @__PURE__ */ vue.createElementVNode("text", { class: "loading-spinner" }, null, -1));
+const _hoisted_4$7 = [
+  _hoisted_3$9
+];
+const _hoisted_5$5 = {
+  key: 0,
+  class: "sw-button__icon"
+};
+const _hoisted_6$5 = {
+  key: 2,
+  class: "sw-button__text"
+};
+const _sfc_main$a = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    type: { default: "primary" },
+    size: { default: "normal" },
+    shape: { default: "default" },
+    disabled: { type: Boolean, default: false },
+    loading: { type: Boolean, default: false },
+    block: { type: Boolean, default: false },
+    round: { type: Boolean, default: false },
+    plain: { type: Boolean, default: false },
+    outline: { type: Boolean, default: false },
+    link: { type: Boolean, default: false },
+    icon: { default: "" },
+    customClass: { default: "" },
+    customStyle: { default: () => ({}) }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    function handleClick(event) {
+      if (!props.disabled && !props.loading) {
+        emit("click", event);
+      }
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("view", {
+        class: vue.normalizeClass(["sw-button", [
+          `sw-button--${_ctx.type}`,
+          `sw-button--${_ctx.size}`,
+          `sw-button--${_ctx.shape}`,
+          { "is-disabled": _ctx.disabled },
+          { "is-loading": _ctx.loading },
+          { "is-block": _ctx.block },
+          { "is-round": _ctx.round },
+          { "is-plain": _ctx.plain },
+          { "is-outline": _ctx.outline },
+          { "is-link": _ctx.link }
+        ]]),
+        disabled: _ctx.disabled || _ctx.loading,
+        onClick: handleClick
+      }, [
+        _ctx.loading ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_2$9, _hoisted_4$7)) : vue.createCommentVNode("", true),
+        !_ctx.loading ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+          _ctx.$slots.icon ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_5$5, [
+            vue.renderSlot(_ctx.$slots, "icon", {}, void 0, true)
+          ])) : vue.createCommentVNode("", true),
+          _ctx.icon ? (vue.openBlock(), vue.createElementBlock("text", {
+            key: 1,
+            class: vue.normalizeClass(["sw-button__icon", [_ctx.icon]])
+          }, null, 2)) : vue.createCommentVNode("", true)
+        ], 64)) : vue.createCommentVNode("", true),
+        _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_6$5, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])) : vue.createCommentVNode("", true)
+      ], 10, _hoisted_1$a);
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const index$7 = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["__scopeId", "data-v-02c23a30"]]);
+const _withScopeId$3 = (n) => (vue.pushScopeId("data-v-a2785685"), n = n(), vue.popScopeId(), n);
+const _hoisted_1$9 = { class: "dialog-content" };
+const _hoisted_2$8 = { class: "dialog-icon" };
+const _hoisted_3$8 = ["src"];
+const _hoisted_4$6 = {
+  key: 1,
+  class: "default-icon"
+};
+const _hoisted_5$4 = { class: "dialog-title" };
+const _hoisted_6$4 = { class: "dialog-description" };
+const _hoisted_7$4 = /* @__PURE__ */ _withScopeId$3(() => /* @__PURE__ */ vue.createElementVNode("view", { class: "dialog-divider" }, null, -1));
+const _hoisted_8$4 = { class: "dialog-buttons" };
+const _sfc_main$9 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    type: { default: "confirm" },
+    title: { default: "" },
+    description: { default: "" },
+    icon: { default: "" },
+    mask: { type: Boolean, default: true },
+    maskOpacity: { default: 0.5 },
+    closeOnMaskClick: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "confirm", "cancel"],
+  setup(__props, { emit: __emit }) {
+    vue.useCssVars((_ctx) => ({
+      "1f434a4e": _ctx.maskOpacity
+    }));
+    const props = __props;
+    const emit = __emit;
+    const showDialog = vue.ref(props.modelValue);
+    vue.watch(() => props.modelValue, (newVal) => {
+      showDialog.value = newVal;
+    });
+    vue.watch(() => showDialog.value, (newVal) => {
+      emit("update:modelValue", newVal);
+    });
+    function handleMaskClick() {
+      if (props.closeOnMaskClick) {
+        showDialog.value = false;
+      }
+    }
+    function handleConfirm() {
+      emit("confirm");
+      showDialog.value = false;
+    }
+    function handleCancel() {
+      emit("cancel");
+      showDialog.value = false;
+    }
+    return (_ctx, _cache) => {
+      return showDialog.value ? (vue.openBlock(), vue.createElementBlock("view", {
+        key: 0,
+        class: "dialog-wrapper",
+        onClick: handleMaskClick
+      }, [
+        vue.createElementVNode("view", {
+          class: "dialog-container",
+          onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+          }, ["stop"]))
+        }, [
+          vue.createElementVNode("view", _hoisted_1$9, [
+            vue.createElementVNode("view", _hoisted_2$8, [
+              _ctx.icon ? (vue.openBlock(), vue.createElementBlock("image", {
+                key: 0,
+                src: _ctx.icon,
+                alt: "dialog-icon"
+              }, null, 8, _hoisted_3$8)) : (vue.openBlock(), vue.createElementBlock("view", _hoisted_4$6))
+            ]),
+            vue.createElementVNode("text", _hoisted_5$4, vue.toDisplayString(_ctx.title), 1),
+            vue.createElementVNode("text", _hoisted_6$4, vue.toDisplayString(_ctx.description), 1)
+          ]),
+          _hoisted_7$4,
+          vue.createElementVNode("view", _hoisted_8$4, [
+            _ctx.type === "open-app" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+              vue.createElementVNode("view", {
+                class: "dialog-button dialog-button-cancel",
+                onClick: handleCancel
+              }, " 取消 "),
+              vue.createElementVNode("view", {
+                class: "dialog-button dialog-button-primary",
+                onClick: handleConfirm
+              }, " 打开app ")
+            ], 64)) : _ctx.type === "confirm" ? (vue.openBlock(), vue.createElementBlock("view", {
+              key: 1,
+              class: "dialog-button dialog-button-full dialog-button-primary",
+              onClick: handleConfirm
+            }, " 知道了 ")) : _ctx.type === "continue" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+              vue.createElementVNode("view", {
+                class: "dialog-button dialog-button-cancel",
+                onClick: handleCancel
+              }, " 取消 "),
+              vue.createElementVNode("view", {
+                class: "dialog-button dialog-button-primary",
+                onClick: handleConfirm
+              }, " 继续访问 ")
+            ], 64)) : vue.createCommentVNode("", true)
+          ])
+        ])
+      ])) : vue.createCommentVNode("", true);
+    };
+  }
+});
+const index$6 = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__scopeId", "data-v-a2785685"]]);
+const _hoisted_1$8 = {
+  key: 0,
+  class: "sw-divider__text"
+};
+const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    vertical: { type: Boolean, default: false },
+    dashed: { type: Boolean, default: false },
+    position: { default: "center" },
+    customClass: { default: "" },
+    customStyle: { default: () => ({}) }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("view", {
+        class: vue.normalizeClass(["sw-divider", [
+          { "is-vertical": _ctx.vertical },
+          { "is-dashed": _ctx.dashed },
+          { [`sw-divider--${_ctx.position}`]: _ctx.position !== "center" }
+        ]])
+      }, [
+        _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_1$8, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ])) : vue.createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const index$5 = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__scopeId", "data-v-b668cd0b"]]);
+const _withScopeId$2 = (n) => (vue.pushScopeId("data-v-00bcefd1"), n = n(), vue.popScopeId(), n);
+const _hoisted_1$7 = {
+  key: 0,
+  class: "popup-header"
+};
+const _hoisted_2$7 = {
+  key: 1,
+  class: "popup-header"
+};
+const _hoisted_3$7 = { class: "popup-title" };
+const _hoisted_4$5 = { class: "popup-content" };
+const _hoisted_5$3 = {
+  key: 2,
+  class: "popup-footer"
+};
+const _hoisted_6$3 = {
+  key: 3,
+  class: "popup-footer"
+};
+const _hoisted_7$3 = /* @__PURE__ */ _withScopeId$2(() => /* @__PURE__ */ vue.createElementVNode("text", { class: "close-icon" }, "×", -1));
+const _hoisted_8$3 = [
+  _hoisted_7$3
+];
+const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    title: { default: "" },
+    position: { default: "center" },
+    animation: { default: "slide" },
+    mask: { type: Boolean, default: true },
+    maskOpacity: { default: 0.5 },
+    closeOnMaskClick: { type: Boolean, default: true },
+    showCloseButton: { type: Boolean, default: true },
+    closeOnEsc: { type: Boolean, default: true },
+    showConfirmButton: { type: Boolean, default: false },
+    confirmText: { default: "确定" },
+    showCancelButton: { type: Boolean, default: false },
+    cancelText: { default: "取消" },
+    width: { default: "50%" },
+    height: { default: "100%" },
+    maxWidth: { default: "500px" },
+    lockScroll: { type: Boolean, default: true }
+  },
+  emits: ["update:modelValue", "open", "close", "maskClick", "confirm", "cancel", "closeButtonClick"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const popupRef = vue.ref(null);
+    const showPopup = vue.ref(props.modelValue);
+    const isClosing = vue.ref(false);
+    const lastScrollY = vue.ref(0);
+    vue.watch(() => props.modelValue, (newVal) => {
+      showPopup.value = newVal;
+      if (newVal) {
+        onOpen();
+      } else {
+        onClose();
+      }
+    });
+    vue.watch(() => showPopup.value, (newVal) => {
+      emit("update:modelValue", newVal);
+      if (newVal) {
+        onOpen();
+      } else {
+        onClose();
+      }
+    });
+    function onOpen() {
+      if (props.lockScroll) {
+        lockScroll();
+      }
+      if (props.closeOnEsc) {
+        window.addEventListener("keydown", handleKeyDown);
+      }
+      emit("open");
+    }
+    function onClose() {
+      if (props.lockScroll) {
+        unlockScroll();
+      }
+      window.removeEventListener("keydown", handleKeyDown);
+      emit("close");
+    }
+    function lockScroll() {
+      lastScrollY.value = window.scrollY;
+      document.body.style.position = "fixed";
+      document.body.style.top = `-${lastScrollY.value}px`;
+      document.body.style.left = "0";
+      document.body.style.right = "0";
+      document.body.style.overflow = "hidden";
+      uni.hideTabBar();
+    }
+    function unlockScroll() {
+      document.body.style.position = "";
+      document.body.style.top = "";
+      document.body.style.left = "";
+      document.body.style.right = "";
+      document.body.style.overflow = "";
+      window.scrollTo(0, lastScrollY.value);
+      uni.showTabBar();
+    }
+    function handleKeyDown(e) {
+      if (e.key === "Escape" && props.closeOnEsc && showPopup.value) {
+        handleClose();
+      }
+    }
+    function handleMaskClick() {
+      if (props.closeOnMaskClick) {
+        handleClose();
+      }
+      emit("maskClick");
+    }
+    function handleClose() {
+      isClosing.value = true;
+      emit("closeButtonClick");
+    }
+    function handleAnimationEnd() {
+      if (isClosing.value) {
+        isClosing.value = false;
+        showPopup.value = false;
+      }
+    }
+    function handleConfirm() {
+      emit("confirm");
+    }
+    function handleCancel() {
+      emit("cancel");
+      handleClose();
+    }
+    vue.onMounted(() => {
+      if (showPopup.value) {
+        onOpen();
+      }
+    });
+    vue.onUnmounted(() => {
+      if (showPopup.value) {
+        onClose();
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("view", {
+        class: vue.normalizeClass(["popup-wrapper", {
+          "modal": _ctx.mask,
+          "non-modal": !_ctx.mask,
+          "closing": isClosing.value
+        }]),
+        onClick: vue.withModifiers(handleMaskClick, ["self"])
+      }, [
+        _ctx.mask ? (vue.openBlock(), vue.createElementBlock("view", {
+          key: 0,
+          class: "popup-mask",
+          style: vue.normalizeStyle({ opacity: _ctx.maskOpacity }),
+          onClick: handleMaskClick
+        }, null, 4)) : vue.createCommentVNode("", true),
+        vue.createElementVNode("view", {
+          ref_key: "popupRef",
+          ref: popupRef,
+          class: vue.normalizeClass(["popup-container", [
+            `position-${_ctx.position}`,
+            `animation-${_ctx.animation}`,
+            { closing: isClosing.value }
+          ]]),
+          onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+          }, ["stop"])),
+          onTouchmove: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+          }, ["stop"])),
+          onAnimationend: handleAnimationEnd
+        }, [
+          _ctx.$slots.header ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_1$7, [
+            vue.renderSlot(_ctx.$slots, "header", {}, void 0, true)
+          ])) : _ctx.title ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_2$7, [
+            vue.createElementVNode("text", _hoisted_3$7, vue.toDisplayString(_ctx.title), 1)
+          ])) : vue.createCommentVNode("", true),
+          vue.createElementVNode("view", _hoisted_4$5, [
+            vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+          ]),
+          _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_5$3, [
+            vue.renderSlot(_ctx.$slots, "footer", {}, void 0, true)
+          ])) : _ctx.showConfirmButton || _ctx.showCancelButton ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_6$3, [
+            _ctx.showCancelButton ? (vue.openBlock(), vue.createElementBlock("view", {
+              key: 0,
+              class: "popup-button popup-button-cancel",
+              onClick: handleCancel
+            }, vue.toDisplayString(_ctx.cancelText), 1)) : vue.createCommentVNode("", true),
+            _ctx.showConfirmButton ? (vue.openBlock(), vue.createElementBlock("view", {
+              key: 1,
+              class: "popup-button popup-button-confirm",
+              onClick: handleConfirm
+            }, vue.toDisplayString(_ctx.confirmText), 1)) : vue.createCommentVNode("", true)
+          ])) : vue.createCommentVNode("", true),
+          _ctx.showCloseButton ? (vue.openBlock(), vue.createElementBlock("view", {
+            key: 4,
+            class: "popup-close-button",
+            onClick: handleClose
+          }, _hoisted_8$3)) : vue.createCommentVNode("", true)
+        ], 34)
+      ], 2)), [
+        [vue.vShow, showPopup.value]
+      ]);
+    };
+  }
+});
+const index$4 = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__scopeId", "data-v-00bcefd1"]]);
+const _hoisted_1$6 = {
+  key: 0,
+  class: "sw-toast__loading"
+};
+const _hoisted_2$6 = {
+  key: 0,
+  class: "sw-toast__spinner"
+};
+const _hoisted_3$6 = {
+  key: 1,
+  class: "sw-toast__custom-icon"
+};
+const _hoisted_4$4 = {
+  key: 1,
+  class: "sw-toast__icon"
+};
+const _hoisted_5$2 = {
+  key: 0,
+  class: "sw-toast__icon--success"
+};
+const _hoisted_6$2 = {
+  key: 1,
+  class: "sw-toast__icon--fail"
+};
+const _hoisted_7$2 = {
+  key: 2,
+  class: "sw-toast__custom-icon"
+};
+const _hoisted_8$2 = {
+  key: 2,
+  class: "sw-toast__text"
+};
+const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    type: { default: "text" },
+    position: { default: "middle" },
+    message: { default: "" },
+    duration: { default: 3e3 },
+    loading: { type: Boolean, default: false },
+    icon: { type: Boolean, default: true },
+    customIcon: { default: "" },
+    large: { type: Boolean, default: false },
+    customStyle: { default: () => ({}) }
+  },
+  emits: ["update:modelValue", "close", "click"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const toastRef = vue.ref(null);
+    let timer = null;
+    const showToast = vue.ref(props.modelValue);
+    const isClosing = vue.ref(false);
+    const showIcon = vue.computed(() => {
+      if (props.loading)
+        return true;
+      if (props.type === "text")
+        return props.icon;
+      return true;
+    });
+    function onClick() {
+      emit("click");
+    }
+    function close() {
+      if (!showToast.value)
+        return;
+      isClosing.value = true;
+      emit("close");
+    }
+    function startTimer() {
+      clearTimer();
+      if (props.duration > 0 && !props.loading) {
+        timer = setTimeout(() => {
+          close();
+        }, props.duration);
+      }
+    }
+    function clearTimer() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+    function handleTransitionEnd() {
+      if (isClosing.value) {
+        showToast.value = false;
+        isClosing.value = false;
+        emit("update:modelValue", false);
+      }
+    }
+    vue.watch(() => props.modelValue, (newVal) => {
+      if (newVal) {
+        showToast.value = true;
+        isClosing.value = false;
+        startTimer();
+      } else {
+        close();
+      }
+    });
+    vue.watch(() => props.message, () => {
+      if (showToast.value && !props.loading) {
+        startTimer();
+      }
+    });
+    vue.onMounted(() => {
+      if (props.modelValue) {
+        startTimer();
+      }
+    });
+    vue.onUnmounted(() => {
+      clearTimer();
+    });
+    __expose({
+      /**
+       * 手动关闭Toast
+       */
+      close
+    });
+    return (_ctx, _cache) => {
+      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("view", {
+        ref_key: "toastRef",
+        ref: toastRef,
+        class: vue.normalizeClass(["sw-toast", [
+          `sw-toast--${_ctx.type}`,
+          `sw-toast--${_ctx.position}`,
+          { "sw-toast--large": _ctx.large },
+          { "sw-toast--text": !showIcon.value && _ctx.type === "text" },
+          { "sw-toast--show": showToast.value && !isClosing.value },
+          { "sw-toast--hide": showToast.value && isClosing.value }
+        ]]),
+        style: vue.normalizeStyle(_ctx.customStyle),
+        onClick,
+        onTransitionend: handleTransitionEnd
+      }, [
+        _ctx.loading ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_1$6, [
+          !_ctx.customIcon ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_2$6)) : (vue.openBlock(), vue.createElementBlock("text", _hoisted_3$6, vue.toDisplayString(_ctx.customIcon), 1))
+        ])) : showIcon.value ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_4$4, [
+          _ctx.type === "success" ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_5$2, "✓")) : _ctx.type === "fail" ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_6$2, "✗")) : _ctx.customIcon ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_7$2, vue.toDisplayString(_ctx.customIcon), 1)) : vue.createCommentVNode("", true)
+        ])) : vue.createCommentVNode("", true),
+        _ctx.message ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_8$2, vue.toDisplayString(_ctx.message), 1)) : vue.createCommentVNode("", true)
+      ], 38)), [
+        [vue.vShow, showToast.value]
+      ]);
+    };
+  }
+});
+const index$3 = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__scopeId", "data-v-2b648fd9"]]);
+const _hoisted_1$5 = { class: "sw-swiper" };
+const _hoisted_2$5 = {
+  key: 0,
+  class: "swiper-indicators"
+};
+const _hoisted_3$5 = ["onClick"];
+const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    items: {},
+    initialIndex: { default: 0 },
+    autoPlay: { type: Boolean, default: true },
+    interval: { default: 3e3 },
+    duration: { default: 300 },
+    showIndicators: { type: Boolean, default: true },
+    showArrows: { type: Boolean, default: false },
+    loop: { type: Boolean, default: true }
+  },
+  emits: ["change", "prev", "next"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const currentIndex = vue.ref(props.initialIndex);
+    let timer = null;
+    function startAutoPlay() {
+      if (props.autoPlay && props.items.length > 1) {
+        timer = setInterval(() => {
+          next();
+        }, props.interval);
+      }
+    }
+    function stopAutoPlay() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+    function prev() {
+      if (props.loop) {
+        currentIndex.value = currentIndex.value === 0 ? props.items.length - 1 : currentIndex.value - 1;
+      } else if (currentIndex.value > 0) {
+        currentIndex.value--;
+      }
+      emit("prev", currentIndex.value);
+      emit("change", currentIndex.value);
+    }
+    function next() {
+      if (props.loop) {
+        currentIndex.value = currentIndex.value === props.items.length - 1 ? 0 : currentIndex.value + 1;
+      } else if (currentIndex.value < props.items.length - 1) {
+        currentIndex.value++;
+      }
+      emit("next", currentIndex.value);
+      emit("change", currentIndex.value);
+    }
+    vue.watch(() => props.items, (newItems) => {
+      if (newItems.length < currentIndex.value + 1) {
+        currentIndex.value = Math.min(currentIndex.value, newItems.length - 1);
+      }
+      stopAutoPlay();
+      startAutoPlay();
+    }, { deep: true });
+    vue.watch(() => props.autoPlay, (autoPlay) => {
+      if (autoPlay) {
+        startAutoPlay();
+      } else {
+        stopAutoPlay();
+      }
+    });
+    vue.onMounted(() => {
+      startAutoPlay();
+    });
+    vue.onUnmounted(() => {
+      stopAutoPlay();
+    });
+    __expose({
+      prev,
+      next,
+      currentIndex
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("view", _hoisted_1$5, [
+        vue.createElementVNode("view", {
+          class: "swiper-wrapper",
+          style: vue.normalizeStyle({
+            transform: `translateX(-${currentIndex.value * 100}%)`,
+            transition: `transform ${_ctx.duration}ms ease`
+          })
+        }, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index2) => {
+            return vue.openBlock(), vue.createElementBlock("view", {
+              key: index2,
+              class: "swiper-item"
+            }, [
+              vue.renderSlot(_ctx.$slots, "default", {
+                item,
+                index: index2
+              }, void 0, true)
+            ]);
+          }), 128))
+        ], 4),
+        _ctx.showIndicators ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_2$5, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.items, (item, index2) => {
+            return vue.openBlock(), vue.createElementBlock("view", {
+              key: index2,
+              class: vue.normalizeClass(["indicator-item", { active: index2 === currentIndex.value }]),
+              onClick: ($event) => currentIndex.value = index2
+            }, null, 10, _hoisted_3$5);
+          }), 128))
+        ])) : vue.createCommentVNode("", true),
+        _ctx.showArrows ? (vue.openBlock(), vue.createElementBlock("view", {
+          key: 1,
+          class: "swiper-arrow swiper-arrow-left",
+          onClick: prev
+        })) : vue.createCommentVNode("", true),
+        _ctx.showArrows ? (vue.openBlock(), vue.createElementBlock("view", {
+          key: 2,
+          class: "swiper-arrow swiper-arrow-right",
+          onClick: next
+        })) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const index$2 = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__scopeId", "data-v-3735cbbd"]]);
+const _withScopeId$1 = (n) => (vue.pushScopeId("data-v-2e49050a"), n = n(), vue.popScopeId(), n);
+const _hoisted_1$4 = { class: "sw-infinite-scroll__content" };
+const _hoisted_2$4 = {
+  key: 0,
+  class: "sw-infinite-scroll__loading"
+};
+const _hoisted_3$4 = /* @__PURE__ */ _withScopeId$1(() => /* @__PURE__ */ vue.createElementVNode("view", { class: "loading-spinner" }, null, -1));
+const _hoisted_4$3 = {
+  key: 1,
+  class: "sw-infinite-scroll__finished"
+};
+const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    loading: { type: Boolean, default: false },
+    finished: { type: Boolean, default: false },
+    offset: { default: 100 },
+    loadingText: { default: "加载中..." },
+    finishedText: { default: "没有更多了" },
+    disabled: { type: Boolean, default: false },
+    height: { default: "auto" }
+  },
+  emits: ["load"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const scrollContainer = vue.ref(null);
+    const containerStyle = vue.computed(() => {
+      return {
+        height: typeof props.height === "number" ? `${props.height}px` : props.height
+      };
+    });
+    function handleScroll() {
+      if (!scrollContainer.value || props.loading || props.finished || props.disabled) {
+        return;
+      }
+      const { scrollTop, scrollHeight, clientHeight } = scrollContainer.value;
+      if (scrollHeight - scrollTop - clientHeight <= props.offset) {
+        emit("load");
+      }
+    }
+    let resizeTimeout = null;
+    function handleResize() {
+      if (resizeTimeout) {
+        clearTimeout(resizeTimeout);
+      }
+      resizeTimeout = setTimeout(() => {
+        handleScroll();
+      }, 100);
+    }
+    vue.onMounted(() => {
+      handleScroll();
+      window.addEventListener("resize", handleResize);
+    });
+    vue.onUnmounted(() => {
+      window.removeEventListener("resize", handleResize);
+      if (resizeTimeout) {
+        clearTimeout(resizeTimeout);
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("view", {
+        ref_key: "scrollContainer",
+        ref: scrollContainer,
+        class: "sw-infinite-scroll",
+        style: vue.normalizeStyle(containerStyle.value),
+        onScroll: handleScroll
+      }, [
+        vue.createElementVNode("view", _hoisted_1$4, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _ctx.loading ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_2$4, [
+          _hoisted_3$4,
+          vue.createElementVNode("text", null, vue.toDisplayString(_ctx.loadingText), 1)
+        ])) : vue.createCommentVNode("", true),
+        _ctx.finished && !_ctx.loading ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_4$3, vue.toDisplayString(_ctx.finishedText), 1)) : vue.createCommentVNode("", true)
+      ], 36);
+    };
+  }
+});
+const index$1 = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__scopeId", "data-v-2e49050a"]]);
+const _withScopeId = (n) => (vue.pushScopeId("data-v-d2876eca"), n = n(), vue.popScopeId(), n);
+const _hoisted_1$3 = {
+  key: 0,
+  class: "refresh-content"
+};
+const _hoisted_2$3 = { class: "refresh-icon" };
+const _hoisted_3$3 = {
+  key: 0,
+  class: "refresh-loading"
+};
+const _hoisted_4$2 = {
+  key: 1,
+  class: "refresh-arrow"
+};
+const _hoisted_5$1 = { class: "refresh-text" };
+const _hoisted_6$1 = { class: "infinite-scroll-content" };
+const _hoisted_7$1 = { class: "infinite-scroll-indicator" };
+const _hoisted_8$1 = {
+  key: 0,
+  class: "infinite-scroll-loading"
+};
+const _hoisted_9 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("view", { class: "loading-spinner" }, [
+  /* @__PURE__ */ vue.createElementVNode("text", { class: "loading-icon" }, "●")
+], -1));
+const _hoisted_10 = { class: "loading-text" };
+const _hoisted_11 = {
+  key: 1,
+  class: "infinite-scroll-error"
+};
+const _hoisted_12 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("text", { class: "error-icon" }, "×", -1));
+const _hoisted_13 = { class: "error-text" };
+const _hoisted_14 = {
+  key: 2,
+  class: "infinite-scroll-no-more"
+};
+const _hoisted_15 = { class: "no-more-text" };
+const _hoisted_16 = {
+  key: 3,
+  class: "infinite-scroll-trigger",
+  style: { height: `0px` }
+};
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    loading: { type: Boolean, default: false },
+    refreshLoading: { type: Boolean, default: false },
+    hasMore: { type: Boolean, default: true },
+    error: { type: Boolean, default: false },
+    threshold: { default: 30 },
+    refreshThreshold: { default: 40 },
+    throttleTime: { default: 200 },
+    loadingText: { default: "加载中..." },
+    errorText: { default: "加载失败" },
+    retryText: { default: "点击重试" },
+    noMoreText: { default: "没有更多数据了" },
+    refreshText: { default: "下拉刷新" },
+    releaseText: { default: "释放可刷新" },
+    refreshingText: { default: "正在刷新..." },
+    refreshSuccessText: { default: "刷新成功" },
+    refreshErrorText: { default: "刷新失败" },
+    useWindowScroll: { type: Boolean, default: false },
+    enableInfiniteScroll: { type: Boolean, default: false },
+    enableRefresh: { type: Boolean, default: true }
+  },
+  emits: ["loadMore", "retry", "refresh"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const containerRef = vue.ref(null);
+    let scrollContainer = null;
+    let lastScrollTime = 0;
+    const pullDistance = vue.ref(0);
+    const startY = vue.ref(0);
+    const isPulling = vue.ref(false);
+    const isRefreshing = vue.ref(false);
+    const refreshStatus = vue.ref("normal");
+    function getScrollContainer() {
+      if (props.useWindowScroll) {
+        return window;
+      }
+      return containerRef.value;
+    }
+    function throttle(fn, delay) {
+      return (...args) => {
+        const now = Date.now();
+        if (now - lastScrollTime >= delay) {
+          lastScrollTime = now;
+          fn.apply(null, args);
+        }
+      };
+    }
+    function checkLoadMore() {
+      if (!props.enableInfiniteScroll) {
+        return;
+      }
+      if (props.loading || !props.hasMore || props.error) {
+        return;
+      }
+      let scrollTop = 0;
+      let scrollHeight = 0;
+      let clientHeight = 0;
+      if (props.useWindowScroll) {
+        scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop;
+        scrollHeight = document.documentElement.scrollHeight || document.body.scrollHeight;
+        clientHeight = window.innerHeight;
+      } else {
+        if (!containerRef.value)
+          return;
+        if (typeof containerRef.value.scrollTop !== "number" || typeof containerRef.value.scrollHeight !== "number" || typeof containerRef.value.clientHeight !== "number") {
+          return;
+        }
+        scrollTop = containerRef.value.scrollTop;
+        scrollHeight = containerRef.value.scrollHeight;
+        clientHeight = containerRef.value.clientHeight;
+      }
+      if ((props.useWindowScroll ? scrollTop > 0 : true) && (scrollHeight <= clientHeight || scrollHeight - scrollTop - clientHeight <= props.threshold)) {
+        emit("loadMore");
+      }
+    }
+    function onRetry() {
+      emit("retry");
+    }
+    function handleTouchStart(e) {
+      var _a;
+      if (!props.enableRefresh || props.refreshLoading) {
+        return;
+      }
+      let scrollTop = 0;
+      if (props.useWindowScroll) {
+        scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop;
+      } else {
+        scrollTop = ((_a = containerRef.value) == null ? void 0 : _a.scrollTop) || 0;
+      }
+      if (scrollTop > 0) {
+        return;
+      }
+      startY.value = e.touches[0].clientY;
+      isPulling.value = true;
+      refreshStatus.value = "pulling";
+    }
+    function handleTouchMove(e) {
+      if (!isPulling.value || props.refreshLoading) {
+        return;
+      }
+      const currentY = e.touches[0].clientY;
+      const distance = currentY - startY.value;
+      if (distance <= 0) {
+        if (pullDistance.value > 0) {
+          pullDistance.value = 0;
+          refreshStatus.value = "normal";
+        }
+        return;
+      }
+      pullDistance.value = Math.min(distance * 0.5, props.refreshThreshold * 1.5);
+      if (pullDistance.value >= props.refreshThreshold) {
+        refreshStatus.value = "triggered";
+      } else {
+        refreshStatus.value = "pulling";
+      }
+      e.preventDefault();
+    }
+    function handleTouchEnd() {
+      if (!isPulling.value) {
+        return;
+      }
+      isPulling.value = false;
+      if (pullDistance.value >= props.refreshThreshold && !props.refreshLoading) {
+        isRefreshing.value = true;
+        refreshStatus.value = "refreshing";
+        emit("refresh");
+      } else {
+        pullDistance.value = 0;
+        refreshStatus.value = "normal";
+      }
+    }
+    const handleScroll = throttle(() => {
+      checkLoadMore();
+    }, props.throttleTime);
+    function addScrollListener() {
+      vue.nextTick(() => {
+        scrollContainer = getScrollContainer();
+        if (scrollContainer && typeof scrollContainer.addEventListener === "function") {
+          scrollContainer.addEventListener("scroll", handleScroll, { passive: true });
+          checkLoadMore();
+        }
+      });
+    }
+    function removeScrollListener() {
+      if (scrollContainer && typeof scrollContainer.removeEventListener === "function") {
+        scrollContainer.removeEventListener("scroll", handleScroll);
+        scrollContainer = null;
+      }
+    }
+    const handleResize = throttle(() => {
+      checkLoadMore();
+    }, props.throttleTime);
+    vue.watch(() => props.loading, (newVal) => {
+      if (!newVal) {
+        vue.nextTick(() => {
+          checkLoadMore();
+        });
+      }
+    });
+    vue.watch(() => props.error, (newVal) => {
+      if (!newVal) {
+        vue.nextTick(() => {
+          checkLoadMore();
+        });
+      }
+    });
+    vue.watch(() => props.refreshLoading, (newVal) => {
+      isRefreshing.value = newVal;
+      if (newVal) {
+        refreshStatus.value = "refreshing";
+      } else {
+        pullDistance.value = 0;
+        setTimeout(() => {
+          refreshStatus.value = "normal";
+        }, 300);
+      }
+    });
+    vue.onMounted(() => {
+      addScrollListener();
+      window.addEventListener("resize", handleResize, { passive: true });
+    });
+    vue.onUnmounted(() => {
+      removeScrollListener();
+      window.removeEventListener("resize", handleResize);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("view", {
+        ref_key: "containerRef",
+        ref: containerRef,
+        class: "infinite-scroll-container",
+        onTouchstart: handleTouchStart,
+        onTouchmove: handleTouchMove,
+        onTouchend: handleTouchEnd,
+        onScroll: _cache[0] || (_cache[0] = //@ts-ignore
+        (...args) => vue.unref(handleScroll) && vue.unref(handleScroll)(...args))
+      }, [
+        vue.createElementVNode("view", {
+          class: "refresh-indicator",
+          style: vue.normalizeStyle({ height: `${pullDistance.value}px` })
+        }, [
+          refreshStatus.value !== "normal" && (refreshStatus.value === "refreshing" || pullDistance.value > 0) ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_1$3, [
+            vue.createElementVNode("view", _hoisted_2$3, [
+              props.refreshLoading ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_3$3, "●")) : (vue.openBlock(), vue.createElementBlock("text", _hoisted_4$2, "↓"))
+            ]),
+            vue.createElementVNode("text", _hoisted_5$1, [
+              props.refreshLoading ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                vue.createTextVNode(vue.toDisplayString(props.refreshingText), 1)
+              ], 64)) : refreshStatus.value === "triggered" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                vue.createTextVNode(vue.toDisplayString(props.releaseText), 1)
+              ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+                vue.createTextVNode(vue.toDisplayString(props.refreshText), 1)
+              ], 64))
+            ])
+          ])) : vue.createCommentVNode("", true)
+        ], 4),
+        vue.createElementVNode("view", _hoisted_6$1, [
+          vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        vue.createElementVNode("view", _hoisted_7$1, [
+          _ctx.loading ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_8$1, [
+            _hoisted_9,
+            vue.createElementVNode("text", _hoisted_10, vue.toDisplayString(_ctx.loadingText), 1)
+          ])) : _ctx.error ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_11, [
+            _hoisted_12,
+            vue.createElementVNode("text", _hoisted_13, vue.toDisplayString(_ctx.errorText), 1),
+            vue.createElementVNode("view", {
+              class: "retry-btn",
+              onClick: onRetry
+            }, vue.toDisplayString(_ctx.retryText), 1)
+          ])) : !_ctx.hasMore ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_14, [
+            vue.createElementVNode("text", _hoisted_15, vue.toDisplayString(_ctx.noMoreText), 1)
+          ])) : (vue.openBlock(), vue.createElementBlock("view", _hoisted_16))
+        ])
+      ], 544);
+    };
+  }
+});
+const index = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-d2876eca"]]);
+function useDropdownSelect(props, emit) {
+  const isOpen = vue.ref(false);
+  const displayText = vue.computed(() => {
+    var _a, _b;
+    if (!((_a = props.options) == null ? void 0 : _a.length)) {
+      return "请选择";
+    }
+    if (props.modelValue !== void 0 && props.modelValue !== null) {
+      const matched = props.options.find(
+        (opt) => opt.value === props.modelValue
+      );
+      if (matched)
+        return matched.text;
+    }
+    return ((_b = props.options[0]) == null ? void 0 : _b.text) || "请选择";
+  });
+  const internalValue = vue.computed({
+    get() {
+      var _a, _b;
+      if (props.modelValue !== void 0 && props.modelValue !== null) {
+        return props.modelValue;
+      }
+      return ((_b = (_a = props.options) == null ? void 0 : _a[0]) == null ? void 0 : _b.value) ?? "";
+    },
+    set(val) {
+      emit("update:modelValue", val);
+    }
+  });
+  const handleChange = (value) => {
+    emit("change", value);
+  };
+  const handleOpen = () => {
+    isOpen.value = true;
+  };
+  const handleClose = () => {
+    isOpen.value = false;
+  };
+  return {
+    displayText,
+    internalValue,
+    isOpen,
+    handleChange,
+    handleOpen,
+    handleClose
+  };
+}
+const _hoisted_1$2 = { class: "dropdown-select" };
+const _hoisted_2$2 = { class: "dropdown-title" };
+const _hoisted_3$2 = { class: "dropdown-text" };
+const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    modelValue: {},
+    iconName: { default: "arrow-down" },
+    options: {}
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { displayText, internalValue, handleChange, handleOpen, handleClose } = useDropdownSelect(props, emit);
+    const isOpen = vue.ref(false);
+    const selectedIndex = vue.computed(() => {
+      if (!props.options || !props.options.length)
+        return 0;
+      return props.options.findIndex((opt) => opt.value === internalValue.value);
+    });
+    function togglePicker() {
+      isOpen.value = !isOpen.value;
+      if (isOpen.value) {
+        handleOpen();
+      } else {
+        handleClose();
+      }
+    }
+    function onPickerChange(e) {
+      const index2 = e.detail.value;
+      const selectedOption = props.options[index2];
+      handleChange(selectedOption.value);
+      isOpen.value = false;
+      handleClose();
+    }
+    function onPickerCancel() {
+      isOpen.value = false;
+      handleClose();
+    }
+    return (_ctx, _cache) => {
+      const _component_picker = vue.resolveComponent("picker");
+      return vue.openBlock(), vue.createElementBlock("view", _hoisted_1$2, [
+        vue.createElementVNode("view", {
+          class: "dropdown-trigger",
+          onTap: togglePicker
+        }, [
+          vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps({ text: vue.unref(displayText) })), () => [
+            vue.createElementVNode("view", _hoisted_2$2, [
+              vue.createElementVNode("text", _hoisted_3$2, vue.toDisplayString(vue.unref(displayText)), 1),
+              vue.createElementVNode("text", {
+                class: vue.normalizeClass(["dropdown-icon", { "is-active": isOpen.value }])
+              }, [
+                vue.renderSlot(_ctx.$slots, "icon", {}, () => [
+                  vue.createElementVNode("view", {
+                    class: vue.normalizeClass(["uni-icon", _ctx.iconName])
+                  }, null, 2)
+                ])
+              ], 2)
+            ])
+          ])
+        ], 32),
+        isOpen.value ? (vue.openBlock(), vue.createBlock(_component_picker, {
+          key: 0,
+          mode: "selector",
+          range: _ctx.options,
+          "range-key": "text",
+          value: selectedIndex.value,
+          class: "dropdown-picker",
+          onChange: onPickerChange,
+          onCancel: onPickerCancel
+        }, null, 8, ["range", "value"])) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+function useDropdownWithBadge(props) {
+  const hasBadge = vue.computed(() => {
+    return props.hideBadge(props.modelValue);
+  });
+  return { hasBadge };
+}
+const _hoisted_1$1 = { class: "dropdown-title" };
+const _hoisted_2$1 = { class: "dropdown-text" };
+const _hoisted_3$1 = { class: "dropdown-icon" };
+const _hoisted_4$1 = { class: "dropdown-with-badge__dot" };
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    hideBadge: { type: Function, default: (modelValue) => modelValue === "" || modelValue === null || modelValue === void 0 }
+  },
+  emits: ["update:modelValue", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { hasBadge } = useDropdownWithBadge(props);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(_sfc_main$2), vue.mergeProps({ modelValue: _ctx.modelValue, options: _ctx.options }, { class: "dropdown-with-badge" }, vue.toHandlers(emit)), {
+        default: vue.withCtx(({ text }) => [
+          vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps({ text })), () => [
+            vue.createElementVNode("view", _hoisted_1$1, [
+              vue.createElementVNode("text", _hoisted_2$1, vue.toDisplayString(text), 1),
+              vue.createElementVNode("text", _hoisted_3$1, [
+                vue.renderSlot(_ctx.$slots, "icon", {}, () => [
+                  vue.createElementVNode("view", {
+                    class: vue.normalizeClass(["uni-icon", _ctx.iconName])
+                  }, null, 2)
+                ])
+              ])
+            ]),
+            vue.withDirectives(vue.createElementVNode("text", _hoisted_4$1, null, 512), [
+              [vue.vShow, !vue.unref(hasBadge)]
+            ])
+          ])
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+function useHasBadge(model) {
+  if (!model) {
+    return vue.computed(() => false);
+  }
+  if (typeof model === "function") {
+    return vue.computed(() => model());
+  }
+  if (vue.isRef(model)) {
+    return vue.computed(() => {
+      if (!model.value)
+        return false;
+      const obj = model.value;
+      for (const key in obj) {
+        if (obj[key]) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  return vue.computed(() => {
+    for (const key in model) {
+      const val = model[key];
+      if (val) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function useFilterDrawer(props, emit) {
+  const visible = vue.ref(false);
+  const hasBadge = useHasBadge(props.modelValue);
+  const openDrawer = () => {
+    visible.value = true;
+  };
+  const closeDrawer = () => {
+    visible.value = false;
+  };
+  const resetDrawer = () => {
+    emit("reset");
+    closeDrawer();
+  };
+  const queryDrawer = () => {
+    emit("query");
+    closeDrawer();
+  };
+  return {
+    visible,
+    openDrawer,
+    closeDrawer,
+    resetDrawer,
+    queryDrawer,
+    hasBadge
+  };
+}
+const _hoisted_1 = /* @__PURE__ */ vue.createElementVNode("view", { class: "uni-icon icon-filter-o" }, null, -1);
+const _hoisted_2 = {
+  key: 0,
+  class: "filter-drawer__badge-dot"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "filter-drawer__popup",
+  style: { height: "100vh", width: "100vw" }
+};
+const _hoisted_4 = { class: "filter-drawer" };
+const _hoisted_5 = { class: "filter-drawer__header" };
+const _hoisted_6 = /* @__PURE__ */ vue.createElementVNode("text", { class: "filter-drawer__title" }, "筛选", -1);
+const _hoisted_7 = { class: "filter-drawer__body" };
+const _hoisted_8 = { class: "filter-drawer__footer" };
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "index",
+  props: {
+    hasBadge: { type: Boolean, default: false },
+    modelValue: {}
+  },
+  emits: ["reset", "query"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { visible, openDrawer, closeDrawer, resetDrawer, queryDrawer, hasBadge } = useFilterDrawer(props, emit);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createElementVNode("view", {
+          class: "filter-drawer__trigger",
+          onClick: _cache[0] || (_cache[0] = //@ts-ignore
+          (...args) => vue.unref(openDrawer) && vue.unref(openDrawer)(...args))
+        }, [
+          vue.renderSlot(_ctx.$slots, "trigger", {}, () => [
+            _hoisted_1
+          ]),
+          vue.unref(hasBadge) ? (vue.openBlock(), vue.createElementBlock("text", _hoisted_2)) : vue.createCommentVNode("", true)
+        ]),
+        vue.unref(visible) ? (vue.openBlock(), vue.createElementBlock("view", {
+          key: 0,
+          class: "filter-drawer__popup-mask",
+          onClick: _cache[1] || (_cache[1] = //@ts-ignore
+          (...args) => vue.unref(closeDrawer) && vue.unref(closeDrawer)(...args))
+        })) : vue.createCommentVNode("", true),
+        vue.unref(visible) ? (vue.openBlock(), vue.createElementBlock("view", _hoisted_3, [
+          vue.createElementVNode("view", {
+            class: "filter-drawer__close",
+            onClick: _cache[2] || (_cache[2] = //@ts-ignore
+            (...args) => vue.unref(closeDrawer) && vue.unref(closeDrawer)(...args))
+          }, " × "),
+          vue.createElementVNode("view", _hoisted_4, [
+            vue.createElementVNode("view", _hoisted_5, [
+              vue.renderSlot(_ctx.$slots, "header", {}, () => [
+                _hoisted_6
+              ])
+            ]),
+            vue.createElementVNode("view", _hoisted_7, [
+              vue.renderSlot(_ctx.$slots, "default")
+            ]),
+            vue.createElementVNode("view", _hoisted_8, [
+              vue.renderSlot(_ctx.$slots, "footer", {}, () => [
+                vue.createElementVNode("view", {
+                  class: "filter-drawer__button filter-drawer__button--plain",
+                  onClick: _cache[3] || (_cache[3] = //@ts-ignore
+                  (...args) => vue.unref(resetDrawer) && vue.unref(resetDrawer)(...args))
+                }, " 重置条件 "),
+                vue.createElementVNode("view", {
+                  class: "filter-drawer__button",
+                  onClick: _cache[4] || (_cache[4] = //@ts-ignore
+                  (...args) => vue.unref(queryDrawer) && vue.unref(queryDrawer)(...args))
+                }, " 查询 ")
+              ])
+            ])
+          ])
+        ])) : vue.createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+exports.Button = index$7;
+exports.Dialog = index$6;
+exports.Divider = index$5;
+exports.DropdownSelect = _sfc_main$2;
+exports.DropdownWithBadge = _sfc_main$1;
+exports.FilterDrawer = _sfc_main;
+exports.InfiniteScroll = index$1;
+exports.Popup = index$4;
+exports.PullRefresh = index;
+exports.Swiper = index$2;
+exports.Toast = index$3;
+exports.useDropdownSelect = useDropdownSelect;
+exports.useDropdownWithBadge = useDropdownWithBadge;
+exports.useFilterDrawer = useFilterDrawer;
+//# sourceMappingURL=index.cjs.js.map