yc-design-vue 1.0.1

package/es/Radio/index.d.ts

@@ -0,0 +1,118 @@
+import { App } from 'vue';
+import { default as _Radio } from './Radio.vue';
+import { default as _RadioGroup } from './RadioGroup.vue';
+export type RadioInstance = InstanceType<typeof _Radio>;
+export type RadioGroupInstance = InstanceType<typeof _RadioGroup>;
+export * from './type';
+declare const Radio: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').RadioProps> & Readonly<{
+        onChange?: ((value: import('./type').RadioValue, ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').RadioValue, ev: Event) => any;
+        "update:modelValue": (value: boolean) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        value: import('./type').RadioValue;
+        type: import('./type').RadioType;
+        defaultChecked: boolean;
+        modelValue: import('./type').RadioValue;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLLabelElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').RadioProps> & Readonly<{
+        onChange?: ((value: import('./type').RadioValue, ev: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        value: import('./type').RadioValue;
+        type: import('./type').RadioType;
+        defaultChecked: boolean;
+        modelValue: import('./type').RadioValue;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').RadioProps> & Readonly<{
+    onChange?: ((value: import('./type').RadioValue, ev: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: import('./type').RadioValue, ev: Event) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, {
+    disabled: boolean;
+    value: import('./type').RadioValue;
+    type: import('./type').RadioType;
+    defaultChecked: boolean;
+    modelValue: import('./type').RadioValue;
+}, {}, 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').RadioSlots> & import('./type').RadioSlots;
+}) & {
+    group: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').RadioGroupProps> & Readonly<{
+            onChange?: ((value: import('./type').RadioValue) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./type').RadioValue) => any) | undefined;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            change: (value: import('./type').RadioValue) => any;
+            "update:modelValue": (value: import('./type').RadioValue) => any;
+        }, import('vue').PublicProps, {
+            size: import('..').Size;
+            disabled: boolean;
+            type: import('./type').RadioType;
+            direction: import('..').Direction;
+            modelValue: import('./type').RadioValue;
+            defaultValue: import('./type').RadioValue;
+            options: import('./type').RadioOption[];
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').RadioGroupProps> & Readonly<{
+            onChange?: ((value: import('./type').RadioValue) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: import('./type').RadioValue) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            size: import('..').Size;
+            disabled: boolean;
+            type: import('./type').RadioType;
+            direction: import('..').Direction;
+            modelValue: import('./type').RadioValue;
+            defaultValue: import('./type').RadioValue;
+            options: import('./type').RadioOption[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').RadioGroupProps> & Readonly<{
+        onChange?: ((value: import('./type').RadioValue) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('./type').RadioValue) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: import('./type').RadioValue) => any;
+        "update:modelValue": (value: import('./type').RadioValue) => any;
+    }, string, {
+        size: import('..').Size;
+        disabled: boolean;
+        type: import('./type').RadioType;
+        direction: import('..').Direction;
+        modelValue: import('./type').RadioValue;
+        defaultValue: import('./type').RadioValue;
+        options: import('./type').RadioOption[];
+    }, {}, 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').RadioGroupSlots> & import('./type').RadioGroupSlots;
+    });
+    install: (app: App) => void;
+};
+export { _RadioGroup as RadioGroup };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcRadio: typeof Radio;
+        YcRadioGroup: typeof _RadioGroup;
+    }
+}
+export default Radio;

package/es/Radio/index.js

@@ -0,0 +1,14 @@
+import _Radio from "./Radio.vue.js";
+import _sfc_main from "./RadioGroup.vue.js";
+/* empty css                */
+const Radio = Object.assign(_Radio, {
+  group: _sfc_main,
+  install: (app) => {
+    app.component("Yc" + _Radio.name, _Radio);
+    app.component("Yc" + _sfc_main.name, _sfc_main);
+  }
+});
+export {
+  _sfc_main as RadioGroup,
+  Radio as default
+};

package/es/Radio/type.d.ts

