ep-craft 0.1.34 → 0.1.36

package/dist/components/timeline-item/EpTimelineItem.vue.d.ts

@@ -0,0 +1,21 @@
+import type { TimelineItemProps } from './timeline-item';
+declare var __VLS_9: {}, __VLS_11: {};
+type __VLS_Slots = {} & {
+    dot?: (props: typeof __VLS_9) => any;
+} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TimelineItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TimelineItemProps> & Readonly<{}>, {
+    size: "normal" | "large";
+    color: string;
+    type: "primary" | "success" | "warning" | "danger" | "info" | "";
+    placement: "top" | "bottom";
+    timestamp: string;
+}, {}, {}, {}, 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/timeline-item/EpTimelineItem.vue.js

@@ -0,0 +1,94 @@
+import { defineComponent as k, inject as E, computed as c, openBlock as l, createElementBlock as i, normalizeClass as m, createElementVNode as r, unref as o, normalizeStyle as h, createBlock as d, withCtx as I, resolveDynamicComponent as C, createCommentVNode as s, renderSlot as p, toDisplayString as u } from "vue";
+import { ElIcon as N } from "../icon/index.js";
+import { useNamespace as T } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+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 { TIMELINE_INJECTION_KEY as B } from "../timeline/tokens.js";
+const q = /* @__PURE__ */ k({
+  name: "EpTimelineItem",
+  __name: "EpTimelineItem",
+  props: {
+    timestamp: { default: "" },
+    hideTimestamp: { type: Boolean },
+    center: { type: Boolean },
+    placement: { default: "bottom" },
+    type: { default: "" },
+    color: { default: "" },
+    size: { default: "normal" },
+    icon: {},
+    hollow: { type: Boolean }
+  },
+  setup(t) {
+    const a = t, { props: f } = E(
+      B
+    ), e = T("timeline-item"), y = c(() => [
+      e.e("node"),
+      e.em("node", a.size || ""),
+      e.em("node", a.type || ""),
+      e.is("hollow", a.hollow)
+    ]), v = c(() => [
+      e.b(),
+      { [e.e("center")]: a.center },
+      e.is(f.mode)
+    ]);
+    return (n, b) => (l(), i("li", {
+      class: m(v.value)
+    }, [
+      r("div", {
+        class: m(o(e).e("tail"))
+      }, null, 2),
+      n.$slots.dot ? s("", !0) : (l(), i("div", {
+        key: 0,
+        class: m(y.value),
+        style: h({
+          backgroundColor: t.color
+        })
+      }, [
+        t.icon ? (l(), d(o(N), {
+          key: 0,
+          class: m(o(e).e("icon"))
+        }, {
+          default: I(() => [
+            (l(), d(C(t.icon)))
+          ]),
+          _: 1
+        }, 8, ["class"])) : s("", !0)
+      ], 6)),
+      n.$slots.dot ? (l(), i("div", {
+        key: 1,
+        class: m(o(e).e("dot"))
+      }, [
+        p(n.$slots, "dot")
+      ], 2)) : s("", !0),
+      r("div", {
+        class: m(o(e).e("wrapper"))
+      }, [
+        !t.hideTimestamp && t.placement === "top" ? (l(), i("div", {
+          key: 0,
+          class: m([o(e).e("timestamp"), o(e).is("top")])
+        }, u(t.timestamp), 3)) : s("", !0),
+        r("div", {
+          class: m(o(e).e("content"))
+        }, [
+          p(n.$slots, "default")
+        ], 2),
+        !t.hideTimestamp && t.placement === "bottom" ? (l(), i("div", {
+          key: 1,
+          class: m([o(e).e("timestamp"), o(e).is("bottom")])
+        }, u(t.timestamp), 3)) : s("", !0)
+      ], 2)
+    ], 2));
+  }
+});
+export {
+  q as default
+};

package/dist/components/timeline-item/EpTimelineItem2.vue.js

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

package/dist/components/timeline-item/index.d.ts

