ep-craft 0.1.7 → 0.1.9

package/dist/node_modules/element-plus/es/components/select-v2/src/defaults.js

@@ -0,0 +1,357 @@
+import { CHANGE_EVENT as i, UPDATE_MODEL_EVENT as n } from "../../../constants/event.js";
+import { isBoolean as u, isNumber as l } from "../../../utils/types.js";
+import { buildProps as p, definePropType as t } from "../../../utils/vue/props/runtime.js";
+import { iconPropType as r } from "../../../utils/vue/icon.js";
+import { useSizeProp as s } from "../../../hooks/use-size/index.js";
+import { useEmptyValuesProps as d } from "../../../hooks/use-empty-values/index.js";
+import { useAriaProps as f } from "../../../hooks/use-aria/index.js";
+import { useTooltipContentProps as o } from "../../tooltip/src/content.js";
+import { scrollbarEmits as m } from "../../scrollbar/src/scrollbar.js";
+import { tagProps as a } from "../../tag/src/tag.js";
+import { defaultProps as c } from "./useProps.js";
+import { ArrowDown as y, CircleClose as b } from "../../../../../@element-plus/icons-vue/dist/index.js";
+import { placements as g } from "../../../../../@popperjs/core/dist/index.js";
+const _ = p({
+  /**
+  * @description whether creating new items is allowed. To use this, `filterable` must be true
+  */
+  allowCreate: Boolean,
+  /**
+  * @description autocomplete of select input
+  */
+  autocomplete: {
+    type: t(String),
+    default: "none"
+  },
+  /**
+  * @description for non-filterable Select, this prop decides if the option menu pops up when the input is focused
+  */
+  automaticDropdown: Boolean,
+  /**
+  * @description whether select can be cleared
+  */
+  clearable: Boolean,
+  /**
+  * @description custom clear icon
+  */
+  clearIcon: {
+    type: r,
+    default: b
+  },
+  /**
+  * @description tooltip theme, built-in theme: `dark` / `light`
+  */
+  effect: {
+    type: t(String),
+    default: "light"
+  },
+  /**
+  * @description whether to collapse tags to a text when multiple selecting
+  */
+  collapseTags: Boolean,
+  /**
+  * @description whether show all selected tags when mouse hover text of collapse-tags. To use this, `collapse-tags` must be true
+  */
+  collapseTagsTooltip: Boolean,
+  /**
+  * @description configuration object for the collapse-tags tooltip. To use this, `collapse-tags` and `collapse-tags-tooltip` must be true
+  */
+  tagTooltip: {
+    type: t(Object),
+    default: () => ({})
+  },
+  /**
+  * @description The max tags number to be shown. To use this, `collapse-tags` must be true
+  */
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  /**
+  * @description
+  */
+  defaultFirstOption: Boolean,
+  /**
+  * @description is disabled
+  */
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  /**
+  * @description Estimated item height for variable option sizes. Defaults to fixed `itemHeight` when omitted.
+  */
+  estimatedOptionHeight: {
+    type: Number,
+    default: void 0
+  },
+  /**
+  * @description whether Select is filterable
+  */
+  filterable: Boolean,
+  /**
+  * @description custom filter method, the first parameter is the current input value. To use this, `filterable` must be true
+  */
+  filterMethod: { type: t(Function) },
+  /**
+  * @description The height of the dropdown panel, 34px for each item
+  */
+  height: {
+    type: Number,
+    default: 274
+  },
+  /**
+  * @description The height of the dropdown item
+  */
+  itemHeight: {
+    type: Number,
+    default: 34
+  },
+  /**
+  * @description native input id
+  */
+  id: String,
+  /**
+  * @description whether Select is loading data from server
+  */
+  loading: Boolean,
+  /**
+  * @description displayed text while loading data from server, default is 'Loading'
+  */
+  loadingText: String,
+  /**
+  * @description biding value
+  */
+  modelValue: {
+    type: t([
+      Array,
+      String,
+      Number,
+      Boolean,
+      Object
+    ]),
+    default: void 0
+  },
+  /**
+  * @description is multiple
+  */
+  multiple: Boolean,
+  /**
+  * @description maximum number of options user can select when multiple is true. No limit when set to 0
+  */
+  multipleLimit: {
+    type: Number,
+    default: 0
+  },
+  /**
+  * @description the name attribute of select input
+  */
+  name: String,
+  /**
+  * @description displayed text when there is no options, you can also use slot empty, the default is 'No Data'
+  */
+  noDataText: String,
+  /**
+  * @description displayed text when no data matches the filtering query, you can also use slot `empty`, default is 'No matching data'
+  */
+  noMatchText: String,
+  /**
+  * @description function that gets called when the input value changes. Its parameter is the current input value. To use this, `filterable` must be true
+  */
+  remoteMethod: { type: t(Function) },
+  /**
+  * @description whether reserve the keyword after select filtered option.
+  */
+  reserveKeyword: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description data of the options, the key of `value` and `label` can be customize by `props`
+  */
+  options: {
+    type: t(Array),
+    required: !0
+  },
+  /**
+  * @description placeholder, the default is 'Please select'
+  */
+  placeholder: { type: String },
+  /**
+  * @description whether select dropdown is teleported, if `true` it will be teleported to where `append-to` sets
+  */
+  teleported: o.teleported,
+  /**
+  * @description when select dropdown is inactive and `persistent` is `false`, select dropdown will be destroyed
+  */
+  persistent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description custom class name for Select's dropdown
+  */
+  popperClass: o.popperClass,
+  /**
+  * @description custom style for Select's dropdown
+  */
+  popperStyle: o.popperStyle,
+  /**
+  * @description [popper.js](https://popper.js.org/docs/v2/) parameters
+  */
+  popperOptions: {
+    type: t(Object),
+    default: () => ({})
+  },
+  /**
+  * @description whether search data from server
+  */
+  remote: Boolean,
+  /**
+  * @description debounce delay during remote search, in milliseconds
+  */
+  debounce: {
+    type: Number,
+    default: 300
+  },
+  /**
+  * @description size of component
+  */
+  size: s,
+  /**
+  * @description configuration options, see the following table
+  */
+  props: {
+    type: t(Object),
+    default: () => c
+  },
+  /**
+  * @description unique identity key name for value, required when value is an object
+  */
+  valueKey: {
+    type: String,
+    default: "value"
+  },
+  /**
+  * @description Controls whether the scrollbar is always displayed
+  */
+  scrollbarAlwaysOn: Boolean,
+  /**
+  * @description whether to trigger form validation
+  */
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description offset of the dropdown
+  */
+  offset: {
+    type: Number,
+    default: 12
+  },
+  /**
+  * @description in remote search method show suffix icon
+  */
+  remoteShowSuffix: Boolean,
+  /**
+  * @description Determines whether the arrow is displayed
+  */
+  showArrow: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+  * @description position of dropdown
+  */
+  placement: {
+    type: t(String),
+    values: g,
+    default: "bottom-start"
+  },
+  /**
+  * @description list of possible positions for dropdown
+  */
+  fallbackPlacements: {
+    type: t(Array),
+    default: [
+      "bottom-start",
+      "top-start",
+      "right",
+      "left"
+    ]
+  },
+  /**
+  * @description tag type
+  */
+  tagType: {
+    ...a.type,
+    default: "info"
+  },
+  /**
+  * @description tag effect
+  */
+  tagEffect: {
+    ...a.effect,
+    default: "light"
+  },
+  /**
+  * @description tabindex for input
+  */
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  /**
+  * @description which element the select dropdown appends to
+  */
+  appendTo: o.appendTo,
+  /**
+  * @description if it is `true`, the width of the dropdown panel is the same as the input box.
+  * if it is `false`, the width is automatically calculated based on the value of `label`,
+  * or it can be set to a number to make it a fixed width
+  */
+  fitInputWidth: {
+    type: [Boolean, Number],
+    default: !0,
+    validator(e) {
+      return u(e) || l(e);
+    }
+  },
+  suffixIcon: {
+    type: r,
+    default: y
+  },
+  ...d,
+  ...f(["ariaLabel"])
+}), j = p({
+  data: Array,
+  disabled: Boolean,
+  hovering: Boolean,
+  item: {
+    type: t(Object),
+    required: !0
+  },
+  index: Number,
+  style: Object,
+  selected: Boolean,
+  created: Boolean
+}), D = {
+  [n]: (e) => !0,
+  [i]: (e) => !0,
+  "end-reached": m["end-reached"],
+  "remove-tag": (e) => !0,
+  "visible-change": (e) => !0,
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0
+}, F = {
+  hover: (e) => l(e),
+  select: (e, B) => !0
+};
+export {
+  F as optionV2Emits,
+  j as optionV2Props,
+  D as selectV2Emits,
+  _ as selectV2Props
+};

