yc-design-vue 1.0.1

package/es/Steps/Step.vue.d.ts

@@ -0,0 +1,21 @@
+import { StepProps, StepSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<StepSlots> & StepSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<StepProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StepProps> & Readonly<{}>, {
+    disabled: boolean;
+    title: string;
+    description: string;
+    status: import('./type').StepStatus;
+}, {}, {}, {}, 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/Steps/Step.vue.js

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

package/es/Steps/Step.vue2.js

@@ -0,0 +1,115 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeClass, unref, createCommentVNode, renderSlot, createElementVNode, createBlock, Fragment, createTextVNode, 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$1 from "../_shared/icons/IconCheck.vue.js";
+import _sfc_main$2 from "../_shared/icons/IconClose.vue.js";
+import useContext from "./hooks/useContext.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "yc-steps-item-tail"
+};
+const _hoisted_2 = { class: "yc-steps-item-node" };
+const _hoisted_3 = { class: "yc-steps-icon" };
+const _hoisted_4 = { class: "yc-steps-item-content" };
+const _hoisted_5 = { class: "yc-steps-item-title" };
+const _hoisted_6 = {
+  key: 0,
+  class: "yc-steps-item-description"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Step"
+  },
+  __name: "Step",
+  props: {
+    title: { default: "" },
+    description: { default: "" },
+    status: { default: void 0 },
+    disabled: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const { disabled } = toRefs(props);
+    const {
+      curStep,
+      stepMap,
+      computedCurrent,
+      type,
+      changeable,
+      status,
+      nextStatus,
+      direction,
+      labelPlacement,
+      lineLess: _lineLess,
+      small: _small,
+      emits
+    } = useContext().inject(props);
+    const small = computed(() => {
+      return type.value != "dot" ? _small.value : false;
+    });
+    const lineLess = computed(() => {
+      return _lineLess.value || curStep.value == stepMap.size || ["arrow", "navigation"].includes(type.value);
+    });
+    const handleClick = (e) => {
+      if (!changeable.value || disabled.value) return;
+      computedCurrent.value = curStep.value;
+      emits("change", curStep.value, e);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-steps-item",
+          `yc-steps-item-${unref(direction)}`,
+          `yc-steps-item-label-${unref(labelPlacement)}`,
+          `yc-steps-item-${unref(status)}`,
+          `yc-steps-item-next-${unref(nextStatus)}`,
+          {
+            "yc-steps-item-active": unref(curStep) == unref(computedCurrent) && unref(type) == "navigation",
+            "yc-steps-item-line-less": lineLess.value,
+            "yc-steps-item-size-small": small.value
+          }
+        ]),
+        onClick: handleClick
+      }, [
+        unref(type) == "default" && (unref(direction) == "vertical" || unref(labelPlacement) == "vertical") || unref(type) == "dot" ? (openBlock(), createElementBlock("div", _hoisted_1)) : createCommentVNode("", true),
+        unref(type) != "arrow" ? renderSlot(_ctx.$slots, "node", {
+          key: 1,
+          step: unref(curStep),
+          status: unref(status)
+        }, () => [
+          createElementVNode("div", _hoisted_2, [
+            createElementVNode("div", _hoisted_3, [
+              ["default", "navigation"].includes(unref(type)) ? renderSlot(_ctx.$slots, "icon", {
+                key: 0,
+                status: unref(status),
+                step: unref(curStep)
+              }, () => [
+                unref(status) == "finish" ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : unref(status) == "error" ? (openBlock(), createBlock(unref(_sfc_main$2), { key: 1 })) : (openBlock(), createElementBlock(Fragment, { key: 2 }, [
+                  createTextVNode(toDisplayString(unref(curStep)), 1)
+                ], 64))
+              ], true) : createCommentVNode("", true)
+            ])
+          ])
+        ], true) : createCommentVNode("", true),
+        createElementVNode("div", _hoisted_4, [
+          createElementVNode("div", _hoisted_5, [
+            renderSlot(_ctx.$slots, "default", {}, () => [
+              createTextVNode(toDisplayString(_ctx.title), 1)
+            ], true)
+          ]),
+          _ctx.$slots.description || _ctx.description ? (openBlock(), createElementBlock("div", _hoisted_6, [
+            renderSlot(_ctx.$slots, "description", {}, () => [
+              createTextVNode(toDisplayString(_ctx.description), 1)
+            ], true)
+          ])) : createCommentVNode("", true)
+        ])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Steps/Steps.vue.d.ts

@@ -0,0 +1,32 @@
+import { StepsProps, StepsSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<StepsSlots> & StepsSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<StepsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (step: number, ev: Event) => any;
+    "update:current": (step: number) => any;
+}, string, import('vue').PublicProps, Readonly<StepsProps> & Readonly<{
+    onChange?: ((step: number, ev: Event) => any) | undefined;
+    "onUpdate:current"?: ((step: number) => any) | undefined;
+}>, {
+    small: boolean;
+    type: import('./type').StepType;
+    direction: import('..').Direction;
+    lineLess: boolean;
+    status: import('./type').StepStatus;
+    current: number;
+    defaultCurrent: number;
+    labelPlacement: import('..').Direction;
+    changeable: boolean;
+}, {}, {}, {}, 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/Steps/Steps.vue.js

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

package/es/Steps/Steps.vue2.js

@@ -0,0 +1,43 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, unref, renderSlot } from "vue";
+import useContext from "./hooks/useContext.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Steps"
+  },
+  __name: "Steps",
+  props: {
+    type: { default: "default" },
+    direction: { default: "horizontal" },
+    labelPlacement: { default: "horizontal" },
+    current: { default: void 0 },
+    defaultCurrent: { default: 1 },
+    status: { default: "process" },
+    lineLess: { type: Boolean, default: false },
+    small: { type: Boolean, default: false },
+    changeable: { type: Boolean, default: false }
+  },
+  emits: ["change", "update:current"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { type, labelPlacement, direction } = useContext().provide(props, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-steps",
+          `yc-steps-mode-${unref(type)}`,
+          `yc-steps-${unref(direction)}`,
+          `yc-steps-label-${unref(labelPlacement)}`,
+          {
+            "yc-steps-changeable": _ctx.changeable
+          }
+        ])
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

