@opentiny/vue-renderless 3.27.0 → 3.28.0

package/picker/index.js

@@ -2,7 +2,7 @@ import {
   __spreadProps,
   __spreadValues
 } from "../chunk-G2ADBYYC.js";
-import { toDate1, getDateWithNewTimezone, getStrTimezone, getLocalTimezone } from "@opentiny/utils";
+import { toDate1, getDateWithNewTimezone, getStrTimezone, getLocalTimezone, parseIso8601 } from "@opentiny/utils";
 import { isNumber, isDate } from "@opentiny/utils";
 import { userPopper } from "@opentiny/vue-hooks";
 import { DATEPICKER } from "@opentiny/utils";
@@ -127,6 +127,24 @@ const parseAsFormatAndType = ({ api }) => (value, customFormat, type, rangeSepar
   const format = customFormat || DATEPICKER.DateFormats[type];
   return parser(value, format, rangeSeparator);
 };
+const ignoreTimezone = (value) => {
+  let res = value;
+  const ignoreTimezoneFn = (value2) => {
+    let date = value2;
+    const iso8601 = parseIso8601(value2);
+    if (iso8601) {
+      const { year, month, day, hours, minutes, seconds } = iso8601;
+      date = new Date(year, month, day, hours, minutes, seconds);
+    }
+    return date;
+  };
+  if (Array.isArray(res)) {
+    res = res.map((item) => ignoreTimezoneFn(item));
+  } else {
+    res = ignoreTimezoneFn(res);
+  }
+  return res;
+};
 const parsedValue = ({ api, props, state, t }) => () => {
   if (!props.modelValue) {
     return props.modelValue;
@@ -139,17 +157,16 @@ const parsedValue = ({ api, props, state, t }) => () => {
   if (valueIsDateObject && !isServiceTimezone) {
     return props.modelValue;
   }
+  let value = ignoreTimezone(props.modelValue);
   if (state.valueFormat) {
-    let date = props.modelValue;
-    if (isServiceTimezone) {
-      if (Array.isArray(date)) {
-        date = [].concat(date).map((item) => {
-          return isDate(item) ? formatDate(item, state.valueFormat, t) : item;
-        });
-      } else {
-        if (state.valueFormat !== DATEPICKER.TimesTamp) {
-          date = formatDate(date, state.valueFormat, t);
-        }
+    let date = value;
+    if (Array.isArray(date)) {
+      date = [].concat(date).map((item) => {
+        return isDate(item) ? formatDate(item, state.valueFormat, t) : item;
+      });
+    } else {
+      if (state.valueFormat !== DATEPICKER.TimesTamp && isDate(date)) {
+        date = formatDate(date, state.valueFormat, t);
       }
     }
     const result = api.parseAsFormatAndType(date, state.valueFormat, state.type, props.rangeSeparator);
@@ -158,7 +175,7 @@ const parsedValue = ({ api, props, state, t }) => () => {
     }
     return getDateWithNewTimezone(result || props.modelValue, from, to, timezoneOffset);
   }
-  const trans = (value) => typeof value === "string" || isNumber(value) ? toDate1(value) : value;
+  const trans = (value2) => typeof value2 === "string" || isNumber(value2) ? toDate1(value2) : value2;
   const values = [].concat(props.modelValue).map((val) => getDateWithNewTimezone(trans(val), from, to, timezoneOffset));
   return values.length > 1 ? values : values[0];
 };
@@ -1019,7 +1036,7 @@ const emitDbTime = ({ emit, state, t }) => (date) => {
       if (isDate(item)) {
         hasDate = true;
         let currentDate = getDateWithNewTimezone(item, getLocalTimezone(), from);
-        if (state.valueFormat) {
+        if (state.valueFormat && state.valueFormat !== DATEPICKER.TimesTamp) {
           currentDate = formatDate(currentDate, state.valueFormat, t);
         }
         return currentDate;

package/popover/index.js

@@ -123,7 +123,7 @@ const handleDocumentClick = ({ vm, state }) => (event) => {
   const popperElm = state.popperElm;
   const $el = vm.$refs.root;
   let target = event.target;
-  if ((target == null ? void 0 : target.shadowRoot) && popperElm) {
+  if ((target == null ? void 0 : target.shadowRoot) && target.shadowRoot.contains($el) && popperElm) {
     target = state.webCompEventTarget;
   }
   if (!$el || !reference || $el.contains(target) || reference.contains(target) || !popperElm || popperElm.contains(target)) {

package/rich-text/index.js

@@ -4,6 +4,21 @@ import { xss } from "@opentiny/utils";
 import { getToolbarTips, defaultOptions } from "./options";
 import registerTableModule from "./table-module";
 import registerCustomClipboard from "./clipboard";
+const registerCustomSize = (Quill, sizeConfig) => {
+  if (!sizeConfig || !Array.isArray(sizeConfig)) {
+    return;
+  }
+  const hasPixelValues = sizeConfig.some((item) => {
+    return item && typeof item === "string" && item.includes("px");
+  });
+  if (!hasPixelValues) {
+    return;
+  }
+  const SizeStyle = Quill.import("attributors/style/size");
+  const whitelist = sizeConfig.filter((item) => item !== false);
+  SizeStyle.whitelist = whitelist;
+  Quill.register("formats/size", SizeStyle, true);
+};
 const initContent = ({ state, props, nextTick }) => () => {
   if (state.quill) {
     const flag = state.quill.selection.hasFocus();
@@ -24,7 +39,34 @@ const initContent = ({ state, props, nextTick }) => () => {
   }
 };
 const initQuill = ({ api, emit, props, vm, service, state, Quill, ImageDrop, ImageUpload, FileUpload }) => () => {
+  var _a, _b;
   state.innerOptions = extend(true, {}, defaultOptions, props.globalOptions, props.options);
+  const toolbarConfig = ((_b = (_a = state.innerOptions.modules) == null ? void 0 : _a.toolbar) == null ? void 0 : _b.container) || [];
+  const findSizeConfig = (config) => {
+    if (!config)
+      return null;
+    if (Array.isArray(config)) {
+      for (let i = 0; i < config.length; i++) {
+        const result = findSizeConfig(config[i]);
+        if (result)
+          return result;
+      }
+    } else if (typeof config === "object" && config !== null) {
+      if (config.size && Array.isArray(config.size)) {
+        return config.size;
+      }
+      for (const key in config) {
+        const result = findSizeConfig(config[key]);
+        if (result)
+          return result;
+      }
+    }
+    return null;
+  };
+  const sizeConfig = findSizeConfig(toolbarConfig);
+  if (sizeConfig) {
+    registerCustomSize(Quill, sizeConfig);
+  }
   if (document.caretRangeFromPoint) {
     if (props.imageDrop) {
       Quill.register("modules/imageDrop", ImageDrop, true);

package/select/index.js

@@ -53,13 +53,13 @@ const showTip = ({ props, state, vm }) => (show) => {
     state.showTip = show && overflow && !!state.tips && !state.visible;
   }
 };
-const gridOnQueryChange = ({ props, vm, constants, state }) => (value) => {
+const gridOnQueryChange = ({ props, vm, constants, state }) => async (value) => {
   const { multiple, valueField, filterMethod, remote, remoteMethod } = props;
   if ((props.filterable || props.searchable) && typeof filterMethod === "function") {
     const table = vm.$refs.selectGrid.$refs.tinyTable;
     const fullData = table.getTableData().fullData;
     vm.$refs.selectGrid.scrollTo(null, 0);
-    table.loadTableData(filterMethod(value, fullData) || []);
+    await table.loadData(filterMethod(value, fullData) || []);
     vm.$refs.selectGrid.handleTableData(!value).then(() => state.selectEmitter.emit(constants.EVENT_NAME.updatePopper));
     state.previousQuery = value;
   } else if (remote && typeof remoteMethod === "function") {

package/select/vue.js

@@ -289,7 +289,8 @@ const initState = ({
     rootAutoTipConfig: computed(() => __spreadValues({
       content: state.displayOnlyContent,
       always: !!state.displayOnlyContent
-    }, props.tooltipConfig))
+    }, props.tooltipConfig)),
+    ariaListId: "tiny-select-" + crypto.randomUUID().slice(-8)
   }));
   return state;
 };

package/select-dropdown/vue.js

@@ -74,12 +74,17 @@ const initApi = ({ api: api2, popper, state, selectEmitter, constants, selectVm,
     mounted: mounted({ selectEmitter, constants, state, selectVm, updatePopper, destroyPopper, parent })
   });
 };
-const initWatch = ({ watch, selectVm, state, nextTick }) => {
+const initWatch = ({ watch, selectVm, state, nextTick, props }) => {
   watch(
     () => !isServer ? selectVm.state.inputWidth : void 0,
     (val) => {
       nextTick(() => {
         state.minWidth = (selectVm && selectVm.$el && selectVm.$el.getBoundingClientRect().width || val) + "px";
+        if (props.isDropInheritWidth) {
+          setTimeout(() => {
+            state.minWidth = (selectVm && selectVm.$el && selectVm.$el.getBoundingClientRect().width || val) + "px";
+          }, 210);
+        }
       });
     },
     { immediate: true }
@@ -129,9 +134,9 @@ const renderless = (props, { computed, onBeforeUnmount, onDeactivated, onMounted
     toRefs,
     watch
   });
-  const state = initState({ reactive, computed, popper, props, selectVm });
+  const state = initState({ reactive, computed, popper, selectVm });
   initApi({ api: api2, popper, state, selectEmitter, constants, selectVm, parent, nextTick, props, isMobileFirstMode });
-  initWatch({ watch, selectVm, state, nextTick, api: api2 });
+  initWatch({ watch, selectVm, state, nextTick, props });
   onBeforeUnmount(() => {
     popper.destroyPopper("remove");
     state.popperElm = null;

package/select-wrapper/vue.js

@@ -0,0 +1,134 @@
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+const api = [
+  "state",
+  "resolvedComponent",
+  "mergedProps",
+  "listeners",
+  "slotNames",
+  "hasScopedDefault",
+  "focus",
+  "blur"
+];
+const renderless = (props, { reactive, computed, useAttrs }, { constants, vm, components }) => {
+  const api2 = {};
+  const resolvedComponent = computed(() => computedResolvedComponent({ props, constants, vm, components }));
+  const mergedProps = computed(() => {
+    const runtimeAttrs = typeof useAttrs === "function" ? useAttrs() : null;
+    const attrs = runtimeAttrs || vm.$attrs || {};
+    const className = attrs.class;
+    const classArray = Array.isArray(className) ? ["tiny-select", ...className] : className ? ["tiny-select", className] : ["tiny-select"];
+    const _a = attrs, { class: _omitClass } = _a, restAttrs = __objRest(_a, ["class"]);
+    return __spreadProps(__spreadValues(__spreadValues({}, props), restAttrs), {
+      class: Array.from(new Set(classArray)),
+      dataTag: "tiny-select"
+    });
+  });
+  const slotNames = computed(() => Object.keys(vm.$slots || {}).filter((name) => name && name !== "default"));
+  const hasScopedDefault = computed(() => {
+    var _a, _b;
+    const scoped = (_a = vm.$scopedSlots) == null ? void 0 : _a.default;
+    if (scoped && scoped.length) {
+      return true;
+    }
+    const slot = (_b = vm.$slots) == null ? void 0 : _b.default;
+    return typeof slot === "function" && slot.length > 0;
+  });
+  const listeners = computed(() => {
+    if (vm.$listeners) {
+      return vm.$listeners;
+    }
+    return {};
+  });
+  const getChildComponent = () => {
+    var _a;
+    return (_a = vm.$refs) == null ? void 0 : _a.childComponent;
+  };
+  const state = new Proxy(
+    {},
+    {
+      get(target, prop) {
+        var _a;
+        const child = getChildComponent();
+        return (_a = child == null ? void 0 : child.state) == null ? void 0 : _a[prop];
+      },
+      set(target, prop, value) {
+        const child = getChildComponent();
+        if (child == null ? void 0 : child.state) {
+          child.state[prop] = value;
+          return true;
+        }
+        return false;
+      },
+      has(target, prop) {
+        const child = getChildComponent();
+        return prop in ((child == null ? void 0 : child.state) || {});
+      },
+      ownKeys(target) {
+        const child = getChildComponent();
+        return Object.keys((child == null ? void 0 : child.state) || {});
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        const child = getChildComponent();
+        const childState = (child == null ? void 0 : child.state) || {};
+        if (prop in childState) {
+          return {
+            enumerable: true,
+            configurable: true,
+            value: childState[prop]
+          };
+        }
+        return void 0;
+      }
+    }
+  );
+  const focus = () => {
+    const child = getChildComponent();
+    child && typeof child.focus === "function" && child.focus();
+  };
+  const blur = () => {
+    const child = getChildComponent();
+    child && typeof child.blur === "function" && child.blur();
+  };
+  const hasData = (value) => {
+    if (!value) {
+      return false;
+    }
+    if (Array.isArray(value)) {
+      return value.length > 0;
+    }
+    if (typeof value === "object") {
+      return Object.keys(value).length > 0;
+    }
+    return true;
+  };
+  const computedResolvedComponent = ({ props: props2, constants: constants2, vm: vm2, components: components2 }) => {
+    var _a;
+    const comps = components2 || ((_a = vm2.$options) == null ? void 0 : _a.components) || {};
+    if (props2.renderType === constants2.TYPE.Tree || hasData(props2.treeOp)) {
+      return comps.TinyTreeSelect || "TinyTreeSelect";
+    }
+    if (props2.renderType === constants2.TYPE.Grid || hasData(props2.gridOp)) {
+      return comps.TinyGridSelect || "TinyGridSelect";
+    }
+    return comps.TinyBaseSelect || "TinyBaseSelect";
+  };
+  Object.assign(api2, {
+    state,
+    resolvedComponent,
+    mergedProps,
+    listeners,
+    slotNames,
+    hasScopedDefault,
+    focus,
+    blur
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/switch/vue.js

@@ -18,6 +18,25 @@ const renderless = (props, { computed, watch, reactive, inject }, { parent, cons
       } else {
         return props.showText;
       }
+    }),
+    // 添加 switchStyle 计算属性
+    switchStyle: computed(() => {
+      if (props.width) {
+        return {
+          width: typeof props.width === "number" ? `${props.width}px` : props.width
+        };
+      }
+      return {};
+    }),
+    // 添加 displayOnlyStyle 计算属性
+    displayOnlyStyle: computed(() => {
+      if (props.width) {
+        return {
+          width: typeof props.width === "number" ? `${props.width}px` : props.width,
+          display: "inline-block"
+        };
+      }
+      return {};
     })
   });
   const api2 = {

package/tabs-mf/index.js

@@ -96,16 +96,24 @@ const clickMore = (api) => (name) => {
   api.setActive(name);
   api.scrollTo(name);
 };
-const removeItem = ({ props, state, emit }) => (name, silent = false) => {
+const removeItem = ({ props, state, emit, api }) => (name, silent = false) => {
   const itemIndex = state.items.findIndex((item) => item.name === name);
   const navIndex = state.navs.findIndex((item) => item.name === name);
+  const isCurrent = state.currentItem && state.currentItem.name === name;
+  const nextNav = state.navs[navIndex - 1] || state.navs[navIndex + 1];
   if (!~itemIndex)
     return;
   const emitEvent = () => {
+    var _a;
     state.items.splice(itemIndex, 1);
     state.items = [...state.items];
     state.navs.splice(navIndex, 1);
     state.navs = [...state.navs];
+    if (isCurrent) {
+      const nextName = nextNav ? nextNav.name : ((_a = state.items[0]) == null ? void 0 : _a.name) || "";
+      api.changeCurrentName(nextName);
+      state.currentItem = state.items.find((item) => item.name === nextName) || null;
+    }
     if (!silent) {
       emit("edit", name, "remove");
       emit("close", name);

package/tabs-mf/vue-nav.js

@@ -1,6 +1,6 @@
 import "../chunk-G2ADBYYC.js";
 const api = ["state"];
-const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmount }, { vm }) => {
+const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmount, watch, nextTick }, { vm }) => {
   const tabs = inject("tabs", null);
   const state = reactive({
     navItems: computed(() => tabs.state.items),
@@ -11,18 +11,75 @@ const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmo
     currentWidth: 0,
     currentPosition: 0
   });
-  let observer;
+  const updateSliderBar = () => {
+    const nav = state.currentNav;
+    if (nav && nav.$el) {
+      state.currentWidth = nav.$el.offsetWidth || 0;
+      state.currentPosition = nav.$el.offsetLeft || 0;
+    }
+  };
+  let mutationObserver;
+  let resizeObserver;
   onMounted(() => {
-    observer = new MutationObserver((mutationsList) => {
-      const nav = state.currentNav;
-      state.currentWidth = nav && nav.$el.offsetWidth || 0;
-      state.currentPosition = nav && nav.$el.offsetLeft || 0;
+    mutationObserver = new MutationObserver(() => {
+      nextTick(() => {
+        updateSliderBar();
+      });
+    });
+    mutationObserver.observe(vm.$el, { attributes: true, subtree: true, childList: true });
+    if (typeof ResizeObserver !== "undefined") {
+      resizeObserver = new ResizeObserver(() => {
+        nextTick(() => {
+          updateSliderBar();
+        });
+      });
+      const navItems = vm.$el.querySelectorAll('[data-tag="tiny-tab-nav-item"]');
+      navItems.forEach((item) => {
+        resizeObserver.observe(item);
+      });
+    }
+    nextTick(() => {
+      updateSliderBar();
     });
-    observer.observe(vm.$el, { attributes: true, subtree: true });
   });
+  watch(
+    () => state.currentNav,
+    () => {
+      nextTick(() => {
+        updateSliderBar();
+      });
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.navItems,
+    () => {
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+        nextTick(() => {
+          const navItems = vm.$el.querySelectorAll('[data-tag="tiny-tab-nav-item"]');
+          navItems.forEach((item) => {
+            resizeObserver.observe(item);
+          });
+          updateSliderBar();
+        });
+      } else {
+        nextTick(() => {
+          updateSliderBar();
+        });
+      }
+    },
+    { deep: true }
+  );
   onBeforeUnmount(() => {
-    observer.disconnect();
-    observer = null;
+    if (mutationObserver) {
+      mutationObserver.disconnect();
+      mutationObserver = null;
+    }
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+      resizeObserver = null;
+    }
   });
   Object.assign(api, {
     state

package/tabs-mf/vue.js

@@ -53,7 +53,7 @@ const renderless = (props, hooks, { vm, emit, nextTick }) => {
     addItem: addItem(state),
     addNav: addNav(state),
     scrollTo: scrollTo({ vm, state }),
-    removeItem: removeItem({ props, state, emit }),
+    removeItem: removeItem({ props, state, emit, api: api2 }),
     changeCurrentName: changeCurrentName({ state, emit }),
     clickMore: clickMore(api2),
     beforeCarouselSwipe: beforeCarouselSwipe({ api: api2, state, vm }),
@@ -82,11 +82,27 @@ const renderless = (props, hooks, { vm, emit, nextTick }) => {
     () => props.modelValue,
     (name) => name && api2.setActive(name)
   );
+  watch(
+    () => state.cacheCurrentItem,
+    (newItem) => {
+      if (newItem && newItem !== state.currentItem) {
+        state.currentItem = newItem;
+      }
+    },
+    { immediate: true }
+  );
   onMounted(() => {
-    nextTick(() => api2.observeTabSwipeSize());
-    state.currentItem = state.cacheCurrentItem;
-    props.activeName && api2.scrollTo(props.activeName);
-    props.modelValue && api2.scrollTo(props.modelValue);
+    nextTick(() => {
+      api2.observeTabSwipeSize();
+      if (!state.currentItem && state.cacheCurrentItem) {
+        state.currentItem = state.cacheCurrentItem;
+      }
+      if (!props.activeName && !props.modelValue && state.items.length > 0 && !state.cacheCurrentItem) {
+        api2.changeCurrentName(state.items[0].name);
+      }
+      props.activeName && api2.scrollTo(props.activeName);
+      props.modelValue && api2.scrollTo(props.modelValue);
+    });
   });
   onBeforeUnmount(() => {
     api2.unobserveTabSwipeSize();

package/transfer-panel/index.js

@@ -39,10 +39,11 @@ const getFilterData = ({ api, props, state, Table, Tree }) => () => {
     return showFilterData(api.getFilterTreeData(copyArray(props.data)), "visible");
   } else {
     return props.data.filter((item) => {
+      var _a;
       if (typeof props.filterMethod === "function") {
         return props.filterMethod(state.query, item);
       } else {
-        const label = item[state.labelProp] || item[state.keyProp].toString();
+        const label = item[state.labelProp] || ((_a = item[state.keyProp]) == null ? void 0 : _a.toString()) || "";
         return label.toLowerCase().includes(state.query.toLowerCase());
       }
     });

package/tree-select/index.js

@@ -87,16 +87,20 @@ const getChildValue = () => (childNodes, key) => {
   return ids;
 };
 const mounted = ({ api, state, props, vm }) => () => {
-  if (!state.modelValue || state.modelValue.length === 0)
+  if (!state.modelValue || Array.isArray(state.modelValue) && state.modelValue.length === 0)
     return;
   if (props.multiple) {
     let initialNodes = [];
     if (Array.isArray(state.modelValue)) {
       state.modelValue.forEach((value) => {
         const option = api.getPluginOption(value);
-        initialNodes = initialNodes.concat(option);
+        if (option && option.length > 0) {
+          initialNodes = initialNodes.concat(option);
+        }
       });
     }
+    if (initialNodes.length === 0)
+      return;
     const selected = initialNodes.map((node) => {
       return __spreadProps(__spreadValues({}, node), {
         currentLabel: node[props.textField],
@@ -106,7 +110,10 @@ const mounted = ({ api, state, props, vm }) => () => {
     vm.$refs.baseSelectRef.updateSelectedData(selected);
     state.defaultCheckedKeys = api.getCheckedData(selected);
   } else {
-    const data = api.getPluginOption(state.modelValue)[0];
+    const options = api.getPluginOption(state.modelValue);
+    const data = options && options.length > 0 ? options[0] : null;
+    if (!data)
+      return;
     vm.$refs.baseSelectRef.updateSelectedData(__spreadProps(__spreadValues({}, data), {
       currentLabel: data[props.textField],
       value: data[props.valueField],
@@ -138,7 +145,9 @@ const watchValue = ({ api, props, vm, state }) => (newValue, oldValue) => {
     if (Array.isArray(checkedKeys)) {
       checkedKeys.forEach((value) => {
         const option = api.getPluginOption(value);
-        initialNodes = initialNodes.concat(option);
+        if (option && option.length > 0) {
+          initialNodes = initialNodes.concat(option);
+        }
       });
     }
     const selected = initialNodes.map((node) => {

package/tree-select/vue.js

@@ -13,12 +13,21 @@ import {
 const api = ["state", "check", "filter", "nodeClick"];
 const renderless = (props, { reactive, computed, watch, onMounted }, { vm, emit }) => {
   const api2 = {};
+  const resolveTreeData = () => {
+    if (Array.isArray(props.treeOp)) {
+      return props.treeOp;
+    }
+    if (props.treeOp && Array.isArray(props.treeOp.data)) {
+      return props.treeOp.data;
+    }
+    return [];
+  };
   const state = reactive({
     childrenName: computed(() => props.treeOp.props && props.treeOp.props.children || "children"),
     currentKey: props.modelValue,
     defaultCheckedKeys: [],
     remoteData: [],
-    treeData: props.treeOp.data,
+    treeData: resolveTreeData(),
     modelValue: []
   });
   Object.assign(api2, {
@@ -34,8 +43,15 @@ const renderless = (props, { reactive, computed, watch, onMounted }, { vm, emit
     getChildValue: getChildValue()
   });
   watch(
-    () => props.treeOp.data,
-    (data) => data && (state.treeData = data),
+    () => {
+      var _a;
+      return Array.isArray(props.treeOp) ? props.treeOp : (_a = props.treeOp) == null ? void 0 : _a.data;
+    },
+    (data) => {
+      if (Array.isArray(data)) {
+        state.treeData = data;
+      }
+    },
     { immediate: true, deep: true }
   );
   watch(

package/types/autocomplete.type.d.ts

@@ -160,9 +160,10 @@ declare const highlight: ({ constants, vm, state }: {
 declare const watchVisible: ({ suggestionState, vm }: {
     suggestionState: IAutoCompleteApi['suggestionState'];
 }) => (val: any) => void;
-declare const mounted: ({ vm, state, suggestionState }: {
+declare const mounted: ({ vm, state, suggestionState, props }: {
     state: IAutoCompleteState;
     suggestionState: IAutoCompleteApi['suggestionState'];
+    props: IAutoCompleteProps;
 }) => () => void;
 
 interface IAutoCompleteState {