yc-design-vue 1.7.5 → 1.7.7

package/es/Checkbox/Checkbox.vue2.js

@@ -1,115 +0,0 @@
-import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeClass, createElementVNode, renderSlot, createVNode, createCommentVNode, unref, withCtx } from "vue";
-import "../node_modules/tinycolor2/esm/tinycolor.js";
-import "../_shared/utils/dom.js";
-import { isUndefined } from "../_shared/utils/is.js";
-import "../_shared/utils/time.js";
-import "../Empty/index.js";
-/* empty css                             */
-import _sfc_main$1 from "../_shared/icons/IconCheckboxChecked.vue.js";
-import useControlValue from "../_shared/utils/control.js";
-import useContext from "./hooks/useContext.js";
-import IconButton from "../_shared/components/IconButton.vue.js";
-/* empty css                                         */
-const _hoisted_1 = ["value", "disabled", "checked"];
-const _hoisted_2 = { class: "yc-checkbox-icon" };
-const _hoisted_3 = {
-  key: 0,
-  class: "yc-checkbox-label text-ellipsis"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Checkbox"
-  },
-  __name: "Checkbox",
-  props: {
-    modelValue: { type: Boolean, default: void 0 },
-    defaultChecked: { type: Boolean, default: false },
-    disabled: { type: Boolean, default: false },
-    value: { type: [String, Number, Boolean], default: "" },
-    indeterminate: { type: Boolean, default: false }
-  },
-  emits: ["update:modelValue", "change"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const {
-      modelValue,
-      defaultChecked,
-      value: checkboxValue,
-      disabled
-    } = toRefs(props);
-    const {
-      computedValue,
-      max,
-      hasGroup,
-      disabled: injectDisabled
-    } = useContext().inject();
-    const checked = useControlValue(
-      modelValue,
-      defaultChecked.value,
-      (val) => {
-        emits("update:modelValue", val);
-      }
-    );
-    const computedChecked = computed(() => {
-      return hasGroup.value ? computedValue.value.includes(checkboxValue.value) : checked.value;
-    });
-    const computedDisabled = computed(() => {
-      return disabled.value || injectDisabled.value || !isUndefined(max.value) && !computedChecked.value && computedValue.value.length >= max.value;
-    });
-    const handleCollect = (e) => {
-      var _a;
-      if (!hasGroup.value) {
-        const curChecked = (_a = e.target) == null ? void 0 : _a.checked;
-        checked.value = curChecked;
-        emits("change", curChecked, e);
-      } else {
-        computedValue.value = computedChecked.value ? computedValue.value.filter((item) => item != checkboxValue.value) : [...computedValue.value, checkboxValue.value];
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("label", {
-        class: normalizeClass([
-          "yc-checkbox",
-          {
-            "yc-checkbox-disabled": computedDisabled.value,
-            "yc-checkbox-unchecked": !computedChecked.value && !_ctx.indeterminate,
-            "yc-checkbox-indeterminate": !computedChecked.value && _ctx.indeterminate,
-            "yc-checkbox-checked": computedChecked.value
-          }
-        ])
-      }, [
-        createElementVNode("input", {
-          type: "checkbox",
-          class: "yc-checkbox-target",
-          value: _ctx.value,
-          disabled: computedDisabled.value,
-          checked: computedChecked.value,
-          onChange: handleCollect
-        }, null, 40, _hoisted_1),
-        renderSlot(_ctx.$slots, "checkbox", {
-          checked: computedChecked.value,
-          disabled: computedDisabled.value
-        }, () => [
-          createVNode(unref(IconButton), {
-            "hover-size": 24,
-            hoverable: !computedChecked.value && !computedDisabled.value
-          }, {
-            default: withCtx(() => [
-              createElementVNode("span", _hoisted_2, [
-                createVNode(unref(_sfc_main$1), { size: [8, 10] })
-              ])
-            ]),
-            _: 1
-          }, 8, ["hoverable"]),
-          _ctx.$slots.default ? (openBlock(), createElementBlock("span", _hoisted_3, [
-            renderSlot(_ctx.$slots, "default", {}, void 0, true)
-          ])) : createCommentVNode("", true)
-        ], true)
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Collapse/Collapse.vue2.js

@@ -1,38 +0,0 @@
-import { defineComponent, createElementBlock, openBlock, normalizeClass, renderSlot } from "vue";
-import useContext from "./hooks/useContext.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Collapse"
-  },
-  __name: "Collapse",
-  props: {
-    activeKey: { default: void 0 },
-    defaultActiveKey: { default: () => [] },
-    accordion: { type: Boolean, default: false },
-    showExpandIcon: { type: Boolean, default: true },
-    expandIconPosition: { default: "left" },
-    bordered: { type: Boolean, default: true },
-    destroyOnHide: { type: Boolean, default: false }
-  },
-  emits: ["update:activekey", "change"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    useContext().provide(props, emits);
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-collapse",
-          {
-            "yc-collapse-bordered": _ctx.bordered
-          }
-        ])
-      }, [
-        renderSlot(_ctx.$slots, "default", {}, void 0, true)
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Collapse/CollapseItem.vue2.js

@@ -1,130 +0,0 @@
-import { defineComponent, toRefs, createElementBlock, openBlock, normalizeClass, unref, createElementVNode, createVNode, createBlock, createCommentVNode, withCtx, renderSlot, resolveDynamicComponent, createTextVNode, toDisplayString, withDirectives, vShow } from "vue";
-import useContext from "./hooks/useContext.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$1 from "../_shared/icons/IconRight.vue.js";
-import IconButton from "../_shared/components/IconButton.vue.js";
-import ExpandTransition from "../_shared/components/ExpandTransition.vue2.js";
-const _hoisted_1 = { class: "yc-collapse-item-header-title text-ellipsis" };
-const _hoisted_2 = {
-  key: 1,
-  class: "yc-collapse-item-header-extra"
-};
-const _hoisted_3 = {
-  key: 0,
-  role: "region",
-  class: "yc-collapse-item-content"
-};
-const _hoisted_4 = { class: "yc-collapse-item-content-box" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "CollapseItem"
-  },
-  __name: "CollapseItem",
-  props: {
-    path: { default: "" },
-    header: { default: "" },
-    disabled: { type: Boolean, default: false },
-    showExpandIcon: { type: Boolean, default: void 0 },
-    destroyOnHide: { type: Boolean, default: void 0 }
-  },
-  setup(__props) {
-    const props = __props;
-    const { path, disabled } = toRefs(props);
-    const {
-      slots,
-      computedActiveKey,
-      accordion,
-      expandIconPosition,
-      showExpandIcon,
-      destroyOnHide
-    } = useContext().inject(props);
-    const handleClick = () => {
-      if (disabled.value) return;
-      if (computedActiveKey.value.includes(path.value)) {
-        computedActiveKey.value = computedActiveKey.value.filter(
-          (item) => item != path.value
-        );
-      } else {
-        if (accordion.value) {
-          computedActiveKey.value = [path.value];
-        } else {
-          computedActiveKey.value.push(path.value);
-        }
-      }
-    };
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-collapse-item",
-          `yc-collapse-item-expand-icon-${unref(expandIconPosition)}`,
-          {
-            "yc-collapse-item-disabled": unref(disabled),
-            "yc-collapse-item-open": unref(computedActiveKey).includes(unref(path))
-          }
-        ])
-      }, [
-        createElementVNode("div", {
-          role: "button",
-          class: "yc-collapse-item-header",
-          onClick: handleClick
-        }, [
-          unref(showExpandIcon) ? (openBlock(), createBlock(unref(IconButton), {
-            key: 0,
-            class: "yc-collapse-item-header-icon"
-          }, {
-            default: withCtx(() => [
-              renderSlot(_ctx.$slots, "expand-icon", {
-                active: unref(computedActiveKey).includes(unref(path)),
-                disabled: unref(disabled),
-                position: unref(expandIconPosition)
-              }, () => [
-                unref(slots)["expand-icon"] ? (openBlock(), createBlock(resolveDynamicComponent(
-                  () => {
-                    var _a, _b;
-                    return (_b = (_a = unref(slots))["expand-icon"]) == null ? void 0 : _b.call(_a, {
-                      active: unref(computedActiveKey).includes(unref(path)),
-                      disabled: unref(disabled),
-                      position: unref(expandIconPosition)
-                    });
-                  }
-                ), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$1), {
-                  key: 1,
-                  color: "rgb(107, 119, 133)",
-                  rotate: unref(computedActiveKey).includes(unref(path)) ? 90 : unref(expandIconPosition) == "left" ? 0 : 180
-                }, null, 8, ["rotate"]))
-              ], true)
-            ]),
-            _: 3
-          })) : createCommentVNode("", true),
-          createElementVNode("div", _hoisted_1, [
-            renderSlot(_ctx.$slots, "header", {}, () => [
-              createTextVNode(toDisplayString(_ctx.header), 1)
-            ], true)
-          ]),
-          _ctx.$slots.extra ? (openBlock(), createElementBlock("div", _hoisted_2, [
-            renderSlot(_ctx.$slots, "extra", {}, void 0, true)
-          ])) : createCommentVNode("", true)
-        ]),
-        createVNode(unref(ExpandTransition), null, {
-          default: withCtx(() => [
-            !unref(destroyOnHide) || unref(computedActiveKey).includes(unref(path)) ? withDirectives((openBlock(), createElementBlock("div", _hoisted_3, [
-              createElementVNode("div", _hoisted_4, [
-                renderSlot(_ctx.$slots, "default", {}, void 0, true)
-              ])
-            ], 512)), [
-              [vShow, unref(computedActiveKey).includes(unref(path))]
-            ]) : createCommentVNode("", true)
-          ]),
-          _: 3
-        })
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/ColorPicker/ColorControl.vue2.js

@@ -1,112 +0,0 @@
-import { defineComponent, toRefs, ref, watch, createElementBlock, openBlock, normalizeStyle, unref, createElementVNode } from "vue";
-import { useDraggable } from "../node_modules/@vueuse/core/index.js";
-import { parseColor, GradientColorCalculator } from "../_shared/utils/color.js";
-import { sleep, valueToPx } from "../_shared/utils/dom.js";
-import "../_shared/utils/time.js";
-import "../Empty/index.js";
-/* empty css                             */
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ColorControl",
-  props: {
-    color: {},
-    baseColor: {},
-    popupVisible: { type: Boolean },
-    disabled: { type: Boolean },
-    hideTrigger: { type: Boolean },
-    mode: {}
-  },
-  emits: ["update:color", "update:alpha", "update:baseColor", "change"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { color, mode, popupVisible, disabled, hideTrigger } = toRefs(props);
-    const btnRef = ref();
-    const barRef = ref();
-    const range = ref({
-      min: 0,
-      max: 0
-    });
-    const calculator = new GradientColorCalculator();
-    const { x } = useDraggable(btnRef, {
-      disabled,
-      onMove() {
-        setColor();
-      }
-    });
-    const setPosition = (color2) => {
-      const { max, min } = range.value;
-      if (mode.value == "alpha") {
-        const alpha = parseColor(color2).getAlpha() * 100;
-        x.value = min + alpha / 100 * (max - min);
-        emits("update:alpha", alpha);
-      } else {
-        x.value = calculator.getPositionForColor(color2, max - min) + min;
-      }
-    };
-    const setColor = () => {
-      const { min, max } = range.value;
-      x.value = x.value < min ? min : x.value;
-      x.value = x.value > max ? max : x.value;
-      let tempColor = "";
-      if (mode.value == "alpha") {
-        const a = +((x.value - min) / (max - min)).toFixed(2);
-        tempColor = parseColor(color.value).setAlpha(a).toRgbString();
-        emits("update:alpha", a);
-      } else {
-        tempColor = calculator.getColorAtPosition(x.value - min, max - min);
-        emits("update:baseColor", tempColor);
-        emits("change", tempColor);
-      }
-      emits("update:color", tempColor);
-    };
-    const handleClick = (e) => {
-      if (disabled.value) return;
-      x.value = e.pageX;
-      setColor();
-    };
-    watch(
-      () => popupVisible.value,
-      async (val) => {
-        if (val || hideTrigger.value) {
-          await sleep(0);
-          const { left, right } = barRef.value.getBoundingClientRect();
-          range.value = {
-            min: left,
-            max: right
-          };
-          setPosition(color.value);
-        }
-      },
-      {
-        immediate: true
-      }
-    );
-    __expose({
-      setPosition
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: "yc-color-picker-control-bar",
-        style: normalizeStyle({
-          background: unref(mode) == "alpha" ? `linear-gradient(to right, rgba(0, 0, 0, 0), ${_ctx.baseColor})` : ""
-        }),
-        ref_key: "barRef",
-        ref: barRef,
-        onClick: handleClick
-      }, [
-        createElementVNode("div", {
-          class: "yc-color-picker-control-bar-handler",
-          style: normalizeStyle({
-            color: unref(color),
-            transform: `translate(calc(${unref(valueToPx)(unref(x) - range.value.min)} - 50%),-50%)`
-          }),
-          ref_key: "btnRef",
-          ref: btnRef
-        }, null, 4)
-      ], 4);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/ColorPicker/ColorInput.vue2.js

@@ -1,161 +0,0 @@
-import { defineComponent, toRefs, ref, watch, createElementBlock, openBlock, createElementVNode, createVNode, unref, createBlock, createCommentVNode, withCtx, createTextVNode, Fragment } from "vue";
-import { parseColor } from "../_shared/utils/color.js";
-import "../_shared/utils/dom.js";
-import "../_shared/utils/time.js";
-import "../Empty/index.js";
-/* empty css                             */
-import { COLOR_PICKER_FORMAT_OPTIONS } from "../_shared/constants/index.js";
-import Select from "../Select/index.js";
-import Input from "../Input/index.js";
-import InputNumber from "../InputNumber/index.js";
-const _hoisted_1 = { class: "yc-color-picker-input-wrapper" };
-const _hoisted_2 = { class: "yc-color-picker-format" };
-const _hoisted_3 = { class: "yc-color-picker-color" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ColorInput",
-  props: {
-    color: {},
-    baseColor: {},
-    alpha: {},
-    disabled: { type: Boolean },
-    disabledAlpha: { type: Boolean }
-  },
-  emits: ["update:color", "update:baseColor", "update:alpha", "change"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { color, alpha: _alpha } = toRefs(props);
-    const format = ref("hex");
-    const hex = ref("");
-    const rgb = ref({});
-    const alpha = ref(_alpha.value);
-    const handleSet = (type) => {
-      if (type == "hex") {
-        const a = parseColor(color.value).getAlpha();
-        const resultColor = parseColor(hex.value).setAlpha(a).toHex8();
-        emits("update:color", resultColor);
-        emits("update:baseColor", resultColor);
-        emits("change", resultColor, "color");
-      } else if (type == "rgb") {
-        const { r, g, b } = rgb.value;
-        const resultColor = `rgb(${r},${g},${b})`;
-        emits("update:color", resultColor);
-        emits("update:baseColor", resultColor);
-        emits("change", resultColor, "color");
-      } else {
-        const a = +(alpha.value / 100).toFixed(2);
-        const resultColor = parseColor(color.value).setAlpha(a).toRgbString();
-        emits("update:color", resultColor);
-        emits("update:alpha", alpha.value);
-        emits("change", resultColor, "alpha");
-      }
-    };
-    watch(
-      () => color.value,
-      () => {
-        hex.value = parseColor(color.value).toHex();
-        rgb.value = parseColor(color.value).toRgb();
-      },
-      {
-        immediate: true
-      }
-    );
-    watch(
-      () => _alpha.value,
-      () => {
-        alpha.value = _alpha.value * 100;
-      }
-    );
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        createElementVNode("div", _hoisted_2, [
-          createVNode(unref(Select), {
-            modelValue: format.value,
-            "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => format.value = $event),
-            options: unref(COLOR_PICKER_FORMAT_OPTIONS),
-            "trigger-props": {
-              contentClass: "yc-color-picker-format-popup-content"
-            },
-            size: "mini"
-          }, null, 8, ["modelValue", "options"])
-        ]),
-        createElementVNode("div", _hoisted_3, [
-          format.value == "hex" ? (openBlock(), createBlock(unref(Input), {
-            key: 0,
-            modelValue: hex.value,
-            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => hex.value = $event),
-            "max-length": 6,
-            disabled: _ctx.disabled,
-            size: "mini",
-            class: "hex-input",
-            onBlur: _cache[2] || (_cache[2] = ($event) => handleSet("hex")),
-            onPressEnter: _cache[3] || (_cache[3] = ($event) => handleSet("hex"))
-          }, {
-            prefix: withCtx(() => _cache[16] || (_cache[16] = [
-              createTextVNode(" # ", -1)
-            ])),
-            _: 1
-          }, 8, ["modelValue", "disabled"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
-            createVNode(unref(InputNumber), {
-              modelValue: rgb.value.r,
-              "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => rgb.value.r = $event),
-              min: 0,
-              max: 255,
-              disabled: _ctx.disabled,
-              size: "mini",
-              class: "rgb-input",
-              "hide-button": "",
-              onBlur: _cache[5] || (_cache[5] = ($event) => handleSet("rgb")),
-              onPressEnter: _cache[6] || (_cache[6] = ($event) => handleSet("rgb"))
-            }, null, 8, ["modelValue", "disabled"]),
-            createVNode(unref(InputNumber), {
-              modelValue: rgb.value.g,
-              "onUpdate:modelValue": _cache[7] || (_cache[7] = ($event) => rgb.value.g = $event),
-              min: 0,
-              max: 255,
-              disabled: _ctx.disabled,
-              size: "mini",
-              class: "rgb-input",
-              "hide-button": "",
-              onBlur: _cache[8] || (_cache[8] = ($event) => handleSet("rgb")),
-              onPressEnter: _cache[9] || (_cache[9] = ($event) => handleSet("rgb"))
-            }, null, 8, ["modelValue", "disabled"]),
-            createVNode(unref(InputNumber), {
-              modelValue: rgb.value.b,
-              "onUpdate:modelValue": _cache[10] || (_cache[10] = ($event) => rgb.value.b = $event),
-              min: 0,
-              max: 255,
-              disabled: _ctx.disabled,
-              class: "rgb-input",
-              size: "mini",
-              "hide-button": "",
-              onBlur: _cache[11] || (_cache[11] = ($event) => handleSet("rgb")),
-              onPressEnter: _cache[12] || (_cache[12] = ($event) => handleSet("rgb"))
-            }, null, 8, ["modelValue", "disabled"])
-          ], 64)),
-          !_ctx.disabledAlpha ? (openBlock(), createBlock(unref(InputNumber), {
-            key: 2,
-            modelValue: alpha.value,
-            "onUpdate:modelValue": _cache[13] || (_cache[13] = ($event) => alpha.value = $event),
-            min: 0,
-            max: 100,
-            disabled: _ctx.disabled,
-            size: "mini",
-            "hide-button": "",
-            class: "alpha-input",
-            onBlur: _cache[14] || (_cache[14] = ($event) => handleSet("alpha")),
-            onPressEnter: _cache[15] || (_cache[15] = ($event) => handleSet("alpha"))
-          }, {
-            suffix: withCtx(() => _cache[17] || (_cache[17] = [
-              createTextVNode(" % ", -1)
-            ])),
-            _: 1
-          }, 8, ["modelValue", "disabled"])) : createCommentVNode("", true)
-        ])
-      ]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/ColorPicker/ColorList.vue2.js

@@ -1,47 +0,0 @@
-import { defineComponent, createElementBlock, openBlock, createElementVNode, createCommentVNode, toDisplayString, Fragment, renderList, normalizeStyle } from "vue";
-const _hoisted_1 = { class: "yc-color-picker-colors-section" };
-const _hoisted_2 = { class: "yc-color-picker-colors-text" };
-const _hoisted_3 = {
-  key: 0,
-  class: "yc-color-picker-colors-empty"
-};
-const _hoisted_4 = { class: "yc-color-picker-colors-list" };
-const _hoisted_5 = ["onClick"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "ColorList",
-  props: {
-    label: {},
-    colors: {}
-  },
-  emits: ["colorClick"],
-  setup(__props) {
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        createElementVNode("div", _hoisted_2, toDisplayString(_ctx.label), 1),
-        !_ctx.colors.length ? (openBlock(), createElementBlock("div", _hoisted_3, "暂无")) : createCommentVNode("", true),
-        createElementVNode("div", _hoisted_4, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.colors, (color, index) => {
-            return openBlock(), createElementBlock("div", {
-              key: index,
-              class: "yc-color-picker-color-block",
-              style: normalizeStyle({
-                backgroundColor: color
-              }),
-              onClick: ($event) => _ctx.$emit("colorClick", color)
-            }, [
-              createElementVNode("div", {
-                class: "yc-color-picker-block",
-                style: normalizeStyle({
-                  backgroundColor: color
-                })
-              }, null, 4)
-            ], 12, _hoisted_5);
-          }), 128))
-        ])
-      ]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};