@@ -0,0 +1,26 @@
+import { Ref, Reactive } from 'vue';
+import { StepsEmits, StepStatus, StepType } from '../type';
+import { Props, Direction } from '../../_shared/type';
+declare const _default: () => {
+    provide: (props: Props, emits: StepsEmits) => {
+        direction: import('vue').ComputedRef<Direction>;
+        labelPlacement: import('vue').ComputedRef<Direction>;
+        type: Ref<StepType, StepType>;
+    };
+    inject: (props: Props) => {
+        curStep: import('vue').ComputedRef<number>;
+        status: import('vue').ComputedRef<any>;
+        nextStatus: import('vue').ComputedRef<StepStatus>;
+        stepMap: Reactive<Map<string, string>>;
+        computedCurrent: Ref<number>;
+        lineLess: Ref<boolean>;
+        direction: Ref<Direction>;
+        labelPlacement: Ref<Direction>;
+        statusArr: Ref<Ref<StepStatus>[]>;
+        small: Ref<boolean>;
+        type: Ref<StepType>;
+        changeable: Ref<boolean>;
+        emits: StepsEmits;
+    };
+};
+export default _default;

package/es/Steps/hooks/useContext.js

@@ -0,0 +1,138 @@
+import { toRefs, computed, reactive, ref, provide, inject, onBeforeUnmount } from "vue";
+import { nanoid } from "../../node_modules/nanoid/index.browser.js";
+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 useControlValue from "../../_shared/utils/control.js";
+const STEPS_CONTEXT_KEY = "card-context";
+const useContext = () => {
+  const provide$1 = (props, emits) => {
+    const {
+      status,
+      current,
+      defaultCurrent,
+      lineLess,
+      labelPlacement: _labelPlacement,
+      direction: _direction,
+      small,
+      type,
+      changeable
+    } = toRefs(props);
+    const computedCurrent = useControlValue(
+      current,
+      defaultCurrent.value,
+      (val) => {
+        emits("update:current", val);
+      }
+    );
+    const direction = computed(() => {
+      if (["default", "dot"].includes(type.value)) {
+        return _direction.value;
+      } else {
+        return "horizontal";
+      }
+    });
+    const labelPlacement = computed(() => {
+      if (type.value == "default" && direction.value == "horizontal") {
+        return _labelPlacement.value;
+      } else if (type.value == "dot") {
+        return direction.value == "vertical" ? "horizontal" : "vertical";
+      } else {
+        return "horizontal";
+      }
+    });
+    const stepMap = reactive(/* @__PURE__ */ new Map());
+    const statusArr = ref([]);
+    provide(STEPS_CONTEXT_KEY, {
+      stepMap,
+      computedCurrent,
+      lineLess,
+      direction,
+      status,
+      statusArr,
+      small,
+      type,
+      changeable,
+      labelPlacement,
+      emits
+    });
+    return {
+      direction,
+      labelPlacement,
+      type
+    };
+  };
+  const inject$1 = (props) => {
+    const { status: _status } = toRefs(props);
+    const injection = inject(STEPS_CONTEXT_KEY, {
+      stepMap: reactive(/* @__PURE__ */ new Map()),
+      computedCurrent: ref(0),
+      lineLess: ref(false),
+      direction: ref("horizontal"),
+      status: ref("process"),
+      statusArr: ref([]),
+      small: ref(false),
+      type: ref("default"),
+      changeable: ref(false),
+      labelPlacement: ref("horizontal"),
+      emits: () => {
+      }
+    });
+    const collectStep = () => {
+      const {
+        stepMap,
+        computedCurrent,
+        statusArr,
+        status: injectStatus
+      } = injection;
+      const id = nanoid();
+      stepMap.set(id, id);
+      const curStep2 = computed(() => {
+        return [...stepMap.values()].findIndex((item) => item == id) + 1;
+      });
+      const status2 = computed(() => {
+        if (!isUndefined(_status.value)) {
+          return _status.value;
+        }
+        if (curStep2.value < computedCurrent.value) {
+          return "finish";
+        } else if (curStep2.value == computedCurrent.value) {
+          return injectStatus.value ?? "process";
+        } else {
+          return "wait";
+        }
+      });
+      const nextStatus2 = computed(() => {
+        var _a;
+        return (_a = statusArr.value[curStep2.value]) == null ? void 0 : _a.value;
+      });
+      statusArr.value[curStep2.value - 1] = status2;
+      onBeforeUnmount(() => {
+        stepMap.delete(id);
+        statusArr.value.splice(curStep2.value - 1, 1);
+      });
+      return {
+        curStep: curStep2,
+        status: status2,
+        nextStatus: nextStatus2
+      };
+    };
+    const { curStep, status, nextStatus } = collectStep();
+    return {
+      ...injection,
+      curStep,
+      status,
+      nextStatus
+    };
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  useContext as default
+};

package/es/Steps/index.d.ts

@@ -0,0 +1,106 @@
+import { App } from 'vue';
+import { default as _Step } from './Step.vue';
+import { default as _Steps } from './Steps.vue';
+export type StepInstance = InstanceType<typeof _Step>;
+export type StepsInstance = InstanceType<typeof _Steps>;
+export * from './type';
+declare const Steps: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').StepsProps> & Readonly<{
+        onChange?: ((step: number, ev: Event) => any) | undefined;
+        "onUpdate:current"?: ((step: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (step: number, ev: Event) => any;
+        "update:current": (step: number) => any;
+    }, import('vue').PublicProps, {
+        small: boolean;
+        type: import('./type').StepType;
+        direction: import('..').Direction;
+        lineLess: boolean;
+        status: import('./type').StepStatus;
+        current: number;
+        defaultCurrent: number;
+        labelPlacement: import('..').Direction;
+        changeable: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').StepsProps> & Readonly<{
+        onChange?: ((step: number, ev: Event) => any) | undefined;
+        "onUpdate:current"?: ((step: number) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        small: boolean;
+        type: import('./type').StepType;
+        direction: import('..').Direction;
+        lineLess: boolean;
+        status: import('./type').StepStatus;
+        current: number;
+        defaultCurrent: number;
+        labelPlacement: import('..').Direction;
+        changeable: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').StepsProps> & Readonly<{
+    onChange?: ((step: number, ev: Event) => any) | undefined;
+    "onUpdate:current"?: ((step: number) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (step: number, ev: Event) => any;
+    "update:current": (step: number) => any;
+}, string, {
+    small: boolean;
+    type: import('./type').StepType;
+    direction: import('..').Direction;
+    lineLess: boolean;
+    status: import('./type').StepStatus;
+    current: number;
+    defaultCurrent: number;
+    labelPlacement: import('..').Direction;
+    changeable: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').StepsSlots> & import('./type').StepsSlots;
+}) & {
+    step: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').StepProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            disabled: boolean;
+            title: string;
+            description: string;
+            status: import('./type').StepStatus;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').StepProps> & Readonly<{}>, {}, {}, {}, {}, {
+            disabled: boolean;
+            title: string;
+            description: string;
+            status: import('./type').StepStatus;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').StepProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        disabled: boolean;
+        title: string;
+        description: string;
+        status: import('./type').StepStatus;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<import('./type').StepSlots> & import('./type').StepSlots;
+    });
+    install: (app: App) => void;
+};
+export { _Step as Step };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcSteps: typeof Steps;
+        YcStep: typeof _Step;
+    }
+}
+export default Steps;

