yc-design-vue 1.0.1

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

@@ -0,0 +1,13 @@
+import { Slots } from 'vue';
+type CardContext = {
+    slots: Slots;
+};
+declare const _default: () => {
+    provide: () => {
+        slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+    };
+    inject: () => CardContext;
+};
+export default _default;

package/es/Card/hooks/useContext.js

@@ -0,0 +1,25 @@
+import { useSlots, provide, inject } from "vue";
+const CARD_CONTEXT_KEY = "card-context";
+const useContext = () => {
+  const provide$1 = () => {
+    const slots = useSlots();
+    provide(CARD_CONTEXT_KEY, {
+      slots
+    });
+    return {
+      slots
+    };
+  };
+  const inject$1 = () => {
+    return inject(CARD_CONTEXT_KEY, {
+      slots: {}
+    });
+  };
+  return {
+    provide: provide$1,
+    inject: inject$1
+  };
+};
+export {
+  useContext as default
+};

package/es/Card/index.d.ts

@@ -0,0 +1,106 @@
+import { App } from 'vue';
+import { default as _Card } from './Card.vue';
+import { default as _CardMeta } from './CardMeta.vue';
+import { default as _CardGrid } from './CardGrid.vue';
+export type CardInstance = InstanceType<typeof _Card>;
+export type CardMetaInstance = InstanceType<typeof _CardMeta>;
+export type CardGridInstance = InstanceType<typeof _CardGrid>;
+export * from './type';
+declare const Card: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CardProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('./type').CardSize;
+        loading: boolean;
+        title: string;
+        bordered: boolean;
+        hoverable: boolean;
+        headerStyle: import('vue').CSSProperties;
+        bodyStyle: import('vue').CSSProperties;
+        extra: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./type').CardProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: import('./type').CardSize;
+        loading: boolean;
+        title: string;
+        bordered: boolean;
+        hoverable: boolean;
+        headerStyle: import('vue').CSSProperties;
+        bodyStyle: import('vue').CSSProperties;
+        extra: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./type').CardProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('./type').CardSize;
+    loading: boolean;
+    title: string;
+    bordered: boolean;
+    hoverable: boolean;
+    headerStyle: import('vue').CSSProperties;
+    bodyStyle: import('vue').CSSProperties;
+    extra: string;
+}, {}, 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').CardSlots> & import('./type').CardSlots;
+}) & {
+    meta: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CardMetaProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            title: string;
+            description: string;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').CardMetaProps> & Readonly<{}>, {}, {}, {}, {}, {
+            title: string;
+            description: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').CardMetaProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        title: string;
+        description: string;
+    }, {}, 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').CardMetaSlots> & import('./type').CardMetaSlots;
+    });
+    grid: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./type').CardGridProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            hoverable: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('./type').CardGridProps> & Readonly<{}>, {}, {}, {}, {}, {
+            hoverable: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('./type').CardGridProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        hoverable: 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').CardGridSlots> & import('./type').CardGridSlots;
+    });
+    install: (app: App) => void;
+};
+export { _CardMeta as CardMeta, _CardGrid as CardGrid };
+declare module 'vue' {
+    interface GlobalComponents {
+        YcCard: typeof Card;
+        YcCardMeta: typeof _CardMeta;
+        YcCardGrid: typeof _CardGrid;
+    }
+}
+export default Card;

package/es/Card/index.js

@@ -0,0 +1,17 @@
+import _Card from "./Card.vue.js";
+import CardMeta from "./CardMeta.vue.js";
+import CardGrid from "./CardGrid.vue.js";
+const Card = Object.assign(_Card, {
+  meta: CardMeta,
+  grid: CardGrid,
+  install: (app) => {
+    app.component("Yc" + _Card.name, _Card);
+    app.component("Yc" + CardMeta.name, CardMeta);
+    app.component("Yc" + CardGrid.name, CardGrid);
+  }
+});
+export {
+  CardGrid,
+  CardMeta,
+  Card as default
+};

package/es/Card/type.d.ts

@@ -0,0 +1,34 @@
+import { CSSProperties } from 'vue';
+export interface CardProps {
+    bordered?: boolean;
+    loading?: boolean;
+    hoverable?: boolean;
+    size?: CardSize;
+    headerStyle?: CSSProperties;
+    bodyStyle?: CSSProperties;
+    title?: string;
+    extra?: string;
+}
+export interface CardSlots {
+    actions(): void;
+    cover(): void;
+    extra(): void;
+    title(): void;
+    default(): void;
+}
+export interface CardMetaProps {
+    title?: string;
+    description?: string;
+}
+export interface CardMetaSlots {
+    description(): void;
+    title(): void;
+    avatar(): void;
+}
+export interface CardGridProps {
+    hoverable?: boolean;
+}
+export interface CardGridSlots {
+    default(): void;
+}
+export type CardSize = 'medium' | 'small';