package/dist/node_modules/element-plus/es/components/select-v2/src/group-item.js

@@ -0,0 +1,16 @@
+import t from "../../../_virtual/_plugin-vue_export-helper.js";
+import r from "./group-item.vue_vue_type_script_lang.js";
+import { openBlock as l, createElementBlock as o, normalizeStyle as i, normalizeClass as p, toDisplayString as a } from "vue";
+function n(e, s, u, _, m, f) {
+  return l(), o("div", {
+    class: p(e.ns.be("group", "title")),
+    style: i({
+      ...e.style,
+      lineHeight: `${e.height}px`
+    })
+  }, a(e.item.label), 7);
+}
+var h = /* @__PURE__ */ t(r, [["render", n]]);
+export {
+  h as default
+};

package/dist/node_modules/element-plus/es/components/select-v2/src/group-item.vue_vue_type_script_lang.js

@@ -0,0 +1,18 @@
+import { useNamespace as e } from "../../../hooks/use-namespace/index.js";
+import { defineComponent as t } from "vue";
+var u = t({
+  props: {
+    item: {
+      type: Object,
+      required: !0
+    },
+    style: { type: Object },
+    height: Number
+  },
+  setup() {
+    return { ns: e("select") };
+  }
+});
+export {
+  u as default
+};