@@ -1,4 +1,14 @@
 import type { Plugin } from 'vue';
-import { ElTimelineItem } from 'element-plus';
-export declare const EpTimelineItem: typeof ElTimelineItem & Plugin;
+import _EpTimelineItem from './EpTimelineItem.vue';
+/**
+ * timeline-item 自持 barrel（vendor-batch-4 产出）。
+ *
+ * 子项通过 `../timeline/tokens` 的字符串键 `TIMELINE_INJECTION_KEY`
+ * 注入父上下文（保留上游字符串键，不改语义）。
+ * 不导出 `ElTimelineItem` 别名。
+ */
+export declare const EpTimelineItem: typeof _EpTimelineItem & Plugin;
 export default EpTimelineItem;
+export { timelineItemProps } from './timeline-item';
+export type { TimelineItemProps, TimelineItemPropsPublic, } from './timeline-item';
+export type { TimelineItemInstance } from './instance';

package/dist/components/timeline-item/index.js

@@ -1,6 +1,10 @@
-import { ElTimelineItem as e } from "element-plus";
 import { withInstall as i } from "../../utils/with-install.js";
-const m = Object.assign({}, e, { name: "EpTimelineItem" }), l = i(m, "ep-timeline-item");
+import m from "./EpTimelineItem.vue.js";
+import "./timeline-item.js";
+const p = i(
+  m,
+  "ep-timeline-item"
+);
 export {
-  l as EpTimelineItem
+  p as EpTimelineItem
 };

package/dist/components/timeline-item/instance.d.ts

@@ -0,0 +1,2 @@
+import type EpTimelineItem from './EpTimelineItem.vue';
+export type TimelineItemInstance = InstanceType<typeof EpTimelineItem> & unknown;

package/dist/components/timeline-item/timeline-item.d.ts

