yc-design-vue 1.7.6 → 1.7.8

package/es/Input/Input.vue2.js

@@ -1,232 +0,0 @@
-import { defineComponent, toRefs, ref, computed, createElementBlock, openBlock, normalizeClass, unref, createBlock, createCommentVNode, createElementVNode, withCtx, renderSlot, withDirectives, mergeProps, withKeys, vShow, createSlots } 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";
-import useControlValue from "../_shared/utils/control.js";
-import useLimitedInput from "./hooks/useLimitedInput.js";
-import IconButton from "../_shared/components/IconButton.vue2.js";
-import _sfc_main$1 from "../_shared/components/PreventFocus.vue.js";
-/* empty css                                         */
-/* empty css                             */
-import InputSuffix from "./InputSuffix.vue.js";
-const _hoisted_1 = ["value", "type", "disabled", "readonly", "placeholder"];
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "Input"
-  },
-  __name: "Input",
-  props: {
-    modelValue: { default: void 0 },
-    defaultValue: { default: "" },
-    size: { default: void 0 },
-    allowClear: { type: Boolean, default: false },
-    disabled: { type: Boolean, default: false },
-    readonly: { type: Boolean, default: false },
-    error: { type: Boolean, default: void 0 },
-    placeholder: { default: "" },
-    maxLength: { default: void 0 },
-    wordLength: { type: Function, default: (value) => {
-      return value.length;
-    } },
-    wordSlice: { type: Function, default: (value, maxLength) => {
-      return value.slice(0, maxLength);
-    } },
-    showWordLimit: { type: Boolean, default: false },
-    inputAttrs: { default: () => {
-      return {};
-    } },
-    isPassword: { type: Boolean, default: false },
-    visibility: { type: Boolean, default: void 0 },
-    defaultVisibility: { type: Boolean, default: false },
-    invisibleButton: { type: Boolean, default: true },
-    showInput: { type: Boolean, default: false }
-  },
-  emits: ["update:modelValue", "update:visibility", "input", "change", "visibility-change", "pressEnter", "keydown", "clear", "focus", "blur"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const { visibility, defaultVisibility } = toRefs(props);
-    const { size } = getGlobalConfig(props);
-    const inputRef = ref();
-    const computedVisibility = useControlValue(
-      visibility,
-      defaultVisibility.value,
-      (val) => {
-        emits("update:visibility", val);
-        emits("visibility-change", val);
-      }
-    );
-    const type = computed(() => {
-      return computedVisibility.value ? "password" : "text";
-    });
-    const {
-      computedValue,
-      showWordLimit,
-      showClearBtn,
-      curLength,
-      maxLength,
-      error,
-      handleInput,
-      handleComposition
-    } = useLimitedInput({
-      props,
-      emits,
-      inputRef
-    });
-    const handleEvent = async (type2, e) => {
-      switch (type2) {
-        case "input":
-          {
-            handleInput(e);
-          }
-          break;
-        case "change":
-          {
-            emits("change", computedValue.value, e);
-          }
-          break;
-        case "focus":
-        case "blur":
-          {
-            emits(type2, e);
-          }
-          break;
-        case "clear":
-          {
-            computedValue.value = "";
-            emits("clear", e);
-          }
-          break;
-        case "keydown":
-          {
-            const ev = e;
-            emits("keydown", ev);
-            ev.key == "Enter" && emits("pressEnter", ev);
-          }
-          break;
-      }
-    };
-    __expose({
-      focus() {
-        var _a;
-        (_a = inputRef.value) == null ? void 0 : _a.focus();
-      },
-      blur() {
-        var _a;
-        (_a = inputRef.value) == null ? void 0 : _a.blur();
-      },
-      getInputRef() {
-        return inputRef.value;
-      }
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        class: normalizeClass([
-          "yc-input-outer",
-          `yc-input-size-${unref(size)}`,
-          {
-            "yc-input-disabled": _ctx.disabled,
-            "yc-input-error": unref(error),
-            "yc-input-has-prepend": _ctx.$slots.prepend,
-            "yc-input-has-append": _ctx.$slots.append
-          }
-        ])
-      }, [
-        _ctx.$slots.prepend ? (openBlock(), createBlock(unref(_sfc_main$1), {
-          key: 0,
-          class: "yc-input-prepend"
-        }, {
-          default: withCtx(() => [
-            renderSlot(_ctx.$slots, "prepend", {}, void 0, true)
-          ]),
-          _: 3
-        })) : createCommentVNode("", true),
-        createElementVNode("div", {
-          class: normalizeClass(["yc-input-wrapper", { "yc-input-wrapper-disabled": _ctx.disabled }])
-        }, [
-          _ctx.$slots.prefix ? (openBlock(), createBlock(unref(_sfc_main$1), {
-            key: 0,
-            class: "yc-input-prefix"
-          }, {
-            default: withCtx(() => [
-              renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
-            ]),
-            _: 3
-          })) : createCommentVNode("", true),
-          withDirectives(createElementVNode("input", mergeProps({
-            value: unref(computedValue),
-            type: type.value,
-            disabled: _ctx.disabled,
-            readonly: _ctx.readonly,
-            placeholder: _ctx.placeholder
-          }, _ctx.inputAttrs, {
-            class: "yc-input",
-            ref_key: "inputRef",
-            ref: inputRef,
-            onInput: _cache[0] || (_cache[0] = ($event) => handleEvent("input", $event)),
-            onChange: _cache[1] || (_cache[1] = ($event) => handleEvent("change", $event)),
-            onCompositionstart: _cache[2] || (_cache[2] = //@ts-ignore
-            (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
-            onCompositionupdate: _cache[3] || (_cache[3] = //@ts-ignore
-            (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
-            onCompositionend: _cache[4] || (_cache[4] = //@ts-ignore
-            (...args) => unref(handleComposition) && unref(handleComposition)(...args)),
-            onFocus: _cache[5] || (_cache[5] = ($event) => handleEvent("focus", $event)),
-            onBlur: _cache[6] || (_cache[6] = ($event) => handleEvent("blur", $event)),
-            onKeydown: _cache[7] || (_cache[7] = withKeys(($event) => handleEvent("keydown", $event), ["enter"]))
-          }), null, 16, _hoisted_1), [
-            [vShow, !_ctx.$slots.label || _ctx.$slots.label && _ctx.showInput]
-          ]),
-          _ctx.$slots.label ? withDirectives((openBlock(), createBlock(unref(_sfc_main$1), {
-            key: 1,
-            class: "yc-input text-ellipsis"
-          }, {
-            default: withCtx(() => [
-              renderSlot(_ctx.$slots, "label", {}, void 0, true)
-            ]),
-            _: 3
-          }, 512)), [
-            [vShow, !_ctx.showInput]
-          ]) : createCommentVNode("", true),
-          unref(showClearBtn) ? (openBlock(), createBlock(unref(IconButton), {
-            key: 2,
-            class: "yc-input-clear-button",
-            onClick: _cache[8] || (_cache[8] = ($event) => handleEvent("clear", $event))
-          })) : createCommentVNode("", true),
-          _ctx.$slots.suffix || unref(showWordLimit) || _ctx.isPassword && _ctx.invisibleButton ? (openBlock(), createBlock(InputSuffix, {
-            key: 3,
-            "cur-length": unref(curLength),
-            "max-length": unref(maxLength),
-            "computed-value": unref(computedValue),
-            "show-word-limit": unref(showWordLimit),
-            "computed-visibility": unref(computedVisibility),
-            "invisible-button": _ctx.invisibleButton,
-            "is-password": _ctx.isPassword,
-            onVisibilityChange: _cache[9] || (_cache[9] = (v) => computedVisibility.value = v)
-          }, createSlots({ _: 2 }, [
-            _ctx.$slots.suffix ? {
-              name: "suffix",
-              fn: withCtx(() => [
-                renderSlot(_ctx.$slots, "suffix", {}, void 0, true)
-              ]),
-              key: "0"
-            } : void 0
-          ]), 1032, ["cur-length", "max-length", "computed-value", "show-word-limit", "computed-visibility", "invisible-button", "is-password"])) : createCommentVNode("", true)
-        ], 2),
-        _ctx.$slots.append ? (openBlock(), createBlock(unref(_sfc_main$1), {
-          key: 1,
-          class: "yc-input-append"
-        }, {
-          default: withCtx(() => [
-            renderSlot(_ctx.$slots, "append", {}, void 0, true)
-          ]),
-          _: 3
-        })) : createCommentVNode("", true)
-      ], 2);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/Input/InputSuffix.vue2.js

@@ -1,51 +0,0 @@
-import { defineComponent, createBlock, openBlock, unref, withCtx, createElementBlock, createCommentVNode, renderSlot, toDisplayString } from "vue";
-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$3 from "../_shared/icons/IconEyeClose.vue2.js";
-import _sfc_main$2 from "../_shared/icons/IconEyeOpen.vue2.js";
-import IconButton from "../_shared/components/IconButton.vue2.js";
-import _sfc_main$1 from "../_shared/components/PreventFocus.vue.js";
-/* empty css                                         */
-const _hoisted_1 = {
-  key: 0,
-  class: "yc-input-word-limit"
-};
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "InputSuffix",
-  props: {
-    curLength: {},
-    maxLength: {},
-    showWordLimit: { type: Boolean },
-    computedVisibility: { type: Boolean },
-    isPassword: { type: Boolean },
-    invisibleButton: { type: Boolean }
-  },
-  emits: ["clear", "visibilityChange"],
-  setup(__props) {
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(_sfc_main$1), { class: "yc-input-suffix" }, {
-        default: withCtx(() => [
-          _ctx.showWordLimit ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(_ctx.curLength) + "/" + toDisplayString(_ctx.maxLength), 1)) : createCommentVNode("", true),
-          _ctx.isPassword && _ctx.invisibleButton ? (openBlock(), createBlock(unref(IconButton), {
-            key: 1,
-            size: 14,
-            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("visibilityChange", !_ctx.computedVisibility))
-          }, {
-            default: withCtx(() => [
-              _ctx.computedVisibility ? (openBlock(), createBlock(unref(_sfc_main$2), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$3), { key: 1 }))
-            ]),
-            _: 1
-          })) : createCommentVNode("", true),
-          _ctx.$slots.suffix ? renderSlot(_ctx.$slots, "suffix", { key: 2 }, void 0, true) : createCommentVNode("", true)
-        ]),
-        _: 3
-      });
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/InputNumber/InputNumber.vue2.js

@@ -1,270 +0,0 @@
-import { defineComponent, toRefs, ref, computed, createBlock, openBlock, unref, createSlots, withCtx, renderSlot, createElementVNode, createVNode } from "vue";
-import "../node_modules/tinycolor2/esm/tinycolor.js";
-import { sleep } from "../_shared/utils/dom.js";
-import { isString, isFunction, isNumber } from "../_shared/utils/is.js";
-import "../_shared/utils/time.js";
-import "../Empty/index.js";
-/* empty css                             */
-import useControlValue from "../_shared/utils/control.js";
-import OperaBtn from "./InputOperaBtn.vue.js";
-import Input from "../Input/index.js";
-const _hoisted_1 = { class: "yc-input-number-step" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  ...{
-    name: "InputNumber"
-  },
-  __name: "InputNumber",
-  props: {
-    modelValue: { default: void 0 },
-    defaultValue: { default: "" },
-    mode: { default: "embed" },
-    precision: { default: 0 },
-    step: { default: 1 },
-    disabled: { type: Boolean, default: false },
-    error: { type: Boolean, default: false },
-    max: { default: Infinity },
-    min: { default: -Infinity },
-    placeholder: { default: "" },
-    hideButton: { type: Boolean, default: false },
-    size: { default: void 0 },
-    allowClear: { type: Boolean, default: false },
-    modelEvent: { default: "change" },
-    formatter: {},
-    parser: {},
-    readonly: { type: Boolean, default: false },
-    inputAttrs: { default: () => {
-      return {};
-    } }
-  },
-  emits: ["update:modelValue", "input", "change", "focus", "blur", "clear", "keydown", "pressEnter"],
-  setup(__props, { expose: __expose, emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const {
-      modelValue,
-      defaultValue,
-      step,
-      min,
-      max,
-      disabled,
-      hideButton,
-      mode,
-      modelEvent,
-      precision: _precision
-    } = toRefs(props);
-    const { formatter, parser } = props;
-    const inputRef = ref();
-    const computedValue = useControlValue(
-      modelValue,
-      defaultValue.value,
-      (val) => {
-        emits(
-          "update:modelValue",
-          modelEvent.value == "change" ? val : handlePrecision(val, "number")
-        );
-      },
-      (val) => {
-        const value = isString(val) ? val : handlePrecision(val, "string");
-        return formatter && isFunction(formatter) ? formatter(value) : value;
-      }
-    );
-    const precision = computed(() => {
-      var _a, _b;
-      const stepPrecision = ((_b = (_a = String(step.value).match(/\.(\d+)/)) == null ? void 0 : _a[1]) == null ? void 0 : _b.length) ?? 0;
-      return Math.max(...[stepPrecision, _precision.value]);
-    });
-    const parserValue = (v) => {
-      return parser && isFunction(parser) ? parser(v) : v;
-    };
-    function handlePrecision(value, type) {
-      const handleValue = isNumber(value) ? value : +value;
-      const numberValue = precision.value ? handleValue.toFixed(precision.value) : handleValue.toFixed(0);
-      return type == "number" ? +numberValue : numberValue;
-    }
-    const handleStep = (type) => {
-      var _a;
-      const handleValue = +parserValue(computedValue.value);
-      let value = type == "minus" ? handleValue - step.value : handleValue + step.value;
-      value = value < min.value ? min.value : value;
-      value = value > max.value ? max.value : value;
-      computedValue.value = handlePrecision(value, "number");
-      (_a = inputRef.value) == null ? void 0 : _a.focus();
-    };
-    const handleUpdateValue = (type, e) => {
-      if (type == "blur") {
-        emits("blur", e);
-      } else {
-        emits("pressEnter", e);
-      }
-      if (!computedValue.value) return;
-      let value = +parserValue(computedValue.value);
-      value = value < min.value ? min.value : value;
-      value = value > max.value ? max.value : value;
-      computedValue.value = handlePrecision(value, "number");
-    };
-    const handleInput = (v, e) => {
-      var _a;
-      if (!v) {
-        computedValue.value = v;
-        return;
-      }
-      const handleValue = parserValue(v);
-      const isInValidNumber = !/^-?\d*\.?\d*$/.test(handleValue);
-      const isInValidPoint = (((_a = handleValue.match(/\./g)) == null ? void 0 : _a.length) ?? 0) > 1;
-      const isInValidNegative = handleValue.includes("-") && handleValue[0] != "-";
-      if (isInValidNumber || isInValidPoint || isInValidNegative) {
-        return;
-      }
-      computedValue.value = handleValue;
-      emits("input", handleValue, e);
-    };
-    const handleClear = (ev) => {
-      computedValue.value = "";
-      emits("clear", ev);
-    };
-    __expose({
-      focus() {
-        var _a;
-        (_a = inputRef.value) == null ? void 0 : _a.focus();
-      },
-      blur() {
-        var _a;
-        (_a = inputRef.value) == null ? void 0 : _a.focus();
-      }
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(Input), {
-        "model-value": unref(computedValue),
-        "allow-clear": _ctx.allowClear,
-        disabled: unref(disabled),
-        readonly: _ctx.readonly,
-        error: _ctx.error,
-        size: _ctx.size,
-        placeholder: _ctx.placeholder,
-        "input-attrs": _ctx.inputAttrs,
-        class: "yc-input-number",
-        ref_key: "inputRef",
-        ref: inputRef,
-        onInput: handleInput,
-        onChange: _cache[0] || (_cache[0] = async (v, ev) => {
-          await unref(sleep)(0);
-          _ctx.$emit("change", +v, ev);
-        }),
-        onClear: handleClear,
-        onFocus: _cache[1] || (_cache[1] = (ev) => _ctx.$emit("focus", ev)),
-        onBlur: _cache[2] || (_cache[2] = (ev) => handleUpdateValue("blur", ev)),
-        onKeydown: _cache[3] || (_cache[3] = (ev) => _ctx.$emit("keydown", ev)),
-        onPressEnter: _cache[4] || (_cache[4] = (ev) => handleUpdateValue("pressEnter", ev))
-      }, createSlots({ _: 2 }, [
-        _ctx.$slots.prefix ? {
-          name: "prefix",
-          fn: withCtx(() => [
-            renderSlot(_ctx.$slots, "prefix", {}, void 0, true)
-          ]),
-          key: "0"
-        } : void 0,
-        _ctx.$slots.suffix || !unref(hideButton) && unref(mode) == "embed" ? {
-          name: "suffix",
-          fn: withCtx(() => [
-            renderSlot(_ctx.$slots, "suffix", {}, () => [
-              createElementVNode("div", _hoisted_1, [
-                createVNode(OperaBtn, {
-                  type: "plus",
-                  mode: unref(mode),
-                  "computed-value": unref(computedValue),
-                  disabled: unref(disabled),
-                  min: unref(min),
-                  max: unref(max),
-                  size: _ctx.size,
-                  onClick: handleStep
-                }, createSlots({ _: 2 }, [
-                  _ctx.$slots.minus ? {
-                    name: "icon",
-                    fn: withCtx(() => [
-                      renderSlot(_ctx.$slots, "plus", {}, void 0, true)
-                    ]),
-                    key: "0"
-                  } : void 0
-                ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"]),
-                createVNode(OperaBtn, {
-                  type: "minus",
-                  mode: unref(mode),
-                  "computed-value": unref(computedValue),
-                  disabled: unref(disabled),
-                  min: unref(min),
-                  max: unref(max),
-                  size: _ctx.size,
-                  onClick: handleStep
-                }, createSlots({ _: 2 }, [
-                  _ctx.$slots.plus ? {
-                    name: "icon",
-                    fn: withCtx(() => [
-                      renderSlot(_ctx.$slots, "minus", {}, void 0, true)
-                    ]),
-                    key: "0"
-                  } : void 0
-                ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"])
-              ])
-            ], true)
-          ]),
-          key: "1"
-        } : void 0,
-        _ctx.$slots.prepend || !unref(hideButton) && unref(mode) == "button" ? {
-          name: "prepend",
-          fn: withCtx(() => [
-            renderSlot(_ctx.$slots, "prepend", {}, () => [
-              createVNode(OperaBtn, {
-                type: "minus",
-                mode: unref(mode),
-                "computed-value": unref(computedValue),
-                disabled: unref(disabled),
-                min: unref(min),
-                max: unref(max),
-                size: _ctx.size,
-                onClick: handleStep
-              }, createSlots({ _: 2 }, [
-                _ctx.$slots.minus ? {
-                  name: "icon",
-                  fn: withCtx(() => [
-                    renderSlot(_ctx.$slots, "minus", {}, void 0, true)
-                  ]),
-                  key: "0"
-                } : void 0
-              ]), 1032, ["mode", "computed-value", "disabled", "min", "max", "size"])
-            ], true)
-          ]),
-          key: "2"
-        } : void 0,
-        _ctx.$slots.append || !unref(hideButton) && unref(mode) == "button" ? {
-          name: "append",
-          fn: withCtx(() => [
-            renderSlot(_ctx.$slots, "append", {}, () => [
-              createVNode(OperaBtn, {
-                type: "plus",
-                mode: unref(mode),
-                "computed-value": unref(computedValue),
-                disabled: unref(disabled),
-                max: unref(max),
-                min: unref(min),
-                size: _ctx.size,
-                onClick: handleStep
-              }, createSlots({ _: 2 }, [
-                _ctx.$slots.plus ? {
-                  name: "icon",
-                  fn: withCtx(() => [
-                    renderSlot(_ctx.$slots, "plus", {}, void 0, true)
-                  ]),
-                  key: "0"
-                } : void 0
-              ]), 1032, ["mode", "computed-value", "disabled", "max", "min", "size"])
-            ], true)
-          ]),
-          key: "3"
-        } : void 0
-      ]), 1032, ["model-value", "allow-clear", "disabled", "readonly", "error", "size", "placeholder", "input-attrs"]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};

package/es/InputNumber/InputOperaBtn.vue2.js

@@ -1,58 +0,0 @@
-import { defineComponent, toRefs, computed, createBlock, openBlock, unref, normalizeClass, withCtx, renderSlot, createElementBlock, Fragment } from "vue";
-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/icons/IconMinus.vue2.js";
-import _sfc_main$3 from "../_shared/icons/IconPlus.vue.js";
-import Button from "../Button/index.js";
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "InputOperaBtn",
-  props: {
-    mode: {},
-    type: {},
-    disabled: { type: Boolean },
-    computedValue: {},
-    min: {},
-    max: {},
-    size: {}
-  },
-  emits: ["click"],
-  setup(__props) {
-    const props = __props;
-    const { disabled: _disabled, computedValue, min, max, type } = toRefs(props);
-    const disabled = computed(() => {
-      if (_disabled.value) return _disabled.value;
-      return type.value == "minus" ? +computedValue.value <= min.value : +computedValue.value >= max.value;
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(Button), {
-        size: _ctx.size,
-        disabled: disabled.value,
-        class: normalizeClass([
-          {
-            "yc-input-number-plus-embed": _ctx.mode == "embed"
-          }
-        ]),
-        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", unref(type)))
-      }, {
-        icon: withCtx(() => [
-          renderSlot(_ctx.$slots, "icon", {}, () => [
-            _ctx.mode == "embed" ? (openBlock(), createBlock(unref(_sfc_main$1), {
-              key: 0,
-              rotate: unref(type) == "plus" ? 180 : 0
-            }, null, 8, ["rotate"])) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [
-              unref(type) == "minus" ? (openBlock(), createBlock(unref(_sfc_main$2), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$3), { key: 1 }))
-            ], 64))
-          ], true)
-        ]),
-        _: 3
-      }, 8, ["size", "disabled", "class"]);
-    };
-  }
-});
-export {
-  _sfc_main as default
-};