@@ -0,0 +1,49 @@
+import { Direction, Size, ObjectData } from '../_shared/type';
+export interface RadioProps {
+    modelValue?: RadioValue;
+    defaultChecked?: boolean;
+    value?: RadioValue;
+    type?: RadioType;
+    disabled?: boolean;
+}
+export interface RadioEmits {
+    (e: 'update:modelValue', value: boolean): void;
+    (e: 'change', value: RadioValue, ev: Event): void;
+}
+export interface RadioSlots {
+    default(): void;
+    radio(scope: {
+        checked: boolean;
+        disabled: boolean;
+    }): void;
+}
+export interface RadioGroupProps {
+    modelValue?: RadioValue;
+    defaultValue?: RadioValue;
+    size?: Size;
+    type?: RadioType;
+    options?: RadioOption[];
+    direction?: Direction;
+    disabled?: boolean;
+}
+export interface RadioGroupEmits {
+    (e: 'update:modelValue', value: RadioValue): void;
+    (e: 'change', value: RadioValue): void;
+}
+export interface RadioGroupSlots {
+    default(): void;
+    radio(scope: {
+        checked: boolean;
+        disabled: boolean;
+    }): void;
+    label(scope: {
+        data: ObjectData;
+    }): void;
+}
+export type RadioOption = (RadioValue | {
+    label?: string;
+    value: RadioValue;
+    disabled?: boolean;
+})[];
+export type RadioValue = string | number | boolean;
+export type RadioType = 'radio' | 'button';

package/es/Rate/index.d.ts

