ep-craft 0.1.26 → 0.1.28

package/dist/components/select-v2/src/group-item2.vue.js

@@ -0,0 +1,33 @@
+import { defineComponent as t } from "vue";
+import { useNamespace as e } 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";
+const y = t({
+  props: {
+    item: {
+      type: Object,
+      required: !0
+    },
+    style: {
+      type: Object
+    },
+    height: Number
+  },
+  setup() {
+    return {
+      ns: e("select")
+    };
+  }
+});
+export {
+  y as default
+};

package/dist/components/select-v2/src/option-item.vue.d.ts

@@ -0,0 +1,66 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly data: ArrayConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly hovering: BooleanConstructor;
+    readonly item: {
+        readonly type: import("vue").PropType<import("./select.types").Option>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly index: NumberConstructor;
+    readonly style: ObjectConstructor;
+    readonly selected: BooleanConstructor;
+    readonly created: BooleanConstructor;
+}>, {
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    contentId: import("vue").Ref<string, string>;
+    mouseMoveEventName: string | null;
+    hoverItem: () => void;
+    handleMousedown: (event: MouseEvent) => void;
+    selectOptionClick: () => void;
+    getLabel: (option: import("./select.types").Option) => any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    hover: (index?: number) => index is number;
+    select: (val: import("./select.types").Option, index?: number) => boolean;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly data: ArrayConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly hovering: BooleanConstructor;
+    readonly item: {
+        readonly type: import("vue").PropType<import("./select.types").Option>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly index: NumberConstructor;
+    readonly style: ObjectConstructor;
+    readonly selected: BooleanConstructor;
+    readonly created: BooleanConstructor;
+}>> & Readonly<{
+    onSelect?: ((val: import("./select.types").Option, index?: number | undefined) => any) | undefined;
+    onHover?: ((index?: number | undefined) => any) | undefined;
+}>, {
+    readonly created: boolean;
+    readonly disabled: boolean;
+    readonly selected: boolean;
+    readonly hovering: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/select-v2/src/option-item.vue.js

@@ -0,0 +1,37 @@
+import i from "./option-item2.vue.js";
+import { openBlock as d, createElementBlock as n, mergeProps as l, toHandlerKey as r, withModifiers as a, renderSlot as t, createElementVNode as m, toDisplayString as p } from "vue";
+import f from "../../../_virtual/_plugin-vue_export-helper.js";
+const u = ["id", "aria-selected", "aria-disabled"];
+function b(e, o, v, $, g, k) {
+  return d(), n("li", l({
+    id: `${e.contentId}-${e.index}`,
+    role: "option",
+    "aria-selected": e.selected,
+    "aria-disabled": e.disabled || void 0,
+    style: e.style,
+    class: [
+      e.ns.be("dropdown", "item"),
+      e.ns.is("selected", e.selected),
+      e.ns.is("disabled", e.disabled),
+      e.ns.is("created", e.created),
+      e.ns.is("hovering", e.hovering)
+    ]
+  }, {
+    [r(e.mouseMoveEventName)]: o[0] || (o[0] = (...s) => e.hoverItem && e.hoverItem(...s))
+  }, {
+    onMousedown: o[1] || (o[1] = (...s) => e.handleMousedown && e.handleMousedown(...s)),
+    onClick: o[2] || (o[2] = a((...s) => e.selectOptionClick && e.selectOptionClick(...s), ["stop"]))
+  }), [
+    t(e.$slots, "default", {
+      item: e.item,
+      index: e.index,
+      disabled: e.disabled
+    }, () => [
+      m("span", null, p(e.getLabel(e.item)), 1)
+    ])
+  ], 16, u);
+}
+const I = /* @__PURE__ */ f(i, [["render", b]]);
+export {
+  I as default
+};

package/dist/components/select-v2/src/option-item2.vue.js

@@ -0,0 +1,46 @@
+import { defineComponent as u, inject as f } from "vue";
+import { useNamespace as d } from "../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import { isIOS as g } from "@vueuse/core";
+import { isFocusable as I } from "../../../utils/dom/aria.js";
+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 { useOption as h } from "./useOption.js";
+import { useProps as v } from "./useProps.js";
+import { optionV2Emits as w, optionV2Props as E } from "./defaults.js";
+import { selectV2InjectionKey as M } from "./token.js";
+const A = u({
+  props: E,
+  emits: w,
+  setup(r, { emit: m }) {
+    const e = f(M), n = d("select"), p = g ? null : "mousemove", { hoverItem: s, selectOptionClick: i } = h(r, { emit: m }), { getLabel: c } = v(e.props), a = e.contentId;
+    return {
+      ns: n,
+      contentId: a,
+      mouseMoveEventName: p,
+      hoverItem: s,
+      handleMousedown: (o) => {
+        let t = o.target;
+        const l = o.currentTarget;
+        for (; t && t !== l; ) {
+          if (I(t))
+            return;
+          t = t.parentElement;
+        }
+        o.preventDefault();
+      },
+      selectOptionClick: i,
+      getLabel: c
+    };
+  }
+});
+export {
+  A as default
+};

package/dist/components/select-v2/src/select-dropdown.d.ts

@@ -0,0 +1,53 @@
+import type { ScrollbarDirection } from '@element-plus/components/scrollbar';
+import type { DynamicSizeListInstance, FixedSizeListInstance } from '@element-plus/components/virtual-list';
+import type { Option } from './select.types';
+import type { ComponentPublicInstance, ComputedRef, ExtractPropTypes, Ref } from 'vue';
+declare const props: {
+    loading: BooleanConstructor;
+    data: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    hoveringIndex: NumberConstructor;
+    width: NumberConstructor;
+    id: StringConstructor;
+    ariaLabel: StringConstructor;
+};
+interface SelectDropdownExposed {
+    listRef: Ref<FixedSizeListInstance | DynamicSizeListInstance | undefined>;
+    isSized: ComputedRef<boolean>;
+    isItemDisabled: (modelValue: any[] | any, selected: boolean) => boolean;
+    isItemHovering: (target: number) => boolean;
+    isItemSelected: (modelValue: any[] | any, target: Option) => boolean;
+    scrollToItem: (index: number) => void;
+    resetScrollTop: () => void;
+}
+export type SelectDropdownInstance = ComponentPublicInstance<ExtractPropTypes<typeof props>, SelectDropdownExposed>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    loading: BooleanConstructor;
+    data: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    hoveringIndex: NumberConstructor;
+    width: NumberConstructor;
+    id: StringConstructor;
+    ariaLabel: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'end-reached': (direction: ScrollbarDirection) => boolean;
+}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    loading: BooleanConstructor;
+    data: {
+        type: ArrayConstructor;
+        required: true;
+    };
+    hoveringIndex: NumberConstructor;
+    width: NumberConstructor;
+    id: StringConstructor;
+    ariaLabel: StringConstructor;
+}>> & Readonly<{
+    "onEnd-reached"?: ((direction: ScrollbarDirection) => any) | undefined;
+}>, {
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/select-v2/src/select-dropdown.js

@@ -0,0 +1,209 @@
+import { defineComponent as Q, inject as W, ref as K, computed as y, watch as X, unref as S, createVNode as l, mergeProps as L, toRaw as Y } from "vue";
+import { get as v } from "lodash-unified";
+import { isUndefined as Z } from "../../../utils/types.js";
+import { isIOS as ee } from "@vueuse/core";
+import { isObject as N } from "@vue/shared";
+import { getEventCode as te } from "../../../utils/dom/event.js";
+import "@element-plus/icons-vue";
+import { EVENT_CODE as oe } from "../../../constants/aria.js";
+import re from "../../virtual-list/src/components/fixed-size-list.js";
+import ie from "../../virtual-list/src/components/dynamic-size-list.js";
+import "../../virtual-list/src/props.js";
+import { useNamespace as ne } from "../../../hooks/use-namespace/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 ae from "./group-item.vue.js";
+import ce from "./option-item.vue.js";
+import { useProps as se } from "./useProps.js";
+import { selectV2InjectionKey as de } from "./token.js";
+import "../../scrollbar/index.js";
+import { scrollbarEmits as me } from "../../scrollbar/src/scrollbar.js";
+const le = {
+  loading: Boolean,
+  data: {
+    type: Array,
+    required: !0
+  },
+  hoveringIndex: Number,
+  width: Number,
+  id: String,
+  ariaLabel: String
+}, qe = /* @__PURE__ */ Q({
+  name: "ElSelectDropdown",
+  props: le,
+  emits: {
+    "end-reached": me["end-reached"]
+  },
+  setup(p, {
+    slots: o,
+    expose: T,
+    emit: k
+  }) {
+    const r = W(de), w = ne("select"), {
+      getLabel: P,
+      getValue: I,
+      getDisabled: R
+    } = se(r.props), A = K([]), u = K(), V = y(() => p.data.length);
+    X(() => V.value, () => {
+      var e, t;
+      (t = (e = r.tooltipRef.value) == null ? void 0 : e.updatePopper) == null || t.call(e);
+    });
+    const f = y(() => Z(r.props.estimatedOptionHeight)), E = y(() => f.value ? {
+      itemSize: r.props.itemHeight
+    } : {
+      estimatedSize: r.props.estimatedOptionHeight,
+      itemSize: (e) => A.value[e]
+    }), j = (e = [], t) => {
+      const {
+        props: {
+          valueKey: i
+        }
+      } = r;
+      return N(t) ? e && e.some((n) => Y(v(n, i)) === v(t, i)) : e.includes(t);
+    }, C = (e, t) => {
+      if (N(t)) {
+        const {
+          valueKey: i
+        } = r.props;
+        return v(e, i) === v(t, i);
+      } else
+        return e === t;
+    }, z = (e, t) => r.props.multiple ? j(e, I(t)) : C(e, I(t)), x = (e, t) => {
+      const {
+        disabled: i,
+        multiple: n,
+        multipleLimit: c
+      } = r.props;
+      return i || !t && (n ? c > 0 && e.length >= c : !1);
+    }, O = (e) => p.hoveringIndex === e;
+    T({
+      listRef: u,
+      isSized: f,
+      isItemDisabled: x,
+      isItemHovering: O,
+      isItemSelected: z,
+      scrollToItem: (e) => {
+        const t = u.value;
+        t && t.scrollToItem(e);
+      },
+      resetScrollTop: () => {
+        const e = u.value;
+        e && e.resetScrollTop();
+      }
+    });
+    const q = (e) => {
+      const {
+        index: t,
+        data: i,
+        style: n
+      } = e, c = S(f), {
+        itemSize: d,
+        estimatedSize: m
+      } = S(E), {
+        modelValue: s
+      } = r.props, {
+        onSelect: h,
+        onHover: b
+      } = r, a = i[t];
+      if (a.type === "Group")
+        return l(ae, {
+          item: a,
+          style: n,
+          height: c ? d : m
+        }, null);
+      const g = z(s, a), _ = x(s, g), $ = O(t);
+      return l(ce, L(e, {
+        selected: g,
+        disabled: R(a) || _,
+        created: !!a.created,
+        hovering: $,
+        item: a,
+        onSelect: h,
+        onHover: b
+      }), {
+        default: (J) => {
+          var D;
+          return ((D = o.default) == null ? void 0 : D.call(o, J)) || l("span", null, [P(a)]);
+        }
+      });
+    }, {
+      onKeyboardNavigate: H,
+      onKeyboardSelect: B
+    } = r, F = () => {
+      H("forward");
+    }, G = () => {
+      H("backward");
+    }, M = (e) => {
+      const t = te(e), {
+        tab: i,
+        esc: n,
+        down: c,
+        up: d,
+        enter: m,
+        numpadEnter: s
+      } = oe;
+      switch ([n, c, d, m, s].includes(t) && (e.preventDefault(), e.stopPropagation()), t) {
+        case i:
+        case n:
+          break;
+        case c:
+          F();
+          break;
+        case d:
+          G();
+          break;
+        case m:
+        case s:
+          B();
+          break;
+      }
+    }, U = (e) => {
+      k("end-reached", e);
+    };
+    return () => {
+      var s, h, b, a;
+      const {
+        data: e,
+        width: t
+      } = p, {
+        height: i,
+        multiple: n,
+        scrollbarAlwaysOn: c
+      } = r.props, d = ee ? !0 : c, m = S(f) ? re : ie;
+      return l("div", {
+        class: [w.b("dropdown"), w.is("multiple", n)],
+        style: {
+          width: `${t}px`
+        }
+      }, [(s = o.header) == null ? void 0 : s.call(o), ((h = o.loading) == null ? void 0 : h.call(o)) || ((b = o.empty) == null ? void 0 : b.call(o)) || l(m, L({
+        ref: u
+      }, S(E), {
+        className: w.be("dropdown", "list"),
+        scrollbarAlwaysOn: d,
+        data: e,
+        height: i,
+        width: t,
+        total: e.length,
+        innerElement: "ul",
+        innerProps: {
+          id: p.id,
+          role: "listbox",
+          "aria-label": p.ariaLabel,
+          "aria-orientation": "vertical"
+        },
+        onEndReached: U,
+        onKeydown: M
+      }), {
+        default: (g) => l(q, g, null)
+      }), (a = o.footer) == null ? void 0 : a.call(o)]);
+    };
+  }
+});
+export {
+  qe as default
+};

package/dist/components/select-v2/src/select.types.d.ts

@@ -1,4 +1,4 @@
-export type OptionCommon = Record<string, any>;
+type OptionCommon = Record<string, any>;
 export type Option = OptionCommon & {
     created?: boolean;
 };
@@ -23,3 +23,4 @@ export type SelectStates = {
     menuVisibleOnFocus: boolean;
     isBeforeHide: boolean;
 };
+export {};