yc-design-vue 1.7.5 → 1.7.7

package/es/Cascader/Cascader.vue.js

@@ -1,7 +1,290 @@
-import _sfc_main from "./Cascader.vue2.js";
-/* empty css              */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const _Cascader = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-546388ae"]]);
+import { defineComponent, ref, computed, createBlock, openBlock, unref, mergeProps, isRef, withCtx, createElementVNode, normalizeStyle, normalizeClass, createSlots, createVNode, renderSlot, normalizeProps, guardReactiveProps, toDisplayString } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { sleep } from "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import useContext from "./hooks/useContext.js";
+import Input from "../Input/index.js";
+import InputTag from "../InputTag/index.js";
+import Trigger from "../Trigger/index.js";
+import _sfc_main$3 from "./CascaderPanel.vue.js";
+/* empty css                   */
+import _sfc_main$2 from "./CascaderSearchPanel.vue.js";
+/* empty css                         */
+import _sfc_main$1 from "./CascaderIcon.vue.js";
+/* empty css                  */
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Cascader"
+  },
+  __name: "Cascader",
+  props: {
+    pathMode: { type: Boolean, default: false },
+    multiple: { type: Boolean, default: false },
+    modelValue: { default: void 0 },
+    defaultValue: { default: (props) => {
+      return props.multiple ? [] : "";
+    } },
+    options: { default: () => [] },
+    disabled: { type: Boolean, default: false },
+    error: { type: Boolean, default: false },
+    size: { default: void 0 },
+    allowSearch: { type: Boolean, default: false },
+    allowClear: { type: Boolean, default: false },
+    inputValue: { default: void 0 },
+    defaultInputValue: { default: "" },
+    popupVisible: { type: Boolean, default: void 0 },
+    defaultPopupVisible: { type: Boolean, default: false },
+    expandTrigger: { default: "click" },
+    placeholder: { default: "" },
+    filterOption: { type: Function, default: (inputValue, option) => {
+      const label = (option.label ?? "").toLowerCase();
+      return label.includes(inputValue.toLowerCase());
+    } },
+    popupContainer: { default: void 0 },
+    maxTagCount: { default: 0 },
+    formatLabel: { type: Function, default: void 0 },
+    triggerProps: { default: () => {
+      return {};
+    } },
+    loadMore: { type: Function, default: void 0 },
+    loading: { type: Boolean, default: false },
+    searchOptionOnlyLabel: { type: Boolean, default: false },
+    searchDelay: { default: 500 },
+    fieldNames: { default: () => {
+      return {};
+    } },
+    valueKey: { default: "value" },
+    fallback: { type: [Boolean, Function], default: true },
+    expandChild: { type: Boolean, default: false },
+    tagNowrap: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "update:inputValue", "update:popupVisible", "change", "input-value-change", "clear", "search", "popup-visible-change", "focus", "blur"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const inputRef = ref();
+    const {
+      computedValue,
+      computedInputValue,
+      computedVisible,
+      selectOptions,
+      searchDelay,
+      multiple,
+      pathMode,
+      disabled,
+      allowClear,
+      allowSearch,
+      loading,
+      curLevel,
+      curPath,
+      getValueKey,
+      getOption
+    } = useContext().provide(props, emits, inputRef);
+    const showClearBtn = computed(() => {
+      let hasValue = true;
+      if (pathMode.value) {
+        hasValue = multiple.value ? computedValue.value.flat(1).length : computedValue.value.length;
+      } else {
+        hasValue = multiple.value ? computedValue.value.length : computedValue.value;
+      }
+      return allowClear.value && !disabled.value && !loading.value && !!hasValue;
+    });
+    const isReadonly = computed(() => {
+      return !allowSearch.value || loading.value;
+    });
+    const isSearchMode = computed(() => {
+      return allowSearch.value && computedInputValue.value;
+    });
+    const handleEvent = async (type, value = "") => {
+      var _a, _b;
+      switch (type) {
+        case "clear":
+          {
+            computedValue.value = multiple.value || pathMode.value ? [] : "";
+            emits("clear");
+          }
+          break;
+        case "search":
+          {
+            await sleep(searchDelay.value);
+            emits("search", value);
+          }
+          break;
+        case "focus":
+          {
+            if (disabled.value) {
+              return;
+            }
+            if (computedVisible.value) {
+              return (_a = inputRef.value) == null ? void 0 : _a.blur();
+            }
+            const value2 = getValueKey(
+              multiple.value ? computedValue.value[0] : computedValue.value
+            );
+            const option = value2 ? getOption(value2) : null;
+            if (option) {
+              curPath.value = option.nodePath.map((item) => item.index);
+              curLevel.value = option.level;
+            } else {
+              curPath.value = [];
+              curLevel.value = 1;
+            }
+            computedVisible.value = true;
+            await sleep(0);
+            (_b = inputRef.value) == null ? void 0 : _b.focus();
+          }
+          break;
+        case "blur":
+          {
+            computedVisible.value = false;
+          }
+          break;
+        case "updateValue":
+          {
+            computedValue.value = value.map(
+              (item) => item.value
+            );
+          }
+          break;
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Trigger), mergeProps({
+        "popup-visible": unref(computedVisible),
+        "onUpdate:popupVisible": _cache[11] || (_cache[11] = ($event) => isRef(computedVisible) ? computedVisible.value = $event : null),
+        "popup-offset": 4,
+        "popup-container": _ctx.popupContainer,
+        disabled: unref(disabled),
+        "content-style": {
+          background: "transparent"
+        },
+        position: "bl",
+        trigger: "focus",
+        "animation-name": "slide-dynamic-origin",
+        "prevent-focus": ""
+      }, _ctx.triggerProps), {
+        content: withCtx(() => [
+          isSearchMode.value ? (openBlock(), createBlock(_sfc_main$2, { key: 0 })) : (openBlock(), createBlock(_sfc_main$3, { key: 1 }))
+        ]),
+        default: withCtx(() => {
+          var _a, _b;
+          return [
+            createElementVNode("div", {
+              class: normalizeClass([
+                "yc-cascader",
+                {
+                  "yc-cascader-allow-clear": showClearBtn.value,
+                  "yc-cascader-allow-search": unref(allowSearch)
+                },
+                _ctx.$attrs.class
+              ]),
+              style: normalizeStyle(_ctx.$attrs.style)
+            }, [
+              unref(multiple) ? (openBlock(), createBlock(unref(InputTag), {
+                key: 0,
+                "input-value": unref(computedInputValue),
+                "onUpdate:inputValue": _cache[1] || (_cache[1] = ($event) => isRef(computedInputValue) ? computedInputValue.value = $event : null),
+                "model-value": unref(selectOptions),
+                placeholder: _ctx.placeholder,
+                readonly: isReadonly.value,
+                disabled: unref(disabled),
+                size: _ctx.size,
+                error: _ctx.error,
+                "max-tag-count": _ctx.maxTagCount,
+                "tag-nowrap": _ctx.tagNowrap,
+                ref_key: "inputRef",
+                ref: inputRef,
+                onFocus: _cache[2] || (_cache[2] = ($event) => handleEvent("focus")),
+                onBlur: _cache[3] || (_cache[3] = ($event) => handleEvent("blur")),
+                onInput: _cache[4] || (_cache[4] = (v) => handleEvent("search", v)),
+                "onUpdate:modelValue": _cache[5] || (_cache[5] = (v) => handleEvent("updateValue", v))
+              }, createSlots({
+                suffix: withCtx(() => [
+                  createVNode(_sfc_main$1, {
+                    "popup-visible": unref(computedVisible),
+                    "allow-search": unref(allowSearch),
+                    loading: unref(loading),
+                    "show-clear-btn": showClearBtn.value,
+                    onClear: _cache[0] || (_cache[0] = ($event) => handleEvent("clear"))
+                  }, null, 8, ["popup-visible", "allow-search", "loading", "show-clear-btn"])
+                ]),
+                _: 2
+              }, [
+                _ctx.$slots.label ? {
+                  name: "tag",
+                  fn: withCtx((scope) => [
+                    renderSlot(_ctx.$slots, "label", normalizeProps(guardReactiveProps(scope)))
+                  ]),
+                  key: "0"
+                } : void 0,
+                _ctx.$slots.prefix ? {
+                  name: "prefix",
+                  fn: withCtx(() => [
+                    renderSlot(_ctx.$slots, "prefix")
+                  ]),
+                  key: "1"
+                } : void 0
+              ]), 1032, ["input-value", "model-value", "placeholder", "readonly", "disabled", "size", "error", "max-tag-count", "tag-nowrap"])) : (openBlock(), createBlock(unref(Input), {
+                key: 1,
+                modelValue: unref(computedInputValue),
+                "onUpdate:modelValue": _cache[7] || (_cache[7] = ($event) => isRef(computedInputValue) ? computedInputValue.value = $event : null),
+                "show-input": unref(computedVisible),
+                readonly: isReadonly.value,
+                disabled: unref(disabled),
+                size: _ctx.size,
+                error: _ctx.error,
+                placeholder: ((_b = (_a = unref(selectOptions)[0]) == null ? void 0 : _a.label) == null ? void 0 : _b.toString()) || "",
+                ref_key: "inputRef",
+                ref: inputRef,
+                onClick: _cache[8] || (_cache[8] = ($event) => handleEvent("focus")),
+                onBlur: _cache[9] || (_cache[9] = ($event) => handleEvent("blur")),
+                onInput: _cache[10] || (_cache[10] = (v) => handleEvent("search", v))
+              }, createSlots({
+                label: withCtx(() => [
+                  renderSlot(_ctx.$slots, "label", {
+                    data: unref(selectOptions)[0]
+                  }, () => {
+                    var _a2, _b2;
+                    return [
+                      createElementVNode("span", {
+                        class: normalizeClass([
+                          {
+                            "yc-input-placeholder": !((_a2 = unref(selectOptions)[0]) == null ? void 0 : _a2.label)
+                          }
+                        ])
+                      }, toDisplayString(((_b2 = unref(selectOptions)[0]) == null ? void 0 : _b2.label) || _ctx.placeholder), 3)
+                    ];
+                  })
+                ]),
+                suffix: withCtx(() => [
+                  createVNode(_sfc_main$1, {
+                    "popup-visible": unref(computedVisible),
+                    "allow-search": unref(allowSearch),
+                    loading: unref(loading),
+                    "show-clear-btn": showClearBtn.value,
+                    onClear: _cache[6] || (_cache[6] = ($event) => handleEvent("clear"))
+                  }, null, 8, ["popup-visible", "allow-search", "loading", "show-clear-btn"])
+                ]),
+                _: 2
+              }, [
+                _ctx.$slots.prefix ? {
+                  name: "prefix",
+                  fn: withCtx(() => [
+                    renderSlot(_ctx.$slots, "prefix")
+                  ]),
+                  key: "0"
+                } : void 0
+              ]), 1032, ["modelValue", "show-input", "readonly", "disabled", "size", "error", "placeholder"]))
+            ], 6)
+          ];
+        }),
+        _: 3
+      }, 16, ["popup-visible", "popup-container", "disabled"]);
+    };
+  }
+});
 export {
-  _Cascader as default
+  _sfc_main as default
 };

