yc-design-vue 1.0.1

package/es/AutoComplete/index.vue.js

@@ -0,0 +1,202 @@
+import { defineComponent, toRefs, ref, createBlock, openBlock, unref, createSlots, withCtx, renderSlot, mergeProps, isRef, normalizeProps, guardReactiveProps, nextTick } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { isObject } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useControlValue from "../_shared/utils/control.js";
+import Select from "../Select/index.js";
+import Textarea from "../Textarea/index.js";
+import Input from "../Input/index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "AutoComplete"
+  },
+  __name: "index",
+  props: {
+    modelValue: { default: void 0 },
+    defaultValue: { default: "" },
+    disabled: { type: Boolean, default: false },
+    data: { default: () => [] },
+    popupContainer: { default: void 0 },
+    strict: { type: Boolean, default: false },
+    filterOption: { type: Function, default: void 0 },
+    triggerProps: { default: () => {
+      return {};
+    } },
+    allowClear: { type: Boolean, default: true },
+    vistualListProps: {},
+    isSelectSetValue: { type: Boolean, default: true },
+    isSearch: { type: Boolean, default: true },
+    type: { default: "input" }
+  },
+  emits: ["update:modelValue", "change", "search", "select", "clear", "dropdown-scroll", "dropdown-reach-bottom", "blur", "focus", "input", "keydown"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { modelValue, defaultValue, data, strict, isSelectSetValue, isSearch } = toRefs(props);
+    const { filterOption } = props;
+    const inputRef = ref();
+    const selectRef = ref();
+    const popupVisible = ref(false);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits("update:modelValue", val);
+      }
+    );
+    const curOptions = ref([]);
+    const defaultFilter = (inputValue, option) => {
+      const labelValue = option.label;
+      const label = strict.value ? labelValue : labelValue.toLowerCase();
+      const value = strict.value ? inputValue : inputValue.toLowerCase();
+      return label == null ? void 0 : label.includes(value);
+    };
+    const handleEvent = async (type, ev, value = "") => {
+      switch (type) {
+        case "input":
+          {
+            emits("input", value, ev);
+            emits("search", value);
+            const oldOptions = [...data.value];
+            await nextTick();
+            if (JSON.stringify(oldOptions) == JSON.stringify(data.value) && isSearch.value) {
+              curOptions.value = data.value.filter((v) => {
+                const option = isObject(v) ? v : { label: v, value: v };
+                return (filterOption == null ? void 0 : filterOption(value, option)) ?? defaultFilter(value, option);
+              });
+            } else {
+              curOptions.value = data.value;
+            }
+            popupVisible.value = !!curOptions.value.length;
+          }
+          break;
+        case "select":
+          {
+            popupVisible.value = false;
+            if (isSelectSetValue.value) {
+              computedValue.value = value;
+            }
+            emits("select", value);
+          }
+          break;
+        case "focus":
+          {
+            popupVisible.value = !!curOptions.value.length;
+            emits("focus", ev);
+          }
+          break;
+        case "blur":
+          {
+            popupVisible.value = false;
+            emits("blur", ev);
+          }
+          break;
+        case "clear":
+          {
+            computedValue.value = "";
+            emits("clear", 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() {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.getInputRef();
+      },
+      getMirrorRef() {
+        var _a;
+        return (_a = inputRef.value) == null ? void 0 : _a.getMirrorRef();
+      },
+      updatePosition(x, y) {
+        var _a, _b;
+        (_b = (_a = selectRef.value) == null ? void 0 : _a.getPopupRef()) == null ? void 0 : _b.updatePosition(x, y);
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Select), {
+        "popup-visible": popupVisible.value,
+        options: curOptions.value,
+        "popup-container": _ctx.popupContainer,
+        "trigger-props": _ctx.triggerProps,
+        "virtual-list-props": _ctx.vistualListProps,
+        "show-empty": false,
+        hotkeys: "",
+        ref_key: "selectRef",
+        ref: selectRef,
+        class: "yc-auto-complete",
+        onDropdownScroll: _cache[14] || (_cache[14] = (ev) => _ctx.$emit("dropdown-scroll", ev)),
+        onDropdownReachBottom: _cache[15] || (_cache[15] = (ev) => _ctx.$emit("dropdown-reach-bottom", ev)),
+        onSelect: _cache[16] || (_cache[16] = (v) => handleEvent("select", null, v))
+      }, createSlots({
+        trigger: withCtx(() => [
+          renderSlot(_ctx.$slots, "trigger", {}, () => [
+            _ctx.type == "input" ? (openBlock(), createBlock(unref(Input), mergeProps({
+              key: 0,
+              modelValue: unref(computedValue),
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => isRef(computedValue) ? computedValue.value = $event : null),
+              disabled: _ctx.disabled,
+              "allow-clear": _ctx.allowClear
+            }, _ctx.$attrs, {
+              ref_key: "inputRef",
+              ref: inputRef,
+              onInput: _cache[1] || (_cache[1] = (v, ev) => handleEvent("input", ev, v)),
+              onChange: _cache[2] || (_cache[2] = (v) => _ctx.$emit("change", v)),
+              onClear: _cache[3] || (_cache[3] = (ev) => handleEvent("clear", ev)),
+              onKeydown: _cache[4] || (_cache[4] = (ev) => handleEvent("keydown", ev)),
+              onFocus: _cache[5] || (_cache[5] = (ev) => handleEvent("focus", ev)),
+              onBlur: _cache[6] || (_cache[6] = (ev) => handleEvent("blur", ev))
+            }), null, 16, ["modelValue", "disabled", "allow-clear"])) : (openBlock(), createBlock(unref(Textarea), mergeProps({
+              key: 1,
+              modelValue: unref(computedValue),
+              "onUpdate:modelValue": _cache[7] || (_cache[7] = ($event) => isRef(computedValue) ? computedValue.value = $event : null),
+              disabled: _ctx.disabled,
+              "allow-clear": _ctx.allowClear,
+              "enter-prevent": "",
+              "show-mirror": ""
+            }, _ctx.$attrs, {
+              ref_key: "inputRef",
+              ref: inputRef,
+              onInput: _cache[8] || (_cache[8] = (v, ev) => handleEvent("input", ev, v)),
+              onChange: _cache[9] || (_cache[9] = (v) => _ctx.$emit("change", v)),
+              onClear: _cache[10] || (_cache[10] = (ev) => handleEvent("clear", ev)),
+              onKeydown: _cache[11] || (_cache[11] = (ev) => _ctx.$emit("keydown", ev)),
+              onFocus: _cache[12] || (_cache[12] = (ev) => handleEvent("focus", ev)),
+              onBlur: _cache[13] || (_cache[13] = (ev) => handleEvent("blur", ev))
+            }), null, 16, ["modelValue", "disabled", "allow-clear"]))
+          ])
+        ]),
+        _: 2
+      }, [
+        _ctx.$slots.option ? {
+          name: "option",
+          fn: withCtx((scope) => [
+            renderSlot(_ctx.$slots, "option", normalizeProps(guardReactiveProps(scope)))
+          ]),
+          key: "0"
+        } : void 0,
+        _ctx.$slots.footer ? {
+          name: "footer",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "footer")
+          ]),
+          key: "1"
+        } : void 0
+      ]), 1032, ["popup-visible", "options", "popup-container", "trigger-props", "virtual-list-props"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/AutoComplete/index.vue3.js

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

package/es/AutoComplete/type.d.ts

@@ -0,0 +1,45 @@
+import { SelectOptions, SelectOptionData, VirtualListProps } from '../Select';
+import { PopupContainer, ObjectData } from '../_shared/type';
+import { TriggerProps } from '../Trigger';
+export type AutoCompleteProps = {
+    modelValue?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    data?: SelectOptions;
+    popupContainer?: PopupContainer;
+    strict?: boolean;
+    filterOption?: (inputValue: string, option: SelectOptionData) => boolean;
+    triggerProps?: TriggerProps;
+    allowClear?: boolean;
+    vistualListProps?: VirtualListProps;
+    isSelectSetValue?: boolean;
+    isSearch?: boolean;
+    type?: 'textarea' | 'input';
+};
+export interface AutoCompleteEmits {
+    (e: 'update:modelValue', value: string): void;
+    (e: 'change', value: string): void;
+    (e: 'search', value: string): void;
+    (e: 'select', value: string): void;
+    (e: 'clear', ev?: Event): void;
+    (e: 'dropdown-scroll', ev?: Event): void;
+    (e: 'dropdown-reach-bottom', ev?: Event): void;
+    (e: 'blur', ev: FocusEvent): void;
+    (e: 'focus', ev: FocusEvent): void;
+    (e: 'input', value: string, ev: Event): void;
+    (e: 'keydown', ev: KeyboardEvent): void;
+}
+export interface AutoCompleteSlots {
+    option(scope: {
+        data: ObjectData;
+    }): void;
+    footer(): void;
+    trigger(): void;
+}
+export interface AutoCompleteExpose {
+    focus(): void;
+    blur(): void;
+    getInputRef(): HTMLInputElement | HTMLTextAreaElement | undefined;
+    getMirrorRef(): HTMLDivElement | undefined;
+    updatePosition(x: number, y: number): void;
+}

package/es/Avatar/Avatar.vue.d.ts

@@ -0,0 +1,38 @@
+import { AvatarProps, AvatarSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AvatarSlots> & AvatarSlots;
+    refs: {
+        avatarRef: HTMLDivElement;
+        textRef: HTMLSpanElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    click: (ev: MouseEvent) => any;
+    error: (ev: Event) => any;
+    load: (ev: Event) => any;
+}, string, import('vue').PublicProps, Readonly<AvatarProps> & Readonly<{
+    onClick?: ((ev: MouseEvent) => any) | undefined;
+    onError?: ((ev: Event) => any) | undefined;
+    onLoad?: ((ev: Event) => any) | undefined;
+}>, {
+    size: number;
+    objectFit: import('./type').ObjectFit;
+    shape: import('./type').AvatarShape;
+    autoFixFontSize: boolean;
+    imageUrl: string;
+    triggerType: import('./type').AvatarTriggerType;
+    triggerIconStyle: import('vue').CSSProperties;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    avatarRef: HTMLDivElement;
+    textRef: HTMLSpanElement;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Avatar/Avatar.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./Avatar.vue2.js";
+/* empty css            */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const _Avatar = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ab5f9220"]]);
+export {
+  _Avatar as default
+};

package/es/Avatar/Avatar.vue2.js

@@ -0,0 +1,116 @@
+import { defineComponent, ref, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, createCommentVNode, renderSlot, createVNode } from "vue";
+import { useResizeObserver } from "../node_modules/@vueuse/core/index.js";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { valueToPx } from "../_shared/utils/fn.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import _sfc_main$1 from "../_shared/icons/IconImageClose.vue.js";
+import useContext from "./hooks/useContext.js";
+const _hoisted_1 = {
+  key: 1,
+  class: "yc-avatar-image"
+};
+const _hoisted_2 = ["src"];
+const _hoisted_3 = {
+  key: 1,
+  class: "yc-avatar-image-icon"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Avatar"
+  },
+  __name: "Avatar",
+  props: {
+    shape: { default: void 0 },
+    imageUrl: { default: "" },
+    size: { default: void 0 },
+    autoFixFontSize: { type: Boolean, default: void 0 },
+    triggerType: { default: "button" },
+    triggerIconStyle: { default: () => {
+      return {};
+    } },
+    objectFit: { default: "cover" }
+  },
+  emits: ["click", "error", "load"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { size, autoFixFontSize, shape } = useContext().inject(props);
+    const isLoadError = ref(false);
+    const scale = ref(1);
+    const textRef = ref();
+    const avatarRef = ref();
+    const textWithImage = computed(() => {
+      var _a;
+      return (_a = textRef.value) == null ? void 0 : _a.querySelector("img");
+    });
+    const handleError = (e) => {
+      isLoadError.value = true;
+      emits("error", e);
+    };
+    const initOvserver = () => {
+      if (!autoFixFontSize.value) return;
+      useResizeObserver(textRef, () => {
+        const avatarWidth = size.value ?? avatarRef.value.offsetWidth;
+        const textWidth = textRef.value.offsetWidth;
+        const textScale = avatarWidth / (textWidth + 8);
+        scale.value = avatarWidth && textScale < 1 ? textScale : 1;
+      });
+    };
+    initOvserver();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(["yc-avatar", `yc-avatar-shape-${unref(shape)}`]),
+        style: normalizeStyle({
+          width: unref(valueToPx)(unref(size)),
+          height: unref(valueToPx)(unref(size))
+        }),
+        ref_key: "avatarRef",
+        ref: avatarRef,
+        onClick: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("click", $event))
+      }, [
+        _ctx.$slots.default ? (openBlock(), createElementBlock("span", {
+          key: 0,
+          class: normalizeClass([textWithImage.value ? "yc-avatar-image" : "yc-avatar-text"]),
+          style: normalizeStyle({
+            transform: textWithImage.value ? "" : `scale(${scale.value}) translateX(-50%)`
+          }),
+          ref_key: "textRef",
+          ref: textRef
+        }, [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ], 6)) : _ctx.imageUrl ? (openBlock(), createElementBlock("span", _hoisted_1, [
+          !isLoadError.value ? (openBlock(), createElementBlock("img", {
+            key: 0,
+            src: _ctx.imageUrl,
+            style: normalizeStyle({
+              objectFit: _ctx.objectFit
+            }),
+            alt: "avatar",
+            onLoad: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("load", $event)),
+            onError: handleError
+          }, null, 44, _hoisted_2)) : (openBlock(), createElementBlock("div", _hoisted_3, [
+            createVNode(unref(_sfc_main$1))
+          ]))
+        ])) : createCommentVNode("", true),
+        _ctx.$slots["trigger-icon"] ? (openBlock(), createElementBlock("div", {
+          key: 2,
+          class: normalizeClass([
+            {
+              "yc-avatar-trigger-icon-button": _ctx.triggerType == "button",
+              "yc-avatar-trigger-icon-mask": _ctx.triggerType == "mask"
+            }
+          ]),
+          style: normalizeStyle(_ctx.triggerIconStyle)
+        }, [
+          renderSlot(_ctx.$slots, "trigger-icon", {}, void 0, true)
+        ], 6)) : createCommentVNode("", true)
+      ], 6);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Avatar/AvatarGroup.vue.d.ts