package/es/Carousel/Carousel.vue.d.ts

@@ -0,0 +1,36 @@
+import { CarouselProps, CarouselSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CarouselSlots> & CarouselSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CarouselProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (index: number, preIndex: number, isManual: boolean) => any;
+    "update:current": (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<CarouselProps> & Readonly<{
+    onChange?: ((index: number, preIndex: number, isManual: boolean) => any) | undefined;
+    "onUpdate:current"?: ((index: number) => any) | undefined;
+}>, {
+    trigger: import('./type').IndicatorTrigger;
+    showArrow: import('./type').CarouselShowArrow;
+    arrowClass: import('../_shared/type').ClassName;
+    animationName: import('./type').CarouselAnimationName;
+    direction: import('..').Direction;
+    transitionTimingFunction: string;
+    moveSpeed: number;
+    current: number;
+    defaultCurrent: number;
+    autoPlay: import('./type').AutoPlay;
+    indicatorType: import('./type').IndicatorType;
+    indicatorPosition: import('./type').IndicatorPosition;
+    indicatorClass: import('../_shared/type').ClassName;
+}, {}, {}, {}, 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/Carousel/Carousel.vue.js

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

package/es/Carousel/Carousel.vue2.js

@@ -0,0 +1,131 @@
+import { defineComponent, watch, onBeforeUnmount, createElementBlock, openBlock, normalizeClass, createElementVNode, createCommentVNode, unref, Fragment, renderList, createBlock, resolveDynamicComponent, createVNode } 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 useContext from "./hooks/useContext.js";
+import CarouselArrow from "./CarouselArrow.vue.js";
+import CarouselIndicator from "./CarouselIndicator.vue.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "yc-carousel-indicator-wrapper"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "yc-carousel-arrow-wrapper"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "Carousel"
+  },
+  __name: "Carousel",
+  props: {
+    current: { default: void 0 },
+    defaultCurrent: { default: 1 },
+    autoPlay: { type: [Boolean, Object], default: false },
+    moveSpeed: { default: 500 },
+    animationName: { default: "slide" },
+    trigger: { default: "click" },
+    direction: { default: "horizontal" },
+    showArrow: { default: "always" },
+    arrowClass: { default: "" },
+    indicatorType: { default: "dot" },
+    indicatorPosition: { default: "bottom" },
+    indicatorClass: { default: "" },
+    transitionTimingFunction: { default: "cubic-bezier(0.34, 0.69, 0.1, 1)" }
+  },
+  emits: ["update:current", "change"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { slideTo, computedCurrent, autoPlay, carouselItems } = useContext().provide(props, emits);
+    let autoPlayTimer = null;
+    const setAutoPlay = () => {
+      var _a;
+      if (!autoPlay.value) return;
+      autoPlayTimer = setInterval(
+        () => {
+          slideTo(computedCurrent.value + 1);
+        },
+        ((_a = autoPlay.value) == null ? void 0 : _a.interval) ?? 3e3
+      );
+    };
+    const stopAutoPlay = () => {
+      clearInterval(autoPlayTimer);
+      autoPlayTimer = null;
+    };
+    const handleChange = async (index) => {
+      stopAutoPlay();
+      await slideTo(index);
+      setAutoPlay();
+    };
+    watch(
+      () => autoPlay.value,
+      () => {
+        if (!autoPlay.value) {
+          return stopAutoPlay();
+        }
+        setAutoPlay();
+      },
+      {
+        immediate: true
+      }
+    );
+    onBeforeUnmount(() => {
+      stopAutoPlay();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-carousel",
+          `yc-carousel-animation-${_ctx.animationName}`,
+          {
+            "yc-carousel-indicator-outer": _ctx.indicatorPosition == "outer"
+          }
+        ])
+      }, [
+        createElementVNode("div", {
+          class: normalizeClass(["yc-carousel-slide", `yc-carousel-direction-${_ctx.direction}`]),
+          onMouseenter: _cache[0] || (_cache[0] = ($event) => {
+            var _a;
+            return unref(isObject)(unref(autoPlay)) && ((_a = unref(autoPlay)) == null ? void 0 : _a.hoverToPause) && stopAutoPlay();
+          }),
+          onMouseleave: _cache[1] || (_cache[1] = ($event) => {
+            var _a;
+            return unref(isObject)(unref(autoPlay)) && ((_a = unref(autoPlay)) == null ? void 0 : _a.hoverToPause) && setAutoPlay();
+          })
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(carouselItems), (node, i) => {
+            return openBlock(), createBlock(resolveDynamicComponent(node), {
+              index: i + 1
+            }, null, 8, ["index"]);
+          }), 256))
+        ], 34),
+        _ctx.indicatorType != "never" ? (openBlock(), createElementBlock("div", _hoisted_1, [
+          createVNode(CarouselIndicator, {
+            "indicator-class": _ctx.indicatorClass,
+            trigger: _ctx.trigger,
+            "indicator-position": _ctx.indicatorPosition,
+            "indicator-type": _ctx.indicatorType,
+            onChange: handleChange
+          }, null, 8, ["indicator-class", "trigger", "indicator-position", "indicator-type"])
+        ])) : createCommentVNode("", true),
+        _ctx.showArrow != "never" ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          createVNode(CarouselArrow, {
+            type: "pre",
+            onChange: handleChange
+          }),
+          createVNode(CarouselArrow, {
+            type: "next",
+            onChange: handleChange
+          })
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Carousel/CarouselArrow.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    type: 'pre' | 'next';
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((index: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/es/Carousel/CarouselArrow.vue.js

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

package/es/Carousel/CarouselArrow.vue2.js

@@ -0,0 +1,55 @@
+import { defineComponent, toRefs, computed, createElementBlock, openBlock, normalizeClass, unref, createVNode } 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/IconArrowRight.vue.js";
+import useContext from "./hooks/useContext.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CarouselArrow",
+  props: {
+    type: {}
+  },
+  emits: ["change"],
+  setup(__props) {
+    const props = __props;
+    const { type } = toRefs(props);
+    const { showArrow, direction, arrowClass, computedCurrent } = useContext().inject();
+    const rotate = computed(() => {
+      if (type.value == "next") {
+        return direction.value == "horizontal" ? 0 : 90;
+      } else {
+        return direction.value == "horizontal" ? 180 : -90;
+      }
+    });
+    const positionClass = computed(() => {
+      if (type.value == "next") {
+        return direction.value == "horizontal" ? "yc-carousel-arrow-right" : "yc-carousel-arrow-bottom";
+      } else {
+        return direction.value == "horizontal" ? "yc-carousel-arrow-left" : "yc-carousel-arrow-top";
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-carousel-arrow",
+          positionClass.value,
+          unref(arrowClass),
+          {
+            "yc-carousel-arrow-show-hover": unref(showArrow) == "hover"
+          }
+        ]),
+        onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit(
+          "change",
+          unref(type) == "next" ? unref(computedCurrent) + 1 : unref(computedCurrent) - 1
+        ))
+      }, [
+        createVNode(unref(_sfc_main$1), { rotate: rotate.value }, null, 8, ["rotate"])
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Carousel/CarouselIndicator.vue.d.ts

@@ -0,0 +1,14 @@
+import { IndicatorTrigger, IndicatorType, IndicatorPosition } from './type';
+import { ClassName } from '../_shared/type';
+type __VLS_Props = {
+    trigger: IndicatorTrigger;
+    indicatorType: IndicatorType;
+    indicatorPosition: IndicatorPosition;
+    indicatorClass: ClassName;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (index: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((index: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/es/Carousel/CarouselIndicator.vue.js

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

package/es/Carousel/CarouselIndicator.vue2.js

@@ -0,0 +1,58 @@
+import { defineComponent, createElementBlock, openBlock, normalizeClass, createCommentVNode, Fragment, renderList, unref, normalizeStyle } 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 "../Empty/index.js";
+/* empty css                         */
+import useContext from "./hooks/useContext.js";
+const _hoisted_1 = ["onMouseenter", "onClick"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CarouselIndicator",
+  props: {
+    trigger: {},
+    indicatorType: {},
+    indicatorPosition: {},
+    indicatorClass: {}
+  },
+  emits: ["change"],
+  setup(__props) {
+    const { length, computedCurrent } = useContext().inject();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-carousel-indicator",
+          `yc-carousel-indicator-shape-${_ctx.indicatorType}`,
+          `yc-carousel-indicator-position-${_ctx.indicatorPosition}`,
+          _ctx.indicatorClass
+        ])
+      }, [
+        (openBlock(true), createElementBlock(Fragment, null, renderList(unref(length), (i) => {
+          return openBlock(), createElementBlock("div", {
+            key: i,
+            class: normalizeClass([
+              "yc-carousel-indicator-item",
+              {
+                "yc-carousel-indicator-item-active": unref(computedCurrent) == i
+              }
+            ]),
+            onMouseenter: ($event) => _ctx.trigger == "hover" && unref(computedCurrent) != i && _ctx.$emit("change", i),
+            onClick: ($event) => _ctx.trigger == "click" && unref(computedCurrent) != i && _ctx.$emit("change", i)
+          }, null, 42, _hoisted_1);
+        }), 128)),
+        _ctx.indicatorType == "slider" ? (openBlock(), createElementBlock("div", {
+          key: 0,
+          class: "yc-carousel-indicator-item-slider",
+          style: normalizeStyle({
+            width: ["top", "bottom", "outer"].includes(_ctx.indicatorPosition) ? unref(valueToPx)(48 / unref(length)) : "",
+            height: ["left", "right"].includes(_ctx.indicatorPosition) ? unref(valueToPx)(48 / unref(length)) : "",
+            transform: ["top", "bottom", "outer"].includes(_ctx.indicatorPosition) ? `translateX(calc(${unref(valueToPx)(48 / unref(length) * unref(computedCurrent))} - 100%))` : `translateY(calc(${unref(valueToPx)(48 / unref(length) * unref(computedCurrent))} - 100%))`
+          })
+        }, null, 4)) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/Carousel/CarouselItem.vue.d.ts

@@ -0,0 +1,16 @@
+import { CarouselItemSlots } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<CarouselItemSlots> & CarouselItemSlots;
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/Carousel/CarouselItem.vue.js

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

package/es/Carousel/CarouselItem.vue2.js

@@ -0,0 +1,55 @@
+import { defineComponent, useAttrs, computed, createElementBlock, openBlock, normalizeStyle, normalizeClass, unref, renderSlot } from "vue";
+import useContext from "./hooks/useContext.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "CarouselItem"
+  },
+  __name: "CarouselItem",
+  setup(__props) {
+    const {
+      moveType,
+      preIndex,
+      computedCurrent,
+      direction,
+      moveSpeed,
+      animationName,
+      transitionTimingFunction,
+      getValidIndex
+    } = useContext().inject();
+    const attrs = useAttrs();
+    const index = computed(() => attrs.index);
+    const slideClass = computed(() => {
+      if (animationName.value != "slide" || computedCurrent.value == preIndex.value || preIndex.value != index.value && computedCurrent.value != index.value) {
+        return;
+      }
+      const slideDirection = direction.value == "horizontal" ? "-x" : "-y";
+      const slideType = preIndex.value == index.value ? "-out" : "-in";
+      const siideMoveType = moveType.value == "positive" ? "" : "-reverse";
+      return `yc-carousel-slide${slideDirection}${slideType}${siideMoveType}`;
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([
+          "yc-carousel-item",
+          slideClass.value,
+          {
+            "yc-carousel-item-current": index.value == unref(getValidIndex)(unref(computedCurrent)),
+            "yc-carousel-item-prev": index.value == unref(getValidIndex)(unref(computedCurrent) - 1),
+            "yc-carousel-item-next": index.value == unref(getValidIndex)(unref(computedCurrent) + 1)
+          }
+        ]),
+        style: normalizeStyle({
+          transitionTimingFunction: unref(transitionTimingFunction),
+          animationTimingFunction: unref(transitionTimingFunction),
+          transitionDuration: unref(moveSpeed) + "ms",
+          animationDuration: unref(moveSpeed) + "ms"
+        })
+      }, [
+        renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 6);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { CarouselAnimationName, CarouselEmits, CarouselShowArrow } from '../type';
+import { ClassName, Direction, Props } from '../../_shared/type';
+type CarouselContext = {
+    length: Ref<number>;
+    computedCurrent: Ref<number>;
+    transitionTimingFunction: Ref<string>;
+    animationName: Ref<CarouselAnimationName>;
+    moveType: Ref<MoveType>;
+    preIndex: Ref<number>;
+    moveSpeed: Ref<number>;
+    direction: Ref<Direction>;
+    showArrow: Ref<CarouselShowArrow>;
+    arrowClass: Ref<ClassName>;
+    getValidIndex: (val: number) => number;
+};
+type MoveType = 'positive' | 'negative';
+declare const _default: () => {
+    provide: (props: Props, emits: CarouselEmits) => {
+        carouselItems: import('vue').ComputedRef<import('../../_shared/type').ObjectData[]>;
+        computedCurrent: import('vue').WritableComputedRef<any, number>;
+        length: import('vue').ComputedRef<number>;
+        autoPlay: Ref<import('..').AutoPlay, import('..').AutoPlay>;
+        slideTo: (targetIndex: number) => Promise<void>;
+    };
+    inject: () => CarouselContext;
+};
+export default _default;