@@ -0,0 +1,63 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { IconPropType } from '@element-plus/utils';
+export interface TimelineItemProps {
+    /**
+     * @description timestamp content
+     */
+    timestamp?: string;
+    /**
+     * @description whether to show timestamp
+     */
+    hideTimestamp?: boolean;
+    /**
+     * @description whether vertically centered
+     */
+    center?: boolean;
+    /**
+     * @description position of timestamp
+     */
+    placement?: 'top' | 'bottom';
+    /**
+     * @description node type
+     */
+    type?: 'primary' | 'success' | 'warning' | 'danger' | 'info' | '';
+    /**
+     * @description background color of node
+     */
+    color?: string;
+    /**
+     * @description node size
+     */
+    size?: 'normal' | 'large';
+    /**
+     * @description icon component
+     */
+    icon?: IconPropType;
+    /**
+     * @description icon is hollow
+     */
+    hollow?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `TimelineItemProps` instead.
+ */
+export declare const timelineItemProps: {
+    readonly timestamp: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly hideTimestamp: BooleanConstructor;
+    readonly center: BooleanConstructor;
+    readonly placement: import("@element-plus/utils").EpPropFinalized<StringConstructor, "bottom" | "top", unknown, "bottom", boolean>;
+    readonly type: import("@element-plus/utils").EpPropFinalized<StringConstructor, "primary" | "success" | "warning" | "info" | "danger", unknown, "", boolean>;
+    readonly color: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly size: import("@element-plus/utils").EpPropFinalized<StringConstructor, "normal" | "large", unknown, "normal", boolean>;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly hollow: BooleanConstructor;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `TimelineItemProps` instead.
+ */
+export type TimelineItemPropsPublic = ExtractPublicPropTypes<typeof timelineItemProps>;

package/dist/components/timeline-item/timeline-item.js

@@ -0,0 +1,64 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { iconPropType as t } from "../../utils/vue/icon.js";
+import "vue";
+import { buildProps as e } from "../../utils/vue/props/runtime.js";
+e({
+  /**
+   * @description timestamp content
+   */
+  timestamp: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description whether to show timestamp
+   */
+  hideTimestamp: Boolean,
+  /**
+   * @description whether vertically centered
+   */
+  center: Boolean,
+  /**
+   * @description position of timestamp
+   */
+  placement: {
+    type: String,
+    values: ["top", "bottom"],
+    default: "bottom"
+  },
+  /**
+   * @description node type
+   */
+  type: {
+    type: String,
+    values: ["primary", "success", "warning", "danger", "info"],
+    default: ""
+  },
+  /**
+   * @description background color of node
+   */
+  color: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description node size
+   */
+  size: {
+    type: String,
+    values: ["normal", "large"],
+    default: "normal"
+  },
+  /**
+   * @description icon component
+   */
+  icon: {
+    type: t
+  },
+  /**
+   * @description icon is hollow
+   */
+  hollow: Boolean
+});

package/dist/components/tour/EpTour.vue.d.ts

@@ -0,0 +1,40 @@
+import type { TourProps } from './tour';
+declare var __VLS_23: {}, __VLS_25: {
+    current: number;
+    total: number;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_23) => any;
+} & {
+    indicators?: (props: typeof __VLS_25) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TourProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => void;
+    change: (current: number) => void;
+    close: (current: number) => void;
+    finish: () => void;
+    "update:current": (current: number) => void;
+}, string, import("vue").PublicProps, Readonly<TourProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onChange?: ((current: number) => any) | undefined;
+    onClose?: ((current: number) => any) | undefined;
+    onFinish?: (() => any) | undefined;
+    "onUpdate:current"?: ((current: number) => any) | undefined;
+}>, {
+    gap: import("./types.js").TourGap;
+    mask: import("./types.js").TourMask;
+    appendTo: string | HTMLElement;
+    placement: import("@floating-ui/dom").Placement;
+    scrollIntoViewOptions: boolean | ScrollIntoViewOptions;
+    showArrow: boolean;
+    closeOnPressEscape: boolean;
+    showClose: boolean;
+    targetAreaClickable: 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/tour/EpTour.vue.js

@@ -0,0 +1,174 @@
+import { defineComponent as K, ref as p, computed as o, toRef as c, watch as d, useSlots as L, provide as R, openBlock as f, createElementBlock as q, Fragment as J, createBlock as T, Teleport as Q, createElementVNode as W, mergeProps as X, createVNode as S, unref as v, normalizeStyle as x, withCtx as b, renderSlot as Y, createCommentVNode as B } from "vue";
+import { useNamespace as ee } from "../../hooks/use-namespace/index.js";
+import { isUndefined as y, isBoolean as te } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { CHANGE_EVENT as oe, UPDATE_MODEL_EVENT as A } from "../../constants/event.js";
+import "@element-plus/icons-vue";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import { useZIndex as re } from "../../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 le from "./EpTourMask.vue.js";
+import ae from "./EpTourContent.vue.js";
+import ne from "./steps.js";
+import { tourEmits as se } from "./tour.js";
+import { useTarget as ue, tourKey as ce } from "./helper.js";
+const Ae = /* @__PURE__ */ K({
+  name: "EpTour",
+  inheritAttrs: !1,
+  __name: "EpTour",
+  props: {
+    modelValue: { type: Boolean },
+    current: {},
+    showArrow: { type: Boolean, default: !0 },
+    showClose: { type: Boolean, default: !0 },
+    closeIcon: {},
+    placement: { default: "bottom" },
+    contentStyle: {},
+    mask: { type: [Boolean, Object], default: !0 },
+    gap: { default: () => ({ offset: 6, radius: 2 }) },
+    zIndex: {},
+    scrollIntoViewOptions: { type: Boolean, default: () => ({ block: "center" }) },
+    type: {},
+    appendTo: { default: "body" },
+    closeOnPressEscape: { type: Boolean, default: !0 },
+    targetAreaClickable: { type: Boolean, default: !0 }
+  },
+  emits: se,
+  setup(n, { emit: O }) {
+    const t = n, a = O, m = ee("tour"), g = p(0), r = p(), w = o(() => !y(t.current)), s = p(t.current ?? 0), l = o({
+      get() {
+        return y(t.current) ? s.value : t.current;
+      },
+      set(e) {
+        (w.value ? t.current : s.value) !== e && (w.value || (s.value = e), a("update:current", e));
+      }
+    }), h = o(() => {
+      var e;
+      return (e = r.value) == null ? void 0 : e.target;
+    }), z = o(() => [
+      m.b(),
+      E.value === "primary" ? m.m("primary") : ""
+    ]), N = o(
+      () => {
+        var e;
+        return ((e = r.value) == null ? void 0 : e.placement) || t.placement;
+      }
+    ), _ = o(
+      () => {
+        var e;
+        return ((e = r.value) == null ? void 0 : e.contentStyle) ?? t.contentStyle;
+      }
+    ), u = o(() => {
+      var e;
+      return ((e = r.value) == null ? void 0 : e.mask) ?? t.mask;
+    }), P = o(() => !!u.value && t.modelValue), k = o(
+      () => te(u.value) ? void 0 : u.value
+    ), M = o(
+      () => {
+        var e;
+        return !!h.value && (((e = r.value) == null ? void 0 : e.showArrow) ?? t.showArrow);
+      }
+    ), Z = o(
+      () => {
+        var e;
+        return ((e = r.value) == null ? void 0 : e.scrollIntoViewOptions) ?? t.scrollIntoViewOptions;
+      }
+    ), E = o(() => {
+      var e;
+      return ((e = r.value) == null ? void 0 : e.type) ?? t.type;
+    }), { nextZIndex: $ } = re(), U = $(), V = o(() => t.zIndex ?? U), { mergedPosInfo: D, triggerTarget: F } = ue(
+      h,
+      c(t, "modelValue"),
+      c(t, "gap"),
+      u,
+      Z
+    );
+    d(
+      () => t.current,
+      (e) => !y(e) && (s.value = e)
+    ), d(
+      l,
+      (e, i) => {
+        !t.modelValue || e === i || a(oe, e);
+      },
+      { flush: "post" }
+    ), d(
+      () => t.modelValue,
+      (e) => {
+        !e && l.value !== 0 && (l.value = 0);
+      }
+    );
+    const j = () => {
+      t.closeOnPressEscape && (a(A, !1), a("close", l.value));
+    }, G = (e) => {
+      g.value = e;
+    }, H = L();
+    return R(ce, {
+      currentStep: r,
+      current: l,
+      total: g,
+      showClose: c(t, "showClose"),
+      closeIcon: c(t, "closeIcon"),
+      mergedType: E,
+      ns: m,
+      slots: H,
+      updateModelValue(e) {
+        a(A, e);
+      },
+      onClose() {
+        a("close", l.value);
+      },
+      onFinish() {
+        a("finish");
+      }
+    }), (e, i) => {
+      var C, I;
+      return f(), q(J, null, [
+        (f(), T(Q, { to: n.appendTo }, [
+          W("div", X({ class: z.value }, e.$attrs), [
+            S(le, {
+              visible: P.value,
+              fill: (C = k.value) == null ? void 0 : C.color,
+              style: x((I = k.value) == null ? void 0 : I.style),
+              pos: v(D),
+              "z-index": V.value,
+              "target-area-clickable": n.targetAreaClickable
+            }, null, 8, ["visible", "fill", "style", "pos", "z-index", "target-area-clickable"]),
+            n.modelValue ? (f(), T(ae, {
+              key: l.value,
+              reference: v(F),
+              placement: N.value,
+              "show-arrow": M.value,
+              "z-index": V.value,
+              style: x(_.value),
+              onClose: j
+            }, {
+              default: b(() => [
+                S(v(ne), {
+                  current: l.value,
+                  onUpdateTotal: G
+                }, {
+                  default: b(() => [
+                    Y(e.$slots, "default")
+                  ]),
+                  _: 3
+                }, 8, ["current"])
+              ]),
+              _: 3
+            }, 8, ["reference", "placement", "show-arrow", "z-index", "style"])) : B("", !0)
+          ], 16)
+        ], 8, ["to"])),
+        B("", !0)
+      ], 64);
+    };
+  }
+});
+export {
+  Ae as default
+};

package/dist/components/tour/EpTour2.vue.js

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

package/dist/components/tour/EpTourContent.vue.d.ts

@@ -0,0 +1,23 @@
+import type { TourContentProps } from './content';
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<TourContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => void;
+}, string, import("vue").PublicProps, Readonly<TourContentProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    zIndex: number;
+    offset: number;
+    placement: import("@floating-ui/dom").Placement;
+    strategy: import("@floating-ui/dom").Strategy;
+    reference: HTMLElement | import("@floating-ui/dom").VirtualElement | null;
+}, {}, {}, {}, 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/tour/EpTourContent.vue.js

