yc-design-vue 1.7.6 → 1.7.8

package/es/Skeleton/SkeletonShape.vue2.js

@@ -1,31 +0,0 @@
-import { defineComponent, createElementBlock, openBlock, normalizeClass, unref } from "vue";
-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";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "SkeletonShape"
-  },
-  __name: "SkeletonShape",
-  props: {
-    shape: { default: "sqaure" },
-    size: { default: void 0 }
-  },
-  setup(__props) {
-    const props = __props;
-    const { size } = getGlobalConfig(props);
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-skeleton-shape",
-          `yc-skeleton-shape-shape-${_ctx.shape}`,
-          `yc-skeleton-shape-size-${unref(size)}`
-        ])
-      }, null, 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Slider/Slider.vue2.js

@@ -1,145 +0,0 @@
-import { defineComponent, ref, computed, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, createCommentVNode, createBlock, createVNode, normalizeStyle } from "vue";
-import useContext from "./hooks/useContext.js";
-import SliderTicks from "./SliderTicks.vue.js";
-import SliderBtn from "./SliderBtn.vue.js";
-import SliderInput from "./SliderInput.vue.js";
-const _hoisted_1 = ["aria-disabled"];
-const _hoisted_2 = {
-  key: 0,
-  class: "yc-slider-input"
-};
-const _hoisted_3 = {
-  key: 0,
-  class: "yc-slider-input-divider"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Slider"
-  },
-  __name: "Slider",
-  props: {
-    modelValue: { default: void 0 },
-    defaultValue: { default: 0 },
-    step: { default: 1 },
-    min: { default: 0 },
-    marks: { default: () => {
-      return {};
-    } },
-    max: { default: 100 },
-    direction: { default: "horizontal" },
-    disabled: { type: Boolean, default: false },
-    showTicks: { type: Boolean, default: false },
-    showInput: { type: Boolean, default: false },
-    range: { type: Boolean, default: false },
-    showTooltip: { type: Boolean, default: true },
-    formatTooltip: { type: Function, default: (val) => {
-      return val + "";
-    } }
-  },
-  emits: ["update:modelValue", "change"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const trackRef = ref();
-    const { ticks, marks, range, direction, min, normalizeValue } = useContext().provide(props, emits, trackRef);
-    const startPosition = ref({
-      bottom: 0,
-      left: 0,
-      top: 0,
-      right: 0
-    });
-    const endPosition = ref({
-      bottom: 0,
-      left: 0,
-      top: 0,
-      right: 0
-    });
-    const position = computed(() => {
-      const { left, right, top, bottom } = startPosition.value;
-      if (!range.value) {
-        return direction.value == "vertical" ? {
-          top: top + "%",
-          bottom: normalizeValue(min.value) + "%"
-        } : {
-          left: normalizeValue(min.value) + "%",
-          right: right + "%"
-        };
-      }
-      const {
-        left: left1,
-        right: right1,
-        top: top1,
-        bottom: bottom1
-      } = endPosition.value;
-      return direction.value == "vertical" ? {
-        top: `${top < top1 ? top : top1}%`,
-        bottom: `${bottom < bottom1 ? bottom : bottom1}%`
-      } : {
-        left: `${left < left1 ? left : left1}%`,
-        right: `${right < right1 ? right : right1}%`
-      };
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-slider",
-          `yc-slider-direction-${unref(direction)}`,
-          {
-            "yc-slider-disabled": _ctx.disabled
-          }
-        ])
-      }, [
-        createElementVNode("div", {
-          class: "yc-slider-track",
-          ref_key: "trackRef",
-          ref: trackRef
-        }, [
-          _ctx.showTicks ? (openBlock(), createBlock(SliderTicks, {
-            key: 0,
-            type: "ticks",
-            data: unref(ticks)
-          }, null, 8, ["data"])) : createCommentVNode("", true),
-          unref(marks).length ? (openBlock(), createBlock(SliderTicks, {
-            key: 1,
-            type: "dots",
-            data: unref(marks)
-          }, null, 8, ["data"])) : createCommentVNode("", true),
-          unref(marks).length ? (openBlock(), createBlock(SliderTicks, {
-            key: 2,
-            type: "marks",
-            data: unref(marks)
-          }, null, 8, ["data"])) : createCommentVNode("", true),
-          createElementVNode("div", {
-            class: "yc-slider-bar",
-            role: "slider",
-            tabindex: "0",
-            "aria-disabled": _ctx.disabled,
-            style: normalizeStyle(position.value)
-          }, null, 12, _hoisted_1),
-          createVNode(SliderBtn, {
-            position: startPosition.value,
-            "onUpdate:position": _cache[0] || (_cache[0] = ($event) => startPosition.value = $event),
-            type: "start"
-          }, null, 8, ["position"]),
-          unref(range) ? (openBlock(), createBlock(SliderBtn, {
-            key: 3,
-            position: endPosition.value,
-            "onUpdate:position": _cache[1] || (_cache[1] = ($event) => endPosition.value = $event),
-            type: "end"
-          }, null, 8, ["position"])) : createCommentVNode("", true)
-        ], 512),
-        _ctx.showInput ? (openBlock(), createElementBlock("div", _hoisted_2, [
-          createVNode(SliderInput, { type: "start" }),
-          unref(range) ? (openBlock(), createElementBlock("div", _hoisted_3)) : createCommentVNode("", true),
-          unref(range) ? (openBlock(), createBlock(SliderInput, {
-            key: 1,
-            type: "end"
-          })) : createCommentVNode("", true)
-        ])) : createCommentVNode("", true)
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Slider/SliderBtn.vue2.js

@@ -1,98 +0,0 @@
-import { defineComponent, toRefs, ref, computed, watch, createBlock, openBlock, unref, isRef, withCtx, createElementVNode, normalizeStyle } from "vue";
-import useContext from "./hooks/useContext.js";
-import useSliderDraggable from "./hooks/useSliderDraggable.js";
-import Tooltip from "../Tooltip/index.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 useControlValue from "../_shared/utils/control.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "SliderBtn",
-  props: {
-    type: {},
-    position: {}
-  },
-  emits: ["update:position"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { type } = toRefs(props);
-    const triggerRef = ref();
-    const {
-      trackRef,
-      min,
-      max,
-      direction,
-      disabled,
-      step,
-      showTooltip,
-      startValue,
-      endValue,
-      formatTooltip,
-      normalizeValue,
-      denormalizeValue
-    } = useContext().inject();
-    const computedValue = computed({
-      get() {
-        return type.value == "start" ? startValue.value : endValue.value;
-      },
-      set(val) {
-        if (type.value == "start") {
-          startValue.value = val;
-        } else {
-          endValue.value = val;
-        }
-      }
-    });
-    const { position, isDragging } = useSliderDraggable({
-      trackRef,
-      triggerRef,
-      computedValue,
-      direction,
-      step,
-      min,
-      max,
-      disabled,
-      denormalizeValue,
-      normalizeValue
-    });
-    const computedVisible = useControlValue(
-      ref(),
-      false,
-      () => {
-      },
-      (val) => {
-        return isDragging.value || val;
-      }
-    );
-    watch(position, () => {
-      emits("update:position", position);
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(Tooltip), {
-        "popup-visible": unref(computedVisible),
-        "onUpdate:popupVisible": _cache[0] || (_cache[0] = ($event) => isRef(computedVisible) ? computedVisible.value = $event : null),
-        disabled: !unref(showTooltip),
-        position: unref(direction) == "vertical" ? "right" : "bottom",
-        content: unref(formatTooltip) ? unref(formatTooltip)(computedValue.value) : String(computedValue.value)
-      }, {
-        default: withCtx(() => [
-          createElementVNode("div", {
-            class: "yc-slider-btn",
-            ref_key: "triggerRef",
-            ref: triggerRef,
-            style: normalizeStyle({
-              transform: unref(position).transform
-            })
-          }, null, 4)
-        ]),
-        _: 1
-      }, 8, ["popup-visible", "disabled", "position", "content"]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Slider/SliderInput.vue2.js

@@ -1,56 +0,0 @@
-import { defineComponent, toRefs, computed, createBlock, openBlock, unref } from "vue";
-import useContext from "./hooks/useContext.js";
-import InputNumber from "../InputNumber/index.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "SliderInput",
-  props: {
-    type: {}
-  },
-  setup(__props) {
-    const props = __props;
-    const { type } = toRefs(props);
-    const {
-      min,
-      max,
-      disabled,
-      startValue,
-      endValue,
-      tempStartValue,
-      tempEndValue
-    } = useContext().inject();
-    const computedValue = computed({
-      get() {
-        return type.value == "start" ? tempStartValue.value : tempEndValue.value;
-      },
-      set(val) {
-        if (type.value == "start") {
-          tempStartValue.value = val;
-        } else {
-          tempEndValue.value = val;
-        }
-      }
-    });
-    const handleSet = () => {
-      if (type.value == "start") {
-        startValue.value = computedValue.value;
-      } else {
-        endValue.value = computedValue.value;
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(InputNumber), {
-        modelValue: computedValue.value,
-        "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => computedValue.value = $event),
-        min: unref(min),
-        max: unref(max),
-        disabled: unref(disabled),
-        "hide-button": "",
-        onBlur: handleSet,
-        onPressEnter: handleSet
-      }, null, 8, ["modelValue", "min", "max", "disabled"]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Slider/SliderTicks.vue2.js

@@ -1,66 +0,0 @@
-import { defineComponent, toRefs, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, normalizeStyle, toDisplayString } from "vue";
-import useContext from "./hooks/useContext.js";
-const _hoisted_1 = ["onClick"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "SliderTicks",
-  props: {
-    type: {},
-    data: {}
-  },
-  emits: ["labelClick"],
-  setup(__props) {
-    const props = __props;
-    const { type } = toRefs(props);
-    const { min, max, startValue, endValue, range, direction, normalizeValue } = useContext().inject();
-    const getPosition = (value) => {
-      const curValue = normalizeValue(value);
-      if (type.value == "ticks") {
-        return `calc(${curValue}% - 0.5px)`;
-      } else if (type.value == "dots") {
-        return `calc(${curValue}% - 4px)`;
-      } else {
-        return `calc(${curValue}% - 7px)`;
-      }
-    };
-    const isInRange = (value) => {
-      const curValue = normalizeValue(value);
-      const start = normalizeValue(startValue.value);
-      const end = normalizeValue(endValue.value);
-      const rangeMin = normalizeValue(min.value);
-      const rangeMax = normalizeValue(max.value);
-      if (!range.value) {
-        return start >= curValue && curValue >= rangeMin && curValue <= rangeMax;
-      } else {
-        const minVal = Math.min(start, end);
-        const maxVal = Math.max(start, end);
-        return curValue >= minVal && curValue <= maxVal;
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([`yc-slider-${unref(type)}`])
-      }, [
-        (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.data, ({ label, value }) => {
-          return openBlock(), createElementBlock("span", {
-            key: value,
-            style: normalizeStyle({
-              left: unref(direction) == "horizontal" ? getPosition(value) : "",
-              bottom: unref(direction) == "vertical" ? getPosition(value) : ""
-            }),
-            class: normalizeClass([
-              `yc-slider-${unref(type).replace("s", "")}`,
-              {
-                "yc-slider-dot-active": unref(type) == "dots" && isInRange(value),
-                "yc-slider-tick-active": unref(type) == "ticks" && isInRange(value)
-              }
-            ]),
-            onClick: ($event) => _ctx.$emit("labelClick", value)
-          }, toDisplayString(unref(type) == "marks" ? label : ""), 15, _hoisted_1);
-        }), 128))
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Space/index.vue2.js

@@ -1,96 +0,0 @@
-import { defineComponent, useSlots, toRefs, computed, Fragment, Comment, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, renderSlot, createCommentVNode, renderList, createElementVNode, createBlock, resolveDynamicComponent } from "vue";
-import "../node_modules/tinycolor2/esm/tinycolor.js";
-import { valueToPx } from "../_shared/utils/dom.js";
-import { isNumber, isArray, isUndefined } from "../_shared/utils/is.js";
-import "../_shared/utils/time.js";
-import { getSlotFunction } from "../_shared/utils/vue-utils.js";
-import "../Empty/index.js";
-/* empty css                             */
-const _hoisted_1 = { class: "yc-space-item" };
-const _hoisted_2 = {
-  key: 0,
-  class: "yc-space-split"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Space"
-  },
-  __name: "index",
-  props: {
-    align: { default: void 0 },
-    direction: { default: "horizontal" },
-    wrap: { type: Boolean, default: false },
-    fill: { type: Boolean, default: false },
-    size: { default: "small" }
-  },
-  setup(__props) {
-    const slots = useSlots();
-    const props = __props;
-    const { size, direction, align: _align } = toRefs(props);
-    const gap = computed(() => {
-      const map = {
-        mini: 4,
-        small: 8,
-        medium: 16,
-        large: 24
-      };
-      if (isNumber(size.value)) {
-        return valueToPx(size.value);
-      } else if (isArray(size.value)) {
-        return size.value.map((v) => valueToPx(v)).join(" ");
-      } else {
-        return valueToPx(map[size.value]);
-      }
-    });
-    const align = computed(() => {
-      if (!isUndefined(_align.value)) {
-        return _align.value;
-      }
-      return direction.value == "horizontal" ? "center" : "start";
-    });
-    const nodes = computed(() => {
-      var _a;
-      if (!slots.split) return [];
-      const result = [];
-      (((_a = slots.default) == null ? void 0 : _a.call(slots)) || []).forEach((node) => {
-        if (node.type === Fragment) {
-          result.push(...node.children);
-        } else if (node.type !== Comment) {
-          result.push(node);
-        }
-      });
-      return result;
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-space",
-          `yc-space-align-${align.value}`,
-          `yc-space-direction-${unref(direction)}`,
-          {
-            "yc-space-wrap": _ctx.wrap,
-            "yc-space-fill": _ctx.fill
-          }
-        ]),
-        style: normalizeStyle({
-          gap: gap.value
-        })
-      }, [
-        !_ctx.$slots.split ? renderSlot(_ctx.$slots, "default", { key: 0 }, void 0, true) : createCommentVNode("", true),
-        (openBlock(true), createElementBlock(Fragment, null, renderList(nodes.value, (node, i) => {
-          return openBlock(), createElementBlock(Fragment, { key: i }, [
-            createElementVNode("div", _hoisted_1, [
-              (openBlock(), createBlock(resolveDynamicComponent(unref(getSlotFunction)(node))))
-            ]),
-            i < nodes.value.length - 1 ? (openBlock(), createElementBlock("div", _hoisted_2, [
-              renderSlot(_ctx.$slots, "split", {}, void 0, true)
-            ])) : createCommentVNode("", true)
-          ], 64);
-        }), 128))
-      ], 6);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Spin/index.vue2.js

@@ -1,89 +0,0 @@
-import { defineComponent, createElementBlock, openBlock, createVNode, createBlock, renderSlot, unref, withCtx, createCommentVNode, normalizeStyle, normalizeClass, Fragment, renderList, createElementVNode, resolveDynamicComponent, createTextVNode, toDisplayString, Transition } from "vue";
-import { createReusableTemplate } from "../node_modules/@vueuse/core/index.js";
-import "../node_modules/tinycolor2/esm/tinycolor.js";
-import { valueToPx } from "../_shared/utils/dom.js";
-import "../_shared/utils/time.js";
-import { getGlobalConfig } from "../_shared/utils/global-config.js";
-const _hoisted_1 = { class: "yc-spin" };
-const _hoisted_2 = {
-  key: 0,
-  class: "yc-dot-loading"
-};
-const _hoisted_3 = {
-  key: 1,
-  class: "yc-spin-tip"
-};
-const _hoisted_4 = {
-  key: 0,
-  class: "yc-spin-mask"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Spin"
-  },
-  __name: "index",
-  props: {
-    size: { default: 20 },
-    loading: { type: Boolean, default: false },
-    dot: { type: Boolean, default: false },
-    tip: { default: "" },
-    hideIcon: { type: Boolean, default: false },
-    isSizeInherit: { type: Boolean, default: false }
-  },
-  setup(__props) {
-    const { define: DefineTemplate, reuse: ReuseTemplate } = createReusableTemplate();
-    const { renderLoading } = getGlobalConfig();
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        createVNode(unref(DefineTemplate), null, {
-          default: withCtx(() => [
-            !_ctx.hideIcon ? (openBlock(), createElementBlock("div", {
-              key: 0,
-              class: normalizeClass([
-                "yc-spin-icon",
-                {
-                  "yc-spin-icon-loading": !_ctx.dot
-                }
-              ]),
-              style: normalizeStyle({
-                fontSize: !_ctx.isSizeInherit ? unref(valueToPx)(_ctx.size) : "inherit"
-              })
-            }, [
-              renderSlot(_ctx.$slots, "icon", {}, () => [
-                _ctx.dot ? (openBlock(), createElementBlock("div", _hoisted_2, [
-                  (openBlock(), createElementBlock(Fragment, null, renderList(5, (i) => {
-                    return createElementVNode("div", {
-                      key: i,
-                      class: "yc-dot-loading-item"
-                    });
-                  }), 64))
-                ])) : (openBlock(), createBlock(resolveDynamicComponent(unref(renderLoading)()), { key: 1 }))
-              ], true)
-            ], 6)) : createCommentVNode("", true),
-            _ctx.tip ? (openBlock(), createElementBlock("div", _hoisted_3, [
-              renderSlot(_ctx.$slots, "tip", {}, () => [
-                createTextVNode(toDisplayString(_ctx.tip), 1)
-              ], true)
-            ])) : createCommentVNode("", true)
-          ]),
-          _: 3
-        }),
-        !_ctx.$slots.default ? (openBlock(), createBlock(unref(ReuseTemplate), { key: 0 })) : (openBlock(), createBlock(Transition, {
-          key: 1,
-          name: "fade"
-        }, {
-          default: withCtx(() => [
-            _ctx.loading ? (openBlock(), createElementBlock("div", _hoisted_4, [
-              createVNode(unref(ReuseTemplate))
-            ])) : createCommentVNode("", true)
-          ]),
-          _: 1
-        })),
-        renderSlot(_ctx.$slots, "default", {}, void 0, true)
-      ]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};