package/es/Steps/index.js

@@ -0,0 +1,13 @@
+import Step from "./Step.vue.js";
+import _Steps from "./Steps.vue.js";
+const Steps = Object.assign(_Steps, {
+  step: Step,
+  install: (app) => {
+    app.component("Yc" + Step.name, Step);
+    app.component("Yc" + _Steps.name, _Steps);
+  }
+});
+export {
+  Step,
+  Steps as default
+};

package/es/Steps/type.d.ts

@@ -0,0 +1,39 @@
+import { Direction } from '../_shared/type';
+export interface StepsProps {
+    type?: StepType;
+    direction?: Direction;
+    labelPlacement?: Direction;
+    current?: number;
+    defaultCurrent?: number;
+    status?: StepStatus;
+    lineLess?: boolean;
+    small?: boolean;
+    changeable?: boolean;
+}
+export interface StepsEmits {
+    (e: 'change', step: number, ev: Event): void;
+    (e: 'update:current', step: number): void;
+}
+export interface StepsSlots {
+    default(): void;
+}
+export interface StepProps {
+    title?: string;
+    description?: string;
+    status?: StepStatus;
+    disabled?: boolean;
+}
+export interface StepSlots {
+    node(scope: {
+        step: number;
+        status: StepStatus;
+    }): void;
+    icon(scope: {
+        step: number;
+        status: StepStatus;
+    }): void;
+    description(): void;
+    default(): void;
+}
+export type StepStatus = 'wait' | 'process' | 'finish' | 'error';
+export type StepType = 'default' | 'arrow' | 'dot' | 'navigation';

