ep-craft 0.1.34 → 0.1.35

package/dist/components/carousel/EpCarousel.vue.d.ts

@@ -0,0 +1,39 @@
+import type { CarouselProps } from './carousel';
+declare var __VLS_29: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CarouselProps, {
+    /** @description active slide index */
+    activeIndex: import("vue").WritableComputedRef<number, number>;
+    /** @description manually switch slide, index of the slide to be switched to, starting from 0; or the `name` of corresponding `el-carousel-item` */
+    setActiveItem: (index: number | string) => void;
+    /** @description switch to the previous slide */
+    prev: () => void;
+    /** @description switch to the next slide */
+    next: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number, prev: number) => void;
+}, string, import("vue").PublicProps, Readonly<CarouselProps> & Readonly<{
+    onChange?: ((current: number, prev: number) => any) | undefined;
+}>, {
+    direction: "horizontal" | "vertical";
+    height: string;
+    type: "" | "card";
+    arrow: "always" | "hover" | "never";
+    trigger: "hover" | "click";
+    loop: boolean;
+    initialIndex: number;
+    autoplay: boolean;
+    interval: number;
+    indicatorPosition: "" | "none" | "outside";
+    cardScale: number;
+    pauseOnHover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/carousel/EpCarousel.vue.js

@@ -0,0 +1,227 @@
+import { defineComponent as te, computed as L, unref as e, openBlock as s, createElementBlock as c, withModifiers as f, normalizeClass as u, createBlock as A, Transition as N, withCtx as v, withDirectives as C, createElementVNode as n, createVNode as m, vShow as k, createCommentVNode as h, normalizeStyle as oe, renderSlot as re, Fragment as ie, renderList as ne, toDisplayString as ae } from "vue";
+import { ElIcon as x } from "../icon/index.js";
+import { ArrowLeft as se, ArrowRight as le } from "@element-plus/icons-vue";
+import { useNamespace as ue } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { useLocale as de } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { carouselEmits as ce } from "./carousel.js";
+import { useCarousel as me } from "./use-carousel.js";
+const pe = ["aria-label"], fe = ["aria-label"], ve = ["onMouseenter", "onClick"], he = ["aria-label"], we = { key: 0 }, ye = {
+  key: 2,
+  xmlns: "http://www.w3.org/2000/svg",
+  version: "1.1",
+  style: { display: "none" }
+}, P = "EpCarousel", Ve = /* @__PURE__ */ te({
+  name: P,
+  __name: "EpCarousel",
+  props: {
+    initialIndex: { default: 0 },
+    height: { default: "" },
+    trigger: { default: "hover" },
+    autoplay: { type: Boolean, default: !0 },
+    interval: { default: 3e3 },
+    indicatorPosition: { default: "" },
+    arrow: { default: "hover" },
+    type: { default: "" },
+    cardScale: { default: 0.83 },
+    loop: { type: Boolean, default: !0 },
+    direction: { default: "horizontal" },
+    pauseOnHover: { type: Boolean, default: !0 },
+    motionBlur: { type: Boolean }
+  },
+  emits: ce,
+  setup(a, { expose: D, emit: V }) {
+    const l = a, z = V, {
+      root: G,
+      activeIndex: p,
+      exposeActiveIndex: H,
+      arrowDisplay: b,
+      hasLabel: B,
+      hover: M,
+      isCardType: O,
+      items: E,
+      isVertical: w,
+      containerStyle: F,
+      handleButtonEnter: S,
+      handleButtonLeave: y,
+      handleIndicatorClick: R,
+      handleMouseEnter: $,
+      handleMouseLeave: I,
+      setActiveItem: j,
+      prev: q,
+      next: J,
+      PlaceholderItem: K,
+      isTwoLengthShow: Q,
+      ItemsSorter: U,
+      throttledArrowClick: T,
+      throttledIndicatorHover: W
+    } = me(l, z, P), t = ue("carousel"), { t: g } = de(), X = L(() => {
+      const r = [t.b(), t.m(l.direction)];
+      return e(O) && r.push(t.m("card")), r.push(
+        t.is(
+          "vertical-outside",
+          e(w) && l.indicatorPosition === "outside"
+        )
+      ), r;
+    }), Y = L(() => {
+      const r = [t.e("indicators"), t.em("indicators", l.direction)];
+      return e(B) && r.push(t.em("indicators", "labels")), l.indicatorPosition === "outside" && r.push(t.em("indicators", "outside")), e(w) && r.push(t.em("indicators", "right")), r;
+    });
+    function Z(r) {
+      if (!l.motionBlur) return;
+      const o = e(w) ? `${t.namespace.value}-transitioning-vertical` : `${t.namespace.value}-transitioning`;
+      r.currentTarget.classList.add(o);
+    }
+    function _(r) {
+      if (!l.motionBlur) return;
+      const o = e(w) ? `${t.namespace.value}-transitioning-vertical` : `${t.namespace.value}-transitioning`;
+      r.currentTarget.classList.remove(o);
+    }
+    return D({
+      /** @description active slide index */
+      activeIndex: H,
+      /** @description manually switch slide, index of the slide to be switched to, starting from 0; or the `name` of corresponding `el-carousel-item` */
+      setActiveItem: j,
+      /** @description switch to the previous slide */
+      prev: q,
+      /** @description switch to the next slide */
+      next: J
+    }), (r, o) => (s(), c("div", {
+      ref_key: "root",
+      ref: G,
+      class: u(X.value),
+      onMouseenter: o[6] || (o[6] = f(
+        //@ts-ignore
+        (...i) => e($) && e($)(...i),
+        ["stop"]
+      )),
+      onMouseleave: o[7] || (o[7] = f(
+        //@ts-ignore
+        (...i) => e(I) && e(I)(...i),
+        ["stop"]
+      ))
+    }, [
+      e(b) ? (s(), A(N, {
+        key: 0,
+        name: "carousel-arrow-left"
+      }, {
+        default: v(() => [
+          C(n("button", {
+            type: "button",
+            class: u([e(t).e("arrow"), e(t).em("arrow", "left")]),
+            "aria-label": e(g)("el.carousel.leftArrow"),
+            onMouseenter: o[0] || (o[0] = (i) => e(S)("left")),
+            onMouseleave: o[1] || (o[1] = //@ts-ignore
+            (...i) => e(y) && e(y)(...i)),
+            onClick: o[2] || (o[2] = f((i) => e(T)(e(p) - 1), ["stop"]))
+          }, [
+            m(e(x), null, {
+              default: v(() => [
+                m(e(se))
+              ]),
+              _: 1
+            })
+          ], 42, pe), [
+            [k, (a.arrow === "always" || e(M)) && (a.loop || e(p) > 0)]
+          ])
+        ]),
+        _: 1
+      })) : h("", !0),
+      e(b) ? (s(), A(N, {
+        key: 1,
+        name: "carousel-arrow-right"
+      }, {
+        default: v(() => [
+          C(n("button", {
+            type: "button",
+            class: u([e(t).e("arrow"), e(t).em("arrow", "right")]),
+            "aria-label": e(g)("el.carousel.rightArrow"),
+            onMouseenter: o[3] || (o[3] = (i) => e(S)("right")),
+            onMouseleave: o[4] || (o[4] = //@ts-ignore
+            (...i) => e(y) && e(y)(...i)),
+            onClick: o[5] || (o[5] = f((i) => e(T)(e(p) + 1), ["stop"]))
+          }, [
+            m(e(x), null, {
+              default: v(() => [
+                m(e(le))
+              ]),
+              _: 1
+            })
+          ], 42, fe), [
+            [
+              k,
+              (a.arrow === "always" || e(M)) && (a.loop || e(p) < e(E).length - 1)
+            ]
+          ])
+        ]),
+        _: 1
+      })) : h("", !0),
+      n("div", {
+        class: u(e(t).e("container")),
+        style: oe(e(F)),
+        onTransitionstart: Z,
+        onTransitionend: _
+      }, [
+        m(e(K)),
+        re(r.$slots, "default")
+      ], 38),
+      m(e(U), null, {
+        default: v(() => [
+          a.indicatorPosition !== "none" ? (s(), c("ul", {
+            key: 0,
+            class: u(Y.value)
+          }, [
+            (s(!0), c(ie, null, ne(e(E), (i, d) => C((s(), c("li", {
+              key: d,
+              class: u([
+                e(t).e("indicator"),
+                e(t).em("indicator", a.direction),
+                e(t).is("active", d === e(p))
+              ]),
+              onMouseenter: (ee) => e(W)(d),
+              onClick: f((ee) => e(R)(d), ["stop"])
+            }, [
+              n("button", {
+                class: u(e(t).e("button")),
+                "aria-label": e(g)("el.carousel.indicator", { index: d + 1 })
+              }, [
+                e(B) ? (s(), c("span", we, ae(i.props.label), 1)) : h("", !0)
+              ], 10, he)
+            ], 42, ve)), [
+              [k, e(Q)(d)]
+            ])), 128))
+          ], 2)) : h("", !0)
+        ]),
+        _: 1
+      }),
+      a.motionBlur ? (s(), c("svg", ye, [...o[8] || (o[8] = [
+        n("defs", null, [
+          n("filter", { id: "elCarouselHorizontal" }, [
+            n("feGaussianBlur", {
+              in: "SourceGraphic",
+              stdDeviation: "12,0"
+            })
+          ]),
+          n("filter", { id: "elCarouselVertical" }, [
+            n("feGaussianBlur", {
+              in: "SourceGraphic",
+              stdDeviation: "0,10"
+            })
+          ])
+        ], -1)
+      ])])) : h("", !0)
+    ], 34));
+  }
+});
+export {
+  Ve as default
+};

package/dist/components/carousel/EpCarousel2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpCarousel.vue.js";
+export {
+  f as default
+};

package/dist/components/carousel/carousel.d.ts

@@ -0,0 +1,86 @@
+import type { ExtractPublicPropTypes } from 'vue';
+export interface CarouselProps {
+    /**
+     * @description index of the initially active slide (starting from 0)
+     */
+    initialIndex?: number;
+    /**
+     * @description height of the carousel
+     */
+    height?: string;
+    /**
+     * @description how indicators are triggered
+     */
+    trigger?: 'hover' | 'click';
+    /**
+     * @description whether automatically loop the slides
+     */
+    autoplay?: boolean;
+    /**
+     * @description interval of the auto loop, in milliseconds
+     */
+    interval?: number;
+    /**
+     * @description position of the indicators
+     */
+    indicatorPosition?: '' | 'none' | 'outside';
+    /**
+     * @description when arrows are shown
+     */
+    arrow?: 'always' | 'hover' | 'never';
+    /**
+     * @description type of the Carousel
+     */
+    type?: '' | 'card';
+    /**
+     * @description when type is card, scaled size of secondary cards
+     */
+    cardScale?: number;
+    /**
+     * @description display the items in loop
+     */
+    loop?: boolean;
+    /**
+     * @description display direction
+     */
+    direction?: 'horizontal' | 'vertical';
+    /**
+     * @description pause autoplay when hover
+     */
+    pauseOnHover?: boolean;
+    /**
+     * @description infuse dynamism and smoothness into the carousel
+     */
+    motionBlur?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `CarouselProps` instead.
+ */
+export declare const carouselProps: {
+    readonly initialIndex: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly height: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly trigger: import("@element-plus/utils").EpPropFinalized<StringConstructor, "click" | "hover", unknown, "hover", boolean>;
+    readonly autoplay: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly interval: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly indicatorPosition: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "none" | "outside", unknown, "", boolean>;
+    readonly arrow: import("@element-plus/utils").EpPropFinalized<StringConstructor, "always" | "never" | "hover", unknown, "hover", boolean>;
+    readonly type: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "card", unknown, "", boolean>;
+    readonly cardScale: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.83, boolean>;
+    readonly loop: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;
+    readonly pauseOnHover: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly motionBlur: BooleanConstructor;
+};
+export declare const carouselEmits: {
+    /**
+     * @description triggers when the active slide switches
+     * @param current index of the new active slide
+     * @param prev index of the old active slide
+     */
+    change: (current: number, prev: number) => boolean;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `CarouselProps` instead.
+ */
+export type CarouselPropsPublic = ExtractPublicPropTypes<typeof carouselProps>;
+export type CarouselEmits = typeof carouselEmits;

package/dist/components/carousel/carousel.js

@@ -0,0 +1,113 @@
+import { isNumber as r } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import "@element-plus/icons-vue";
+import { buildProps as o } from "../../utils/vue/props/runtime.js";
+import "vue";
+const s = o({
+  /**
+   * @description index of the initially active slide (starting from 0)
+   */
+  initialIndex: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description height of the carousel
+   */
+  height: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description how indicators are triggered
+   */
+  trigger: {
+    type: String,
+    values: ["hover", "click"],
+    default: "hover"
+  },
+  /**
+   * @description whether automatically loop the slides
+   */
+  autoplay: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description interval of the auto loop, in milliseconds
+   */
+  interval: {
+    type: Number,
+    default: 3e3
+  },
+  /**
+   * @description position of the indicators
+   */
+  indicatorPosition: {
+    type: String,
+    values: ["", "none", "outside"],
+    default: ""
+  },
+  /**
+   * @description when arrows are shown
+   */
+  arrow: {
+    type: String,
+    values: ["always", "hover", "never"],
+    default: "hover"
+  },
+  /**
+   * @description type of the Carousel
+   */
+  type: {
+    type: String,
+    values: ["", "card"],
+    default: ""
+  },
+  /**
+   * @description when type is card, scaled size of secondary cards
+   */
+  cardScale: {
+    type: Number,
+    default: 0.83
+  },
+  /**
+   * @description display the items in loop
+   */
+  loop: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description display direction
+   */
+  direction: {
+    type: String,
+    values: ["horizontal", "vertical"],
+    default: "horizontal"
+  },
+  /**
+   * @description pause autoplay when hover
+   */
+  pauseOnHover: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description infuse dynamism and smoothness into the carousel
+   */
+  motionBlur: Boolean
+}), y = {
+  /**
+   * @description triggers when the active slide switches
+   * @param current index of the new active slide
+   * @param prev index of the old active slide
+   */
+  change: (e, t) => [e, t].every(r)
+};
+export {
+  y as carouselEmits,
+  s as carouselProps
+};

package/dist/components/carousel/constants.d.ts

@@ -0,0 +1,32 @@
+import type { InjectionKey, Ref, VNode } from 'vue';
+import type { CarouselItemProps } from '../carousel-item/carousel-item';
+export type CarouselItemStates = {
+    hover: boolean;
+    translate: number;
+    scale: number;
+    active: boolean;
+    ready: boolean;
+    inStage: boolean;
+    animating: boolean;
+};
+export type CarouselItemContext = {
+    props: Required<CarouselItemProps>;
+    states: CarouselItemStates;
+    uid: number;
+    getVnode: () => VNode;
+    translateItem: (index: number, activeIndex: number, oldIndex?: number) => void;
+};
+export type CarouselContext = {
+    root: Ref<HTMLElement | undefined>;
+    items: Ref<CarouselItemContext[]>;
+    isCardType: Ref<boolean>;
+    isVertical: Ref<boolean>;
+    loop: boolean;
+    cardScale: number;
+    addItem: (item: CarouselItemContext) => void;
+    removeItem: (item: CarouselItemContext) => void;
+    setActiveItem: (index: number) => void;
+    setContainerHeight: (height: number) => void;
+};
+export declare const carouselContextKey: InjectionKey<CarouselContext>;
+export declare const CAROUSEL_ITEM_NAME = "EpCarouselItem";

package/dist/components/carousel/constants.js

@@ -0,0 +1,5 @@
+const e = Symbol("carouselContextKey"), o = "EpCarouselItem";
+export {
+  o as CAROUSEL_ITEM_NAME,
+  e as carouselContextKey
+};

package/dist/components/carousel/index.d.ts

@@ -1,4 +1,30 @@
 import type { Plugin } from 'vue';
-import { ElCarousel } from 'element-plus';
-export declare const EpCarousel: typeof ElCarousel & Plugin;
+import _EpCarousel from './EpCarousel.vue';
+import { EpCarouselItem } from '../carousel-item';
+/**
+ * carousel 自持 barrel（vendor-batch-2 产出）。
+ *
+ * 子项识别契约：`useCarousel` 以 `CAROUSEL_ITEM_NAME` 调用
+ * `useOrderedChildren` 并过滤 `PlaceholderItem` 的插槽，子项 `EpCarouselItem.vue`
+ * 的 `defineOptions({ name })` 取同一常量（`'EpCarouselItem'`）。两侧不得各自
+ * 维护字面量。
+ *
+ * `.CarouselItem` 是对外公开面的一部分（迁移前包装态经 `Object.assign`
+ * 继承自上游），此处以同一形态挂载**本地已安装子项**。
+ *
+ * `carouselContextKey` 是本地 Symbol：使用方若要 `inject` 父上下文，必须用
+ * 这里的导出，拿 element-plus 的同名 Symbol 会静默失效。
+ *
+ * 不导出 `ElCarousel` / `ElCarouselItem` 别名。
+ */
+export declare const EpCarousel: typeof _EpCarousel & Plugin & {
+    CarouselItem: typeof EpCarouselItem;
+};
 export default EpCarousel;
+export { CAROUSEL_ITEM_NAME, carouselContextKey } from './constants';
+export { carouselEmits, carouselProps } from './carousel';
+export { carouselItemProps } from '../carousel-item';
+export type { CarouselEmits, CarouselProps, CarouselPropsPublic, } from './carousel';
+export type { CarouselContext, CarouselItemContext, CarouselItemStates, } from './constants';
+export type { CarouselInstance, CarouselItemInstance } from './instance';
+export type { CarouselItemProps, CarouselItemPropsPublic, } from '../carousel-item';

package/dist/components/carousel/index.js

@@ -1,6 +1,13 @@
-import { ElCarousel as o } from "element-plus";
-import { withInstall as r } from "../../utils/with-install.js";
-const s = Object.assign({}, o, { name: "EpCarousel" }), l = r(s, "ep-carousel");
+import { withInstall as o } from "../../utils/with-install.js";
+import r from "./EpCarousel.vue.js";
+import { EpCarouselItem as s } from "../carousel-item/index.js";
+import { carouselEmits as i, carouselProps as c } from "./carousel.js";
+const a = Object.assign(
+  o(r, "ep-carousel"),
+  { CarouselItem: s }
+);
 export {
-  l as EpCarousel
+  a as EpCarousel,
+  i as carouselEmits,
+  c as carouselProps
 };

package/dist/components/carousel/instance.d.ts

@@ -0,0 +1,8 @@
+import type EpCarousel from './EpCarousel.vue';
+import type EpCarouselItem from '../carousel-item/EpCarouselItem.vue';
+/**
+ * 实例类型（源文件为纯类型模块，按上游 `instance.d.ts` 还原）。
+ * 本地父项 / 子项分处两个目录，故两处引用各自指向本地 SFC。
+ */
+export type CarouselInstance = InstanceType<typeof EpCarousel> & unknown;
+export type CarouselItemInstance = InstanceType<typeof EpCarouselItem> & unknown;

package/dist/components/carousel/use-carousel.d.ts

@@ -0,0 +1,41 @@
+import type { SetupContext } from 'vue';
+import type { DebouncedFunc } from 'lodash-unified';
+import type { CarouselItemContext } from './constants';
+import type { CarouselEmits, CarouselProps } from './carousel';
+export declare const useCarousel: (props: Required<CarouselProps>, emit: SetupContext<CarouselEmits>["emit"], componentName: string) => {
+    root: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+    activeIndex: import("vue").Ref<number, number>;
+    exposeActiveIndex: import("vue").WritableComputedRef<number, number>;
+    arrowDisplay: import("vue").ComputedRef<boolean>;
+    hasLabel: import("vue").ComputedRef<boolean>;
+    hover: import("vue").Ref<boolean, boolean>;
+    isCardType: import("vue").ComputedRef<boolean>;
+    items: import("vue").ShallowRef<CarouselItemContext[], CarouselItemContext[]>;
+    isVertical: import("vue").ComputedRef<boolean>;
+    containerStyle: import("vue").ComputedRef<{
+        height: string;
+        overflow?: undefined;
+    } | {
+        height: string;
+        overflow: string;
+    }>;
+    isItemsTwoLength: import("vue").Ref<boolean, boolean>;
+    handleButtonEnter: (arrow: "left" | "right") => void;
+    handleButtonLeave: () => void;
+    handleIndicatorClick: (index: number) => void;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    setActiveItem: (index: number | string) => void;
+    prev: () => void;
+    next: () => void;
+    PlaceholderItem: () => ({
+        [name: string]: unknown;
+        $stable?: boolean;
+    } | import("@element-plus/utils").VNodeChildAtom)[] | null;
+    isTwoLengthShow: (index: number) => boolean;
+    ItemsSorter: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    throttledArrowClick: DebouncedFunc<(index: number) => void>;
+    throttledIndicatorHover: DebouncedFunc<(index: number) => void>;
+};