@@ -0,0 +1,74 @@
+import { App } from 'vue';
+import { default as _Rate } from './index.vue';
+export type RateInstance = InstanceType<typeof _Rate>;
+export * from './type';
+declare const Rate: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').RateProps> & Readonly<{
+        onChange?: ((value: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+        "onHover-change"?: ((value: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        change: (value: number) => any;
+        "update:modelValue": (value: number) => any;
+        "hover-change": (value: number) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        color: string | Record<number, string>;
+        modelValue: number;
+        defaultValue: number;
+        readonly: boolean;
+        count: number;
+        allowHalf: boolean;
+        grading: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').RateProps> & Readonly<{
+        onChange?: ((value: number) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+        "onHover-change"?: ((value: number) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        disabled: boolean;
+        color: string | Record<number, string>;
+        modelValue: number;
+        defaultValue: number;
+        readonly: boolean;
+        count: number;
+        allowHalf: boolean;
+        grading: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').RateProps> & Readonly<{
+    onChange?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    "onHover-change"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+    "hover-change": (value: number) => any;
+}, string, {
+    disabled: boolean;
+    color: string | Record<number, string>;
+    modelValue: number;
+    defaultValue: number;
+    readonly: boolean;
+    count: number;
+    allowHalf: boolean;
+    grading: 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').RateSlots> & import('./type').RateSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcRate: typeof Rate;
+    }
+}
+export default Rate;

package/es/Rate/index.js

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

package/es/Rate/index.vue.d.ts

@@ -0,0 +1,33 @@
+import { RateProps, RateSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<RateSlots> & RateSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<RateProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+    "hover-change": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<RateProps> & Readonly<{
+    onChange?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+    "onHover-change"?: ((value: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    color: string | Record<number, string>;
+    modelValue: number;
+    defaultValue: number;
+    readonly: boolean;
+    count: number;
+    allowHalf: boolean;
+    grading: 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/Rate/index.vue.js

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

package/es/Rate/index.vue2.js

@@ -0,0 +1,149 @@
+import { defineComponent, toRefs, ref, computed, createElementBlock, openBlock, normalizeClass, unref, Fragment, renderList, createCommentVNode, createElementVNode, withModifiers, normalizeStyle, renderSlot, createBlock } from "vue";
+import "../node_modules/tinycolor2/esm/tinycolor.js";
+import "../_shared/utils/dom.js";
+import { sleep } from "../_shared/utils/fn.js";
+import { isObject } from "../_shared/utils/is.js";
+import "../_shared/utils/time.js";
+import "../Empty/index.js";
+/* empty css                         */
+import _sfc_main$1 from "../_shared/icons/IconFaceSmile.vue.js";
+import _sfc_main$2 from "../_shared/icons/IconStar.vue.js";
+import useControlValue from "../_shared/utils/control.js";
+const _hoisted_1 = ["onClick", "onMouseenter"];
+const _hoisted_2 = ["onClick", "onMouseenter"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Rate"
+  },
+  __name: "index",
+  props: {
+    count: { default: 5 },
+    modelValue: { default: void 0 },
+    defaultValue: { default: 0 },
+    allowHalf: { type: Boolean, default: false },
+    allowClear: { type: Boolean },
+    grading: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    disabled: { type: Boolean, default: false },
+    color: { default: "rgb(247, 186, 30)" }
+  },
+  emits: ["update:modelValue", "change", "hover-change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      modelValue,
+      defaultValue,
+      readonly,
+      disabled,
+      count,
+      allowClear,
+      color: _color
+    } = toRefs(props);
+    const chars = ref([]);
+    let loading = false;
+    const curHover = ref(0);
+    const computedValue = useControlValue(
+      modelValue,
+      defaultValue.value,
+      (val) => {
+        emits("update:modelValue", val);
+      }
+    );
+    const color = computed(() => {
+      var _a;
+      if (isObject(_color.value)) {
+        return ((_a = Object.entries(_color.value).find(
+          ([key]) => curHover.value <= +key
+        )) == null ? void 0 : _a[1]) ?? "rgb(247, 186, 30)";
+      } else {
+        return _color.value ?? "rgb(247, 186, 30)";
+      }
+    });
+    const handleClick = async (index) => {
+      if (readonly.value || disabled.value || loading) {
+        return;
+      }
+      computedValue.value = allowClear.value && computedValue.value == index ? 0 : index;
+      emits("change", computedValue.value);
+      loading = true;
+      for (let i = 1; i <= count.value; i++) {
+        if (i > computedValue.value) {
+          continue;
+        }
+        const el = chars.value[i];
+        el.classList.add("yc-rate-character-scale");
+        await sleep(50);
+        setTimeout(() => {
+          el.classList.remove("yc-rate-character-scale");
+        }, 150);
+      }
+      loading = false;
+    };
+    let timer;
+    const handleMouseenter = (i) => {
+      if (readonly.value || disabled.value) return;
+      if (timer) clearTimeout(timer);
+      curHover.value = i;
+      emits("hover-change", i);
+    };
+    const handleMouseleave = () => {
+      if (readonly.value || disabled.value) return;
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        curHover.value = 0;
+      }, 100);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-rate",
+          {
+            "yc-rate-disabled": unref(disabled),
+            "yc-rate-readonly": unref(readonly)
+          }
+        ])
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(count), (i) => {
+          return openBlock(), createElementBlock("div", {
+            key: i,
+            class: "yc-rate-character",
+            ref_for: true,
+            ref: (el) => chars.value[i] = el
+          }, [
+            _ctx.allowHalf ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "yc-rate-character-left",
+              style: normalizeStyle({
+                color: i - 0.5 <= unref(computedValue) && !curHover.value || i - 0.5 <= curHover.value ? color.value : ""
+              }),
+              onClick: withModifiers(($event) => handleClick(i - 0.5), ["stop"]),
+              onMouseenter: ($event) => handleMouseenter(i - 0.5),
+              onMouseleave: handleMouseleave
+            }, [
+              renderSlot(_ctx.$slots, "character", { index: i }, () => [
+                _ctx.grading ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$2), { key: 1 }))
+              ], true)
+            ], 44, _hoisted_1)) : createCommentVNode("", true),
+            createElementVNode("div", {
+              class: "yc-rate-character-right",
+              style: normalizeStyle({
+                color: i <= unref(computedValue) && !curHover.value || i <= curHover.value ? color.value : ""
+              }),
+              onClick: ($event) => handleClick(i),
+              onMouseenter: ($event) => handleMouseenter(i),
+              onMouseleave: handleMouseleave
+            }, [
+              renderSlot(_ctx.$slots, "character", { index: i }, () => [
+                _ctx.grading ? (openBlock(), createBlock(unref(_sfc_main$1), { key: 0 })) : (openBlock(), createBlock(unref(_sfc_main$2), { key: 1 }))
+              ], true)
+            ], 44, _hoisted_2)
+          ]);
+        }), 128))
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Rate/type.d.ts

@@ -0,0 +1,21 @@
+export interface RateProps {
+    count?: number;
+    modelValue?: number;
+    defaultValue?: number;
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    grading?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+    color?: string | Record<number, string>;
+}
+export interface RateEmits {
+    (e: 'update:modelValue', value: number): void;
+    (e: 'change', value: number): void;
+    (e: 'hover-change', value: number): void;
+}
+export interface RateSlots {
+    character(scope: {
+        index: number;
+    }): void;
+}