package/es/Switch/index.d.ts

@@ -0,0 +1,94 @@
+import { App } from 'vue';
+import { default as _Switch } from './index.vue';
+export type SwitchInstance = InstanceType<typeof _Switch>;
+export * from './type';
+declare const Switch: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').SwitchProps> & Readonly<{
+        onChange?: ((value: import('./type').SwitchValue, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').SwitchValue) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').SwitchValue, ev: Event) => any;
+        focus: (ev: FocusEvent) => any;
+        blur: (ev: FocusEvent) => any;
+        "update:modelValue": (value: import('./type').SwitchValue) => any;
+    }, import('vue').PublicProps, {
+        size: import('./type').SwitchSize;
+        disabled: boolean;
+        loading: boolean;
+        type: import('./type').SwitchType;
+        defaultChecked: import('./type').SwitchValue;
+        modelValue: import('./type').SwitchValue;
+        checkedValue: import('./type').SwitchValue;
+        uncheckedValue: import('./type').SwitchValue;
+        checkedColor: string;
+        uncheckedColor: string;
+        checkedText: string;
+        uncheckedText: string;
+        beforeChange: import('./type').BeforeChange;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLButtonElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').SwitchProps> & Readonly<{
+        onChange?: ((value: import('./type').SwitchValue, ev: Event) => any) | undefined;
+        onFocus?: ((ev: FocusEvent) => any) | undefined;
+        onBlur?: ((ev: FocusEvent) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').SwitchValue) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('./type').SwitchSize;
+        disabled: boolean;
+        loading: boolean;
+        type: import('./type').SwitchType;
+        defaultChecked: import('./type').SwitchValue;
+        modelValue: import('./type').SwitchValue;
+        checkedValue: import('./type').SwitchValue;
+        uncheckedValue: import('./type').SwitchValue;
+        checkedColor: string;
+        uncheckedColor: string;
+        checkedText: string;
+        uncheckedText: string;
+        beforeChange: import('./type').BeforeChange;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').SwitchProps> & Readonly<{
+    onChange?: ((value: import('./type').SwitchValue, ev: Event) => any) | undefined;
+    onFocus?: ((ev: FocusEvent) => any) | undefined;
+    onBlur?: ((ev: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: import('./type').SwitchValue) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').SwitchValue, ev: Event) => any;
+    focus: (ev: FocusEvent) => any;
+    blur: (ev: FocusEvent) => any;
+    "update:modelValue": (value: import('./type').SwitchValue) => any;
+}, string, {
+    size: import('./type').SwitchSize;
+    disabled: boolean;
+    loading: boolean;
+    type: import('./type').SwitchType;
+    defaultChecked: import('./type').SwitchValue;
+    modelValue: import('./type').SwitchValue;
+    checkedValue: import('./type').SwitchValue;
+    uncheckedValue: import('./type').SwitchValue;
+    checkedColor: string;
+    uncheckedColor: string;
+    checkedText: string;
+    uncheckedText: string;
+    beforeChange: import('./type').BeforeChange;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('./type').SwitchSlots> & import('./type').SwitchSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcSwitch: typeof Switch;
+    }
+}
+export default Switch;

package/es/Switch/index.js

@@ -0,0 +1,9 @@
+import _Switch from "./index.vue.js";
+const Switch = Object.assign(_Switch, {
+  install: (app) => {
+    app.component("Yc" + _Switch.name, _Switch);
+  }
+});
+export {
+  Switch as default
+};