@@ -0,0 +1,72 @@
+import { defineComponent as k, ref as n, watch as x, toRef as r, computed as E, inject as g, openBlock as f, createElementBlock as p, normalizeClass as d, unref as t, normalizeStyle as m, createVNode as z, withCtx as S, renderSlot as b, createCommentVNode as A } from "vue";
+import { EpFocusTrap as B } from "../focus-trap/index.js";
+import { tourContentEmits as F } from "./content.js";
+import { useFloating as T, tourKey as q } from "./helper.js";
+const I = ["data-side"], P = /* @__PURE__ */ k({
+  name: "EpTourContent",
+  __name: "EpTourContent",
+  props: {
+    placement: { default: "bottom" },
+    reference: { default: null },
+    strategy: { default: "absolute" },
+    offset: { default: 10 },
+    showArrow: { type: Boolean },
+    zIndex: { default: 2001 }
+  },
+  emits: F,
+  setup(l, { emit: i }) {
+    const e = l, y = i, s = n(e.placement), w = n(e.strategy), a = n(null), c = n(null);
+    x(
+      () => e.placement,
+      () => {
+        s.value = e.placement;
+      }
+    );
+    const { contentStyle: R, arrowStyle: C } = T(
+      r(e, "reference"),
+      a,
+      c,
+      s,
+      w,
+      r(e, "offset"),
+      r(e, "zIndex"),
+      r(e, "showArrow")
+    ), _ = E(() => s.value.split("-")[0]), { ns: u } = g(q), h = () => {
+      y("close");
+    }, v = (o) => {
+      o.detail.focusReason === "pointer" && o.preventDefault();
+    };
+    return (o, N) => (f(), p("div", {
+      ref_key: "contentRef",
+      ref: a,
+      style: m(t(R)),
+      class: d(t(u).e("content")),
+      "data-side": _.value,
+      tabindex: "-1"
+    }, [
+      z(t(B), {
+        loop: "",
+        trapped: "",
+        "focus-start-el": "container",
+        "focus-trap-el": a.value || void 0,
+        onReleaseRequested: h,
+        onFocusoutPrevented: v
+      }, {
+        default: S(() => [
+          b(o.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["focus-trap-el"]),
+      l.showArrow ? (f(), p("span", {
+        key: 0,
+        ref_key: "arrowRef",
+        ref: c,
+        style: m(t(C)),
+        class: d(t(u).e("arrow"))
+      }, null, 6)) : A("", !0)
+    ], 14, I));
+  }
+});
+export {
+  P as default
+};

package/dist/components/tour/EpTourContent2.vue.js

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

package/dist/components/tour/EpTourMask.vue.d.ts

@@ -0,0 +1,7 @@
+import type { MaskProps } from './mask';
+declare const _default: import("vue").DefineComponent<MaskProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MaskProps> & Readonly<{}>, {
+    fill: string;
+    zIndex: number;
+    targetAreaClickable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;