package/es/ResizeBox/index.d.ts

@@ -0,0 +1,89 @@
+import { App } from 'vue';
+import { default as _ResizeBox } from './index.vue';
+export type ResizeBoxInstance = InstanceType<typeof _ResizeBox>;
+export * from './type';
+declare const ResizeBox: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').ResizeBoxProps> & Readonly<{
+        "onUpdate:width"?: ((value: number) => any) | undefined;
+        "onUpdate:height"?: ((value: number) => any) | undefined;
+        "onMoving-start"?: ((ev: MouseEvent) => any) | undefined;
+        onMoving?: ((size: {
+            width: number;
+            height: number;
+        }, ev: MouseEvent) => any) | undefined;
+        "onMoving-end"?: ((ev: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:width": (value: number) => any;
+        "update:height": (value: number) => any;
+        "moving-start": (ev: MouseEvent) => any;
+        moving: (size: {
+            width: number;
+            height: number;
+        }, ev: MouseEvent) => any;
+        "moving-end": (ev: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        width: number;
+        height: number;
+        component: string;
+        directions: import('./type').ResizeBoxDirection[];
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        boxRef: unknown;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').ResizeBoxProps> & Readonly<{
+        "onUpdate:width"?: ((value: number) => any) | undefined;
+        "onUpdate:height"?: ((value: number) => any) | undefined;
+        "onMoving-start"?: ((ev: MouseEvent) => any) | undefined;
+        onMoving?: ((size: {
+            width: number;
+            height: number;
+        }, ev: MouseEvent) => any) | undefined;
+        "onMoving-end"?: ((ev: MouseEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        width: number;
+        height: number;
+        component: string;
+        directions: import('./type').ResizeBoxDirection[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').ResizeBoxProps> & Readonly<{
+    "onUpdate:width"?: ((value: number) => any) | undefined;
+    "onUpdate:height"?: ((value: number) => any) | undefined;
+    "onMoving-start"?: ((ev: MouseEvent) => any) | undefined;
+    onMoving?: ((size: {
+        width: number;
+        height: number;
+    }, ev: MouseEvent) => any) | undefined;
+    "onMoving-end"?: ((ev: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:width": (value: number) => any;
+    "update:height": (value: number) => any;
+    "moving-start": (ev: MouseEvent) => any;
+    moving: (size: {
+        width: number;
+        height: number;
+    }, ev: MouseEvent) => any;
+    "moving-end": (ev: MouseEvent) => any;
+}, string, {
+    width: number;
+    height: number;
+    component: string;
+    directions: import('./type').ResizeBoxDirection[];
+}, {}, 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').ResizeBoxSlots> & import('./type').ResizeBoxSlots;
+}) & {
+    install: (app: App) => void;
+};
+declare module 'vue' {
+    interface GlobalComponents {
+        YcResizeBox: typeof ResizeBox;
+    }
+}
+export default ResizeBox;

package/es/ResizeBox/index.js

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

package/es/ResizeBox/index.vue.d.ts

@@ -0,0 +1,43 @@
+import { ResizeBoxProps, ResizeBoxSlots, ResizeBoxDirection } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ResizeBoxSlots> & ResizeBoxSlots;
+    refs: {
+        boxRef: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ResizeBoxProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:width": (value: number) => any;
+    "update:height": (value: number) => any;
+    "moving-start": (ev: MouseEvent) => any;
+    moving: (size: {
+        width: number;
+        height: number;
+    }, ev: MouseEvent) => any;
+    "moving-end": (ev: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<ResizeBoxProps> & Readonly<{
+    "onUpdate:width"?: ((value: number) => any) | undefined;
+    "onUpdate:height"?: ((value: number) => any) | undefined;
+    "onMoving-start"?: ((ev: MouseEvent) => any) | undefined;
+    onMoving?: ((size: {
+        width: number;
+        height: number;
+    }, ev: MouseEvent) => any) | undefined;
+    "onMoving-end"?: ((ev: MouseEvent) => any) | undefined;
+}>, {
+    width: number;
+    height: number;
+    component: string;
+    directions: ResizeBoxDirection[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    boxRef: unknown;
+}, any>;
+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/ResizeBox/index.vue.js

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