@maple-design/ui-vue 0.0.0-stage → 1.1.1

package/lib/select/Optgroup.vue.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Optgroup_vue_vue_type_script_lang = require("./Optgroup2.vue.js");
+const vue = require("vue");
+const _pluginVue_exportHelper = require("../_virtual/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["aria-labelledby"];
+const _hoisted_2 = ["id"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("li", {
+    class: vue.normalizeClass(_ctx.prefixCls),
+    role: "group",
+    "aria-labelledby": _ctx.titleId
+  }, [
+    vue.createElementVNode("div", {
+      id: _ctx.titleId,
+      class: vue.normalizeClass(`${_ctx.prefixCls}-title`),
+      role: "presentation"
+    }, [
+      vue.renderSlot(_ctx.$slots, "label", {}, () => [
+        vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
+      ])
+    ], 10, _hoisted_2),
+    vue.createElementVNode("ul", {
+      class: vue.normalizeClass(`${_ctx.prefixCls}-options`),
+      role: "presentation"
+    }, [
+      vue.renderSlot(_ctx.$slots, "default")
+    ], 2)
+  ], 10, _hoisted_1);
+}
+const OptgroupComponent = /* @__PURE__ */ _pluginVue_exportHelper.default(Optgroup_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
+exports.default = OptgroupComponent;

package/lib/select/Optgroup2.vue.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const components = require("../utils/components.js");
+const { name, n, classes } = components.createNamespace("optgroup");
+const _sfc_main = vue.defineComponent({
+  name,
+  props: {
+    /**
+     * @zh 选项组的标题
+     * @en Title of option group
+     */
+    label: {
+      type: String
+    }
+  },
+  /**
+   * @zh 选项组的标题
+   * @en Title of option group
+   * @slot label
+   */
+  setup() {
+    const prefixCls = components.getPrefixCls("select-group");
+    return {
+      prefixCls,
+      titleId: `select-group-${vue.useId()}`
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/select/Option.vue.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Option_vue_vue_type_script_lang = require("./Option2.vue.js");
+const vue = require("vue");
+const _pluginVue_exportHelper = require("../_virtual/_plugin-vue_export-helper.js");
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_IconCheck = vue.resolveComponent("IconCheck");
+  return vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.component), {
+    id: _ctx.optionId,
+    ref: "itemRef",
+    class: vue.normalizeClass([_ctx.cls, { [`${_ctx.prefixCls}-has-suffix`]: Boolean(_ctx.$slots.suffix) }]),
+    role: "option",
+    "aria-selected": _ctx.isSelected,
+    "aria-disabled": _ctx.disabled,
+    onClick: _ctx.handleClick,
+    onMouseenter: _ctx.handleMouseEnter,
+    onMouseleave: _ctx.handleMouseLeave
+  }, {
+    default: vue.withCtx(() => [
+      _ctx.$slots.icon ? (vue.openBlock(), vue.createElementBlock("span", {
+        key: 0,
+        class: vue.normalizeClass(`${_ctx.prefixCls}-icon`)
+      }, [
+        vue.renderSlot(_ctx.$slots, "icon")
+      ], 2)) : vue.createCommentVNode("", true),
+      vue.createElementVNode("span", {
+        class: vue.normalizeClass(`${_ctx.prefixCls}-content`)
+      }, [
+        vue.renderSlot(_ctx.$slots, "default", { selected: _ctx.isSelected }, () => [
+          vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
+        ])
+      ], 2),
+      _ctx.$slots.suffix ? (vue.openBlock(), vue.createElementBlock("span", {
+        key: 1,
+        class: vue.normalizeClass(`${_ctx.prefixCls}-suffix`)
+      }, [
+        vue.renderSlot(_ctx.$slots, "suffix")
+      ], 2)) : vue.createCommentVNode("", true),
+      _ctx.isSelected ? (vue.openBlock(), vue.createElementBlock("span", {
+        key: 2,
+        class: vue.normalizeClass(`${_ctx.prefixCls}-check`),
+        "aria-hidden": "true"
+      }, [
+        vue.createVNode(_component_IconCheck)
+      ], 2)) : vue.createCommentVNode("", true)
+    ]),
+    _: 3
+  }, 40, ["id", "class", "aria-selected", "aria-disabled", "onClick", "onMouseenter", "onMouseleave"])), [
+    [vue.vShow, _ctx.isValid]
+  ]);
+}
+const OptionComponent = /* @__PURE__ */ _pluginVue_exportHelper.default(Option_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
+exports.default = OptionComponent;

package/lib/select/Option2.vue.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const iconsVue = require("@maple-design/icons-vue");
+const isEqual = require("../_utils/is-equal.js");
+const components = require("../utils/components.js");
+const context = require("./context.js");
+const props = require("./props.js");
+const utils = require("./utils.js");
+const { name, n, classes } = components.createNamespace("option");
+const _sfc_main = vue.defineComponent({
+  name,
+  components: {
+    IconCheck: iconsVue.IconCheck
+  },
+  props: { ...props.optionProps, internal: Boolean },
+  setup(props2) {
+    const { disabled, tagProps: _tagProps, index } = vue.toRefs(props2);
+    const prefixCls = components.getPrefixCls("select-option");
+    const selectCtx = vue.inject(context.selectInjectionKey, void 0);
+    const instance = vue.getCurrentInstance();
+    const itemRef = vue.ref();
+    const tagProps = vue.ref(_tagProps.value);
+    vue.watch(_tagProps, (cur, pre) => {
+      if (!isEqual.isEqual(cur, pre)) {
+        tagProps.value = cur;
+      }
+    });
+    const textContent = vue.ref("");
+    const value = vue.computed(() => props2.value ?? props2.label ?? textContent.value);
+    const label = vue.computed(() => props2.label ?? textContent.value);
+    const key = vue.computed(() => utils.getKeyFromValue(value.value, selectCtx?.fieldNames?.value));
+    const component = vue.computed(() => selectCtx?.component ?? "li");
+    const setTextContent = () => {
+      if (!props2.label && itemRef.value) {
+        const text = itemRef.value.textContent ?? "";
+        if (textContent.value !== text) {
+          textContent.value = text;
+        }
+      }
+    };
+    vue.onMounted(() => setTextContent());
+    vue.onUpdated(() => setTextContent());
+    const isSelected = vue.computed(() => selectCtx?.valueKeys.includes(key.value) ?? false);
+    const optionId = vue.computed(
+      () => props2.internal || selectCtx?.component !== "div" ? selectCtx?.getOptionId?.(key.value) : void 0
+    );
+    const isActive = vue.computed(() => selectCtx?.activeKey === key.value);
+    const optionInfo = vue.reactive({
+      raw: {
+        value,
+        label,
+        disabled,
+        tagProps
+      },
+      ref: itemRef,
+      index,
+      key,
+      origin: "slot",
+      value,
+      label,
+      disabled,
+      tagProps
+    });
+    const isValid = vue.computed(
+      () => props2.internal || utils.isValidOption(optionInfo, {
+        inputValue: selectCtx?.inputValue,
+        filterOption: selectCtx?.filterOption,
+        caseSensitive: selectCtx?.caseSensitive,
+        searchFields: selectCtx?.searchFields
+      })
+    );
+    if (!props2.internal) {
+      if (instance) {
+        selectCtx?.addSlotOptionInfo(instance.uid, optionInfo);
+      }
+      vue.onBeforeUnmount(() => {
+        if (instance) {
+          selectCtx?.removeSlotOptionInfo(instance.uid);
+        }
+      });
+    }
+    const handleClick = (ev) => {
+      if (!props2.disabled) {
+        selectCtx?.onSelect(key.value, ev);
+      }
+    };
+    const handleMouseEnter = () => {
+      if (!props2.disabled) {
+        selectCtx?.setActiveKey(key.value);
+      }
+    };
+    const handleMouseLeave = () => {
+      if (!props2.disabled) {
+        selectCtx?.setActiveKey();
+      }
+    };
+    const cls = vue.computed(() => [
+      prefixCls,
+      {
+        [`${prefixCls}-disabled`]: props2.disabled,
+        [`${prefixCls}-selected`]: isSelected.value,
+        [`${prefixCls}-active`]: isActive.value,
+        [`${prefixCls}-multiple`]: selectCtx?.multiple
+      }
+    ]);
+    return {
+      optionId,
+      prefixCls,
+      cls,
+      selectCtx,
+      itemRef,
+      component,
+      isSelected,
+      isValid,
+      handleClick,
+      handleMouseEnter,
+      handleMouseLeave
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/select/SelectDropdown.vue.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const SelectDropdown_vue_vue_type_script_lang = require("./SelectDropdown2.vue.js");
+const vue = require("vue");
+const _pluginVue_exportHelper = require("../_virtual/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["id", "role", "aria-multiselectable"];
+const _hoisted_2 = ["id", "role", "aria-multiselectable"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_loading = vue.resolveComponent("loading");
+  return vue.openBlock(), vue.createElementBlock("div", {
+    class: vue.normalizeClass(_ctx.cls),
+    onWheel: _cache[0] || (_cache[0] = (...args) => _ctx.onUserInteraction && _ctx.onUserInteraction(...args)),
+    onPointerdown: _cache[1] || (_cache[1] = (...args) => _ctx.onUserInteraction && _ctx.onUserInteraction(...args)),
+    onTouchstart: _cache[2] || (_cache[2] = (...args) => _ctx.onUserInteraction && _ctx.onUserInteraction(...args))
+  }, [
+    _ctx.$slots.header && (!_ctx.empty || _ctx.showHeaderOnEmpty) ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 0,
+      class: vue.normalizeClass(`${_ctx.prefixCls}-header`)
+    }, [
+      vue.renderSlot(_ctx.$slots, "header")
+    ], 2)) : vue.createCommentVNode("", true),
+    _ctx.loading ? (vue.openBlock(), vue.createBlock(_component_loading, {
+      key: 1,
+      class: vue.normalizeClass(`${_ctx.prefixCls}-loading`)
+    }, null, 8, ["class"])) : _ctx.empty ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 2,
+      class: vue.normalizeClass(`${_ctx.prefixCls}-empty`)
+    }, [
+      vue.renderSlot(_ctx.$slots, "empty", {}, () => [
+        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.SelectEmpty)))
+      ])
+    ], 2)) : vue.createCommentVNode("", true),
+    _ctx.virtualList && !_ctx.loading && !_ctx.empty ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 3,
+      id: _ctx.listboxId,
+      role: _ctx.listboxId ? "listbox" : void 0,
+      "aria-multiselectable": _ctx.listboxId ? _ctx.multiple : void 0
+    }, [
+      vue.renderSlot(_ctx.$slots, "virtual-list")
+    ], 8, _hoisted_1)) : vue.createCommentVNode("", true),
+    !_ctx.virtualList ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.displayScrollbar ? "ScrollbarComponent" : "div"), vue.mergeProps(
+      {
+        key: 4,
+        ref: "wrapperComRef",
+        class: `${_ctx.prefixCls}-list-wrapper`
+      },
+      _ctx.displayScrollbar ? {
+        ..._ctx.scrollbarProps,
+        outerStyle: [_ctx.scrollbarProps?.outerStyle, !_ctx.loading && !_ctx.empty ? void 0 : { display: "none" }]
+      } : { style: !_ctx.loading && !_ctx.empty ? void 0 : { display: "none" } },
+      { onScroll: _ctx.handleScroll }
+    ), {
+      default: vue.withCtx(() => [
+        vue.createElementVNode("ul", {
+          id: _ctx.listboxId,
+          role: _ctx.listboxId ? "listbox" : void 0,
+          "aria-multiselectable": _ctx.listboxId ? _ctx.multiple : void 0,
+          class: vue.normalizeClass(`${_ctx.prefixCls}-list`)
+        }, [
+          vue.renderSlot(_ctx.$slots, "default")
+        ], 10, _hoisted_2)
+      ]),
+      _: 3
+    }, 16, ["class", "onScroll"])) : vue.createCommentVNode("", true),
+    _ctx.$slots.footer && (!_ctx.empty || _ctx.showFooterOnEmpty) ? (vue.openBlock(), vue.createElementBlock("div", {
+      key: 5,
+      class: vue.normalizeClass(`${_ctx.prefixCls}-footer`)
+    }, [
+      vue.renderSlot(_ctx.$slots, "footer")
+    ], 2)) : vue.createCommentVNode("", true)
+  ], 34);
+}
+const SelectDropdown = /* @__PURE__ */ _pluginVue_exportHelper.default(SelectDropdown_vue_vue_type_script_lang.default, [["render", _sfc_render]]);
+exports.default = SelectDropdown;