package/es/Cascader/Cascader.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./Cascader.vue.js";
+/* empty css              */
+export {
+  _sfc_main as default
+};

package/es/Cascader/CascaderIcon.vue.js

@@ -1,7 +1,67 @@
-import _sfc_main from "./CascaderIcon.vue2.js";
-/* empty css                  */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const CascaderIcon = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b7d4002f"]]);
+import { defineComponent, resolveComponent, createBlock, createElementBlock, openBlock, unref, createSlots, withCtx, resolveDynamicComponent, Fragment, createElementVNode, createCommentVNode, withModifiers } from "vue";
+import useContext from "./hooks/useContext.js";
+import _sfc_main$1 from "../_shared/icons/IconArrowDown.vue.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import _sfc_main$2 from "../_shared/components/IconButton.vue.js";
+/* empty css                                    */
+/* empty css                                         */
+import Spin from "../Spin/index.js";
+const _hoisted_1 = { class: "yc-cascader-suffix-icon" };
+const _hoisted_2 = {
+  key: 0,
+  class: "yc-cascader-search-icon"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CascaderIcon",
+  props: {
+    loading: { type: Boolean },
+    popupVisible: { type: Boolean },
+    showClearBtn: { type: Boolean },
+    allowSearch: { type: Boolean }
+  },
+  emits: ["clear"],
+  setup(__props) {
+    const { slots } = useContext().inject();
+    const renderIcon = (name) => {
+      return slots[name];
+    };
+    return (_ctx, _cache) => {
+      const _component_icon_search = resolveComponent("icon-search");
+      return _ctx.loading ? (openBlock(), createBlock(unref(Spin), {
+        key: 0,
+        size: 12,
+        class: "yc-cascader-loading-icon"
+      }, createSlots({ _: 2 }, [
+        _ctx.$slots["loading-icon"] ? {
+          name: "icon",
+          fn: withCtx(() => [
+            (openBlock(), createBlock(resolveDynamicComponent(renderIcon("loading-icon"))))
+          ]),
+          key: "0"
+        } : void 0
+      ]), 1024)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
+        createElementVNode("div", _hoisted_1, [
+          unref(slots)["arrow-icon"] ? (openBlock(), createBlock(resolveDynamicComponent(renderIcon("arrow-icon")), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$1), {
+            key: 1,
+            rotate: _ctx.popupVisible ? 180 : 0
+          }, null, 8, ["rotate"]))
+        ]),
+        _ctx.allowSearch ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          unref(slots)["search-icon"] ? (openBlock(), createBlock(resolveDynamicComponent(renderIcon("search-icon")), { key: 0 })) : (openBlock(), createBlock(_component_icon_search, { key: 1 }))
+        ])) : createCommentVNode("", true),
+        _ctx.showClearBtn ? (openBlock(), createBlock(unref(_sfc_main$2), {
+          key: 1,
+          class: "yc-cascader-clear-icon",
+          onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("clear"), ["stop"]))
+        })) : createCommentVNode("", true)
+      ], 64));
+    };
+  }
+});
 export {
-  CascaderIcon as default
+  _sfc_main as default
 };