package/dist/node_modules/element-plus/es/components/select-v2/src/option-item.js

@@ -0,0 +1,35 @@
+import d from "../../../_virtual/_plugin-vue_export-helper.js";
+import s from "./option-item.vue_vue_type_script_lang.js";
+import { openBlock as l, createElementBlock as n, mergeProps as r, toHandlerKey as a, withModifiers as t, renderSlot as p, createElementVNode as m, toDisplayString as u } from "vue";
+const f = [
+  "id",
+  "aria-selected",
+  "aria-disabled"
+];
+function v(e, o, b, g, $, k) {
+  return l(), n("li", r({
+    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)
+    ]
+  }, { [a(e.mouseMoveEventName)]: o[0] || (o[0] = (...i) => e.hoverItem && e.hoverItem(...i)) }, {
+    onMousedown: o[1] || (o[1] = (...i) => e.handleMousedown && e.handleMousedown(...i)),
+    onClick: o[2] || (o[2] = t((...i) => e.selectOptionClick && e.selectOptionClick(...i), ["stop"]))
+  }), [p(e.$slots, "default", {
+    item: e.item,
+    index: e.index,
+    disabled: e.disabled
+  }, () => [m("span", null, u(e.getLabel(e.item)), 1)])], 16, f);
+}
+var h = /* @__PURE__ */ d(s, [["render", v]]);
+export {
+  h as default
+};

package/dist/node_modules/element-plus/es/components/select-v2/src/option-item.vue_vue_type_script_lang.js

@@ -0,0 +1,34 @@
+import { isFocusable as l } from "../../../utils/dom/aria.js";
+import { useNamespace as f } from "../../../hooks/use-namespace/index.js";
+import { useProps as d } from "./useProps.js";
+import { useOption as _ } from "./useOption.js";
+import { optionV2Emits as g, optionV2Props as v } from "./defaults.js";
+import { selectV2InjectionKey as h } from "./token.js";
+import { defineComponent as I, inject as w } from "vue";
+var O = I({
+  props: v,
+  emits: g,
+  setup(r, { emit: n }) {
+    const o = w(h), s = f("select"), p = "mousemove", { hoverItem: m, selectOptionClick: i } = _(r, { emit: n }), { getLabel: c } = d(o.props), a = o.contentId;
+    return {
+      ns: s,
+      contentId: a,
+      mouseMoveEventName: p,
+      hoverItem: m,
+      handleMousedown: (t) => {
+        let e = t.target;
+        const u = t.currentTarget;
+        for (; e && e !== u; ) {
+          if (l(e)) return;
+          e = e.parentElement;
+        }
+        t.preventDefault();
+      },
+      selectOptionClick: i,
+      getLabel: c
+    };
+  }
+});
+export {
+  O as default
+};

package/dist/node_modules/element-plus/es/components/select-v2/src/select-dropdown.js

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