@@ -0,0 +1,24 @@
+import { AvatarGroupProps, AvatarGroupSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AvatarGroupSlots> & AvatarGroupSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AvatarGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AvatarGroupProps> & Readonly<{}>, {
+    size: number;
+    shape: import('./type').AvatarShape;
+    autoFixFontSize: boolean;
+    maxCount: number;
+    zIndexAscend: boolean;
+    maxStyle: import('vue').CSSProperties;
+    maxPopoverTriggerProps: import('..').TriggerProps;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/Avatar/AvatarGroup.vue.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./AvatarGroup.vue2.js";
+/* empty css                 */
+import _export_sfc from "../_virtual/_plugin-vue_export-helper.js";
+const AvatarGroup = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a468c247"]]);
+export {
+  AvatarGroup as default
+};

package/es/Avatar/AvatarGroup.vue2.js

@@ -0,0 +1,96 @@
+import { defineComponent, toRefs, useSlots, computed, createElementBlock, openBlock, createBlock, createCommentVNode, Fragment, renderList, resolveDynamicComponent, normalizeStyle, unref, withCtx, createVNode, createTextVNode, toDisplayString } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { valueToPx } from "../_shared/utils/fn.js";
+import "../_shared/utils/time.js";
+import { findComponentsFromVnodes } from "../_shared/utils/vue-utils.js";
+import "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+import Avatar from "./index.js";
+import Popover from "../Popover/index.js";
+const _hoisted_1 = { class: "yc-avatar-group" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "AvatarGroup"
+  },
+  __name: "AvatarGroup",
+  props: {
+    shape: { default: "round" },
+    size: { default: 40 },
+    autoFixFontSize: { type: Boolean, default: true },
+    maxCount: { default: 0 },
+    zIndexAscend: { type: Boolean, default: false },
+    maxStyle: { default: () => {
+      return {};
+    } },
+    maxPopoverTriggerProps: { default: () => {
+      return {};
+    } }
+  },
+  setup(__props) {
+    const props = __props;
+    const { maxCount } = toRefs(props);
+    useContext().provide(props);
+    const slots = useSlots();
+    const nodes = computed(() => {
+      var _a;
+      const avatars = findComponentsFromVnodes(
+        ((_a = slots.default) == null ? void 0 : _a.call(slots)) || [],
+        Avatar.name
+      );
+      return {
+        visible: maxCount.value > 0 ? avatars.slice(0, maxCount.value) : avatars,
+        hide: avatars.slice(maxCount.value)
+      };
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(nodes.value.visible, (node, index) => {
+          return openBlock(), createBlock(resolveDynamicComponent(node), {
+            key: index,
+            style: normalizeStyle({
+              zIndex: _ctx.zIndexAscend ? index + 1 : nodes.value.visible.length - index,
+              marginLeft: index ? unref(valueToPx)(-_ctx.size / 4) : ""
+            })
+          }, null, 8, ["style"]);
+        }), 128)),
+        unref(maxCount) > 0 && nodes.value.hide.length ? (openBlock(), createBlock(unref(Popover), {
+          key: 0,
+          "trigger-props": _ctx.maxPopoverTriggerProps
+        }, {
+          content: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(nodes.value.hide, (node, index) => {
+              return openBlock(), createBlock(resolveDynamicComponent(node), {
+                key: index,
+                style: normalizeStyle({
+                  border: "2px solid #fff",
+                  zIndex: _ctx.zIndexAscend ? index + 1 : nodes.value.hide.length - index,
+                  marginLeft: index ? unref(valueToPx)(-_ctx.size / 4) : ""
+                })
+              }, null, 8, ["style"]);
+            }), 128))
+          ]),
+          default: withCtx(() => [
+            createVNode(unref(Avatar), {
+              style: normalizeStyle({
+                zIndex: _ctx.zIndexAscend ? nodes.value.visible.length : 0,
+                marginLeft: unref(valueToPx)(-_ctx.size / 4),
+                ..._ctx.maxStyle
+              })
+            }, {
+              default: withCtx(() => [
+                createTextVNode(toDisplayString(`+${nodes.value.hide.length}`), 1)
+              ]),
+              _: 1
+            }, 8, ["style"])
+          ]),
+          _: 1
+        }, 8, ["trigger-props"])) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Avatar/hooks/useContext.d.ts