package/es/Cascader/CascaderIcon.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./CascaderIcon.vue.js";
+/* empty css                  */
+export {
+  _sfc_main as default
+};

package/es/Cascader/CascaderOption.vue.js

@@ -1,7 +1,207 @@
-import _sfc_main from "./CascaderOption.vue2.js";
-/* empty css                    */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const YcCascaderOption = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-2b9a8f90"]]);
+import { defineComponent, toRefs, ref, computed, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, createElementVNode, resolveDynamicComponent } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import { sleep } from "../_shared/utils/dom.js";
+import { isFunction } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                             */
+import _sfc_main$1 from "../_shared/icons/IconArrowRight.vue.js";
+import _sfc_main$2 from "../_shared/icons/IconLoading.vue.js";
+import Checkbox from "../Checkbox/index.js";
+import useContext, { getLeafNodes, findOptionByValueAndLevel } from "./hooks/useContext.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CascaderOption",
+  props: {
+    level: { default: -1 },
+    index: { default: -1 },
+    nodePath: { default: () => [] },
+    label: { default: "" },
+    value: { default: "" },
+    render: { type: Function, default: void 0 },
+    disabled: { type: Boolean, default: false },
+    tagProps: { default: () => {
+      return {};
+    } },
+    children: { default: () => [] },
+    isLeaf: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const { label, value, disabled, level, isLeaf, children, nodePath } = toRefs(props);
+    const {
+      totalOptions,
+      computedValue,
+      pathMode,
+      curLevel,
+      curPath,
+      multiple,
+      expandTrigger,
+      expandChild,
+      slots,
+      getOption,
+      getValueKey,
+      blur,
+      loadMore
+    } = useContext().inject();
+    const loading = ref(false);
+    const showArrow = computed(() => {
+      if (isFunction(loadMore)) {
+        return !loading.value && !isLeaf.value && !children.value.length;
+      } else {
+        return children.value.length;
+      }
+    });
+    const leafNodes = computed(() => {
+      return children.value.length ? getLeafNodes(children.value) : [getOption(value.value)];
+    });
+    const isLeafNode = computed(() => {
+      return !children.value.length;
+    });
+    const checked = computed(() => {
+      var _a;
+      if (!computedValue.value) {
+        return false;
+      }
+      if (!multiple.value) {
+        const option = getOption(computedValue.value) ?? {};
+        return (_a = option.nodePath) == null ? void 0 : _a.some((node) => {
+          return getValueKey(node.value) == getValueKey(value.value);
+        });
+      }
+      const valueOptions = computedValue.value.map(
+        (v) => {
+          return getOption(v) ?? {};
+        }
+      );
+      if (isLeafNode.value) {
+        return valueOptions.some(
+          (option) => getValueKey(option == null ? void 0 : option.value) == getValueKey(value.value)
+        );
+      }
+      const valueMap = Object.fromEntries(
+        valueOptions.map((option) => [getValueKey(option == null ? void 0 : option.value), option])
+      );
+      return leafNodes.value.every((node) => valueMap[getValueKey(node.value)]);
+    });
+    const indeterminate = computed(() => {
+      if (isLeafNode.value || !multiple.value) {
+        return false;
+      }
+      const valueOptions = computedValue.value.map(
+        (v) => {
+          return getOption(v) ?? {};
+        }
+      );
+      const valueMap = Object.fromEntries(
+        valueOptions.map((option) => [getValueKey(option.value), option])
+      );
+      return leafNodes.value.some((node) => valueMap[getValueKey(node.value)]);
+    });
+    const handleMuti = (checked2) => {
+      var _a, _b, _c, _d, _e;
+      const curValue = computedValue.value;
+      if (checked2) {
+        const valueMap = Object.fromEntries(
+          curValue.map((v) => {
+            return [getValueKey(v), v];
+          })
+        );
+        computedValue.value = [
+          ...curValue,
+          ...leafNodes.value.map((item) => {
+            return pathMode.value ? item.nodePath.map((v) => v.value) : item.value;
+          }).filter((item) => {
+            return !valueMap[getValueKey(item)];
+          })
+        ];
+        curLevel.value = ((_b = (_a = leafNodes.value) == null ? void 0 : _a[0]) == null ? void 0 : _b.level) ?? curLevel.value;
+        curPath.value = ((_e = (_d = (_c = leafNodes.value) == null ? void 0 : _c[0]) == null ? void 0 : _d.nodePath) == null ? void 0 : _e.map((item) => item.index)) ?? curPath.value;
+      } else {
+        const valueMap = Object.fromEntries(
+          leafNodes.value.map((item) => {
+            return pathMode.value ? item.nodePath.map((v) => v.value) : item.value;
+          }).map((v) => {
+            return [getValueKey(v), v];
+          })
+        );
+        computedValue.value = curValue.filter((item) => {
+          return !valueMap[getValueKey(item)];
+        });
+        curLevel.value = level.value;
+        curPath.value = nodePath.value.map((item) => item.index);
+      }
+    };
+    const handleEvent = async (type) => {
+      if (disabled.value || loading.value) {
+        return;
+      }
+      if (showArrow.value && isFunction(loadMore) && expandTrigger.value == type) {
+        loading.value = true;
+        const option = findOptionByValueAndLevel(
+          totalOptions.value,
+          value.value,
+          level.value
+        );
+        await new Promise((resolve) => {
+          loadMore(option, (children2) => {
+            option.children = (children2 == null ? void 0 : children2.length) ? children2 : [];
+            resolve("");
+          });
+        });
+        loading.value = false;
+        await sleep(0);
+      }
+      if (!isLeafNode.value && expandTrigger.value == type) {
+        curLevel.value = expandChild.value ? leafNodes.value[0].level : level.value + 1;
+        curPath.value = expandChild.value ? leafNodes.value[0].nodePath.map((item) => item.index) : nodePath.value.map((item) => item.index);
+      }
+      if (isLeafNode.value && type == "click" && !multiple.value) {
+        computedValue.value = pathMode.value ? nodePath.value.map((item) => item.value) : value.value;
+        blur();
+      }
+    };
+    const renderLabel = () => {
+      var _a;
+      return ((_a = slots.option) == null ? void 0 : _a.call(slots, {
+        data: props
+      })) ?? label.value;
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("li", {
+        tabindex: "0",
+        role: "menuitem",
+        class: normalizeClass([
+          "yc-cascader-option",
+          {
+            "yc-cascader-option-selected": checked.value || indeterminate.value,
+            "yc-cascader-option-disabled": unref(disabled)
+          }
+        ])
+      }, [
+        unref(multiple) ? (openBlock(), createBlock(unref(Checkbox), {
+          key: 0,
+          disabled: unref(disabled),
+          "model-value": checked.value,
+          indeterminate: indeterminate.value,
+          "onUpdate:modelValue": handleMuti
+        }, null, 8, ["disabled", "model-value", "indeterminate"])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          class: "yc-cascader-option-label text-ellipsis",
+          onMouseenter: _cache[0] || (_cache[0] = ($event) => handleEvent("hover")),
+          onClick: _cache[1] || (_cache[1] = ($event) => handleEvent("click"))
+        }, [
+          (openBlock(), createBlock(resolveDynamicComponent(renderLabel))),
+          showArrow.value ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : createCommentVNode("", true),
+          loading.value ? (openBlock(), createBlock(unref(_sfc_main$2), {
+            key: 1,
+            color: "rgb(22,93,255)",
+            spin: ""
+          })) : createCommentVNode("", true)
+        ], 32)
+      ], 2);
+    };
+  }
+});
 export {
-  YcCascaderOption as default
+  _sfc_main as default
 };