package/lib/select/SelectDropdown2.vue.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const emptySlot = require("../_components/selection-field/empty-slot.js");
+const index = require("../_components/selection-scrollbar/index.js");
+const useComponentRef = require("../_hooks/use-component-ref.js");
+const useScrollbar = require("../_hooks/use-scrollbar.js");
+require("../empty/index.js");
+const Loading_vue_vue_type_script_setup_true_lang = require("../loading/Loading.vue.js");
+const components = require("../utils/components.js");
+const Empty_vue_vue_type_script_setup_true_lang = require("../empty/Empty.vue.js");
+const { name, n, classes } = components.createNamespace("select-dropdown");
+const _sfc_main = vue.defineComponent({
+  name,
+  components: {
+    ScrollbarComponent: index.Scrollbar,
+    Empty: Empty_vue_vue_type_script_setup_true_lang.default,
+    Loading: Loading_vue_vue_type_script_setup_true_lang.default
+  },
+  props: {
+    onUserInteraction: Function,
+    listboxId: String,
+    multiple: Boolean,
+    loading: Boolean,
+    empty: Boolean,
+    virtualList: Boolean,
+    bottomOffset: {
+      type: Number,
+      default: 0
+    },
+    scrollbar: {
+      type: [Boolean, Object],
+      default: true
+    },
+    onScroll: {
+      type: [Function, Array]
+    },
+    onReachBottom: {
+      type: [Function, Array]
+    },
+    showHeaderOnEmpty: {
+      type: Boolean,
+      default: false
+    },
+    showFooterOnEmpty: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["scroll", "reach-bottom"],
+  setup(props, { emit, slots }) {
+    const { scrollbar } = vue.toRefs(props);
+    const prefixCls = components.getPrefixCls("select-dropdown");
+    const emptySlot$1 = emptySlot.useEmptySlot();
+    const SelectEmpty = () => emptySlot$1.value?.({ component: "select" }) ?? vue.h(Empty_vue_vue_type_script_setup_true_lang.default);
+    const { componentRef: wrapperComRef, elementRef: wrapperRef } = useComponentRef.useComponentRef("containerRef");
+    const { displayScrollbar, scrollbarProps } = useScrollbar.useScrollbar(scrollbar);
+    const handleScroll = (e) => {
+      const { scrollTop, scrollHeight, offsetHeight } = e.target;
+      const bottom = scrollHeight - (scrollTop + offsetHeight);
+      if (bottom <= props.bottomOffset) {
+        emit("reach-bottom", e);
+      }
+      emit("scroll", e);
+    };
+    const cls = vue.computed(() => [
+      prefixCls,
+      {
+        [`${prefixCls}-has-header`]: Boolean(slots.header),
+        [`${prefixCls}-has-footer`]: Boolean(slots.footer)
+      }
+    ]);
+    return {
+      prefixCls,
+      SelectEmpty,
+      cls,
+      wrapperRef,
+      wrapperComRef,
+      handleScroll,
+      displayScrollbar,
+      scrollbarProps
+    };
+  }
+});
+exports.default = _sfc_main;

package/lib/select/SelectMenu.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const VirtualList = require("../_components/virtual-list-v2/VirtualList.vue.js");
+const is = require("../_utils/is.js");
+const components = require("../utils/components.js");
+const Optgroup = require("./Optgroup.vue.js");
+const Option = require("./Option.vue.js");
+const SelectDropdown = require("./SelectDropdown.vue.js");
+const utils = require("./utils.js");
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+const SelectMenu = /* @__PURE__ */ vue.defineComponent({
+  name: components.createNamespace("select-menu").name,
+  props: {
+    controller: {
+      type: Object,
+      required: true
+    }
+  },
+  setup({
+    controller
+  }, {
+    slots
+  }) {
+    const getOptionContentFunc = (optionInfo) => {
+      if (is.isFunction(slots.option)) {
+        const optionSlot = slots.option;
+        return () => optionSlot({
+          data: optionInfo.raw
+        });
+      }
+      if (is.isFunction(optionInfo.render)) {
+        return optionInfo.render;
+      }
+      return () => optionInfo.label;
+    };
+    const renderOption = (optionInfo) => {
+      if (utils.isGroupOptionInfo(optionInfo)) {
+        let _slot;
+        return vue.createVNode(Optgroup.default, {
+          "key": optionInfo.key,
+          "label": optionInfo.label
+        }, _isSlot(_slot = optionInfo.options.map((child) => renderOption(child))) ? _slot : {
+          default: () => [_slot]
+        });
+      }
+      if (!utils.isValidOption(optionInfo, {
+        inputValue: controller.computedInputValue,
+        filterOption: controller.props.filterOption,
+        caseSensitive: controller.props.caseSensitive,
+        searchFields: controller.props.searchFields
+      })) {
+        return null;
+      }
+      return vue.createVNode(Option.default, {
+        "ref": (ref) => {
+          if (ref && "$el" in ref) {
+            controller.optionRefs[optionInfo.key] = ref.$el;
+          } else if (!ref) {
+            delete controller.optionRefs[optionInfo.key];
+          }
+        },
+        "key": optionInfo.key,
+        "value": optionInfo.value,
+        "label": optionInfo.label,
+        "disabled": optionInfo.disabled || controller.session.pending,
+        "internal": true
+      }, {
+        default: getOptionContentFunc(optionInfo)
+      });
+    };
+    const renderDropDown = () => {
+      return vue.createVNode(vue.Fragment, null, [controller.props.virtualListProps && vue.createVNode("div", {
+        "hidden": true
+      }, [slots.default?.()]), vue.createVNode(SelectDropdown.default, {
+        "onUserInteraction": controller.cancelPendingInitialScroll,
+        "listboxId": controller.listboxId,
+        "multiple": controller.props.multiple,
+        "ref": (el) => {
+          controller.dropdownRef = el;
+        },
+        "loading": controller.loading,
+        "empty": controller.validOptionInfos.length === 0,
+        "virtualList": Boolean(controller.props.virtualListProps),
+        "scrollbar": controller.props.scrollbar,
+        "showHeaderOnEmpty": controller.props.showHeaderOnEmpty,
+        "showFooterOnEmpty": controller.props.showFooterOnEmpty,
+        "onScroll": controller.handleDropdownScroll,
+        "onReach-bottom": controller.handleDropdownReachBottom
+      }, {
+        default: () => [...slots.default?.() ?? [], ...controller.validOptions.map(renderOption)],
+        "virtual-list": () => vue.createVNode(VirtualList.default, vue.mergeProps(controller.props.virtualListProps, {
+          "onScroll": controller.handleDropdownScroll,
+          "onReach-bottom": controller.handleDropdownReachBottom,
+          "ref": (el) => {
+            controller.virtualListRef = el;
+          },
+          "data": [...controller.validOptionInfos.filter((option) => option.origin === "slot"), ...controller.validOptions]
+        }), {
+          item: ({
+            item
+          }) => renderOption(item)
+        }),
+        empty: slots.empty,
+        header: slots.header,
+        footer: slots.footer
+      })]);
+    };
+    return renderDropDown;
+  }
+});
+exports.default = SelectMenu;

package/lib/select/context.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const selectInjectionKey = Symbol("CedarSelectContext");
+exports.selectInjectionKey = selectInjectionKey;

package/lib/select/emits.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const selectEmits = {
+  "load-error": (error) => true,
+  focus: (event) => true,
+  blur: (event) => true,
+  /**
+   * @zh 字段按键事件，可调用 preventDefault 阻止内部键盘操作
+   * @en Field key event; call preventDefault to suppress internal keyboard handling
+   */
+  keydown: (event) => true,
+  "update:modelValue": (value) => true,
+  "update:inputValue": (inputValue) => true,
+  "update:open": (visible) => true,
+  /**
+   * @zh 值发生改变时触发
+   * @en Triggered when the value changes
+   * @param { string | number | boolean | Record<string, any> | (string | number | boolean | Record<string, any>)[] } value
+   */
+  change: (value) => true,
+  /**
+   * @zh 输入框的值发生改变时触发
+   * @en Triggered when the value of the input changes
+   * @param {string} inputValue
+   */
+  "input-value-change": (inputValue) => true,
+  /**
+   * @zh 下拉框的显示状态改变时触发
+   * @en Triggered when the display state of the drop-down box changes
+   * @param {boolean} visible
+   */
+  "open-change": (visible) => true,
+  /**
+   * @zh 点击清除按钮时触发
+   * @en Triggered when the clear button is clicked
+   */
+  clear: (ev) => true,
+  /**
+   * @zh 点击标签的删除按钮时触发
+   * @en Triggered when the delete button of the label is clicked
+   * @param {string | number | boolean | Record<string, any> | undefined} removed
+   */
+  remove: (removed) => true,
+  /**
+   * @zh 用户搜索时触发
+   * @en Triggered when the user searches
+   * @param {string} inputValue
+   */
+  search: (inputValue) => true,
+  /**
+   * @zh 下拉菜单发生滚动时触发
+   * @en Triggered when the drop-down scrolls
+   */
+  "dropdown-scroll": (ev) => true,
+  /**
+   * @zh 下拉菜单滚动到底部时触发
+   * @en Triggered when the drop-down menu is scrolled to the bottom
+   */
+  "dropdown-reach-bottom": (ev) => true,
+  /**
+   * @zh 多选超出限制时触发
+   * @en Triggered when multiple selection exceeds the limit
+   * @param {string | number | boolean | Record<string, any> | undefined} value
+   * @param {Event} ev
+   */
+  "exceed-limit": (value, ev) => true
+};
+exports.selectEmits = selectEmits;