@@ -0,0 +1,10 @@
+import { Props } from '../../_shared/type';
+declare const _default: () => {
+    provide: (props: Props) => void;
+    inject: (props: Props) => {
+        shape: import('vue').ComputedRef<any>;
+        size: import('vue').ComputedRef<any>;
+        autoFixFontSize: import('vue').ComputedRef<any>;
+    };
+};
+export default _default;

package/es/Avatar/hooks/useContext.js

@@ -0,0 +1,42 @@
+import { toRefs, provide, inject, ref, computed } from "vue";
+const AVATAR_GROUP_CONTEXT_KEY = "radio-group-context";
+const useContext = () => {
+  const provide$1 = (props) => {
+    const { shape, size, autoFixFontSize } = toRefs(props);
+    provide(AVATAR_GROUP_CONTEXT_KEY, {
+      shape,
+      size,
+      autoFixFontSize
+    });
+  };
+  const inject$1 = (props) => {
+    const { shape, size, autoFixFontSize } = toRefs(props);
+    const {
+      shape: _shape,
+      size: _size,
+      autoFixFontSize: _autoFixFontSize
+    } = inject(AVATAR_GROUP_CONTEXT_KEY, {
+      shape: ref("round"),
+      size: ref(40),
+      autoFixFontSize: ref(true)
+    });
+    return {
+      shape: computed(() => {
+        return shape.value ?? _shape.value;
+      }),
+      size: computed(() => {
+        return size.value ?? _size.value;
+      }),
+      autoFixFontSize: computed(() => {
+        return autoFixFontSize.value ?? _autoFixFontSize.value;
+      })
+    };
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  useContext as default
+};