package/es/Cascader/CascaderOption.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./CascaderOption.vue.js";
+/* empty css                    */
+export {
+  _sfc_main as default
+};

package/es/Cascader/CascaderPanel.vue.js

@@ -1,7 +1,64 @@
-import _sfc_main from "./CascaderPanel.vue2.js";
-/* empty css                   */
-import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
-const CascaderPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-0880e9fb"]]);
+import { defineComponent, createBlock, openBlock, TransitionGroup, withCtx, createElementBlock, unref, resolveDynamicComponent, Fragment, renderList, withDirectives, normalizeStyle, createVNode, createElementVNode, mergeProps, vShow } from "vue";
+import useContext, { findOptions } from "./hooks/useContext.js";
+import _sfc_main$1 from "./CascaderOption.vue.js";
+/* empty css                    */
+import Scrollbar from "../Scrollbar/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import "../_shared/utils/time.js";
+import { getGlobalConfig } from "../_shared/utils/global-config.js";
+import Spin from "../Spin/index.js";
+const _hoisted_1 = {
+  role: "menu",
+  class: "yc-cascader-list"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CascaderPanel",
+  setup(__props) {
+    const { renderEmpty } = getGlobalConfig();
+    const { options, curLevel, curPath, maxLevel, loading, slots } = useContext().inject();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(TransitionGroup, {
+        tag: "div",
+        name: "cascader-slide",
+        class: "yc-cascader-panel"
+      }, {
+        default: withCtx(() => [
+          unref(loading) ? (openBlock(), createBlock(unref(Spin), {
+            key: 0,
+            loading: unref(loading)
+          }, null, 8, ["loading"])) : !unref(options).length ? (openBlock(), createBlock(resolveDynamicComponent(unref(slots).empty || unref(renderEmpty)("Select")), { key: 1 })) : (openBlock(true), createElementBlock(Fragment, { key: 2 }, renderList(unref(maxLevel), (i) => {
+            return withDirectives((openBlock(), createElementBlock("div", {
+              key: i,
+              style: normalizeStyle({
+                zIndex: unref(maxLevel) + 1 - i
+              }),
+              class: "yc-cascader-panel-column"
+            }, [
+              createVNode(unref(Scrollbar), { class: "yc-cascader-column-content" }, {
+                default: withCtx(() => [
+                  createElementVNode("ul", _hoisted_1, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(unref(findOptions)(
+                      unref(options),
+                      i,
+                      unref(curPath).slice(0, i - 1)
+                    ), (option, i1) => {
+                      return openBlock(), createBlock(_sfc_main$1, mergeProps({ key: i1 }, { ref_for: true }, option), null, 16);
+                    }), 128))
+                  ])
+                ]),
+                _: 2
+              }, 1024)
+            ], 4)), [
+              [vShow, unref(curLevel) >= i]
+            ]);
+          }), 128))
+        ]),
+        _: 1
+      });
+    };
+  }
+});
 export {
-  CascaderPanel as default
+  _sfc_main as default
 };

package/es/Cascader/CascaderPanel.vue3.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./CascaderPanel.vue.js";
+/* empty css                   */
+export {
+  _sfc_main as default
+};