ep-craft 0.1.26 → 0.1.27

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

@@ -0,0 +1,359 @@
+import { placements as i } from "@popperjs/core";
+import "vue";
+import { isBoolean as n, isNumber as l } from "../../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import { CHANGE_EVENT as u, UPDATE_MODEL_EVENT as m } from "../../../constants/event.js";
+import { iconPropType as r } from "../../../utils/vue/icon.js";
+import { buildProps as p, definePropType as t } from "../../../utils/vue/props/runtime.js";
+import { useSizeProp as d } from "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import { useAriaProps as s } from "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import { useEmptyValuesProps as f } from "../../../hooks/use-empty-values/index.js";
+import { floatLabelProp as c } from "../../../hooks/use-float-label/index.js";
+import "../../scrollbar/index.js";
+import "../../tooltip/index.js";
+import { ArrowDown as y, CircleClose as b } from "@element-plus/icons-vue";
+import "../../tag/index.js";
+import { defaultProps as g } from "./useProps.js";
+import { useTooltipContentProps as o } from "../../tooltip/src/content.js";
+import { tagProps as a } from "../../tag/tag.js";
+import { scrollbarEmits as B } from "../../scrollbar/src/scrollbar.js";
+const G = 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
+    // same as select dropdown menu
+  },
+  /**
+   * @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: d,
+  /**
+   * @description configuration options, see the following table
+   */
+  props: {
+    type: t(Object),
+    default: () => g
+  },
+  /**
+   * @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: i,
+    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 n(e) || l(e);
+    }
+  },
+  suffixIcon: {
+    type: r,
+    default: y
+  },
+  ...c,
+  ...f,
+  ...s(["ariaLabel"])
+}), U = p({
+  data: Array,
+  disabled: Boolean,
+  hovering: Boolean,
+  item: {
+    type: t(Object),
+    required: !0
+  },
+  index: Number,
+  style: Object,
+  selected: Boolean,
+  created: Boolean
+}), W = {
+  [m]: (e) => !0,
+  [u]: (e) => !0,
+  "end-reached": B["end-reached"],
+  "remove-tag": (e) => !0,
+  "visible-change": (e) => !0,
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0
+}, J = {
+  hover: (e) => l(e),
+  select: (e, v) => !0
+};
+export {
+  J as optionV2Emits,
+  U as optionV2Props,
+  W as selectV2Emits,
+  G as selectV2Props
+};

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

@@ -0,0 +1,40 @@
+import type { CSSProperties, PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    height: NumberConstructor;
+}>, {
+    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;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    height: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

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

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;