@opentiny/vue-renderless 3.6.0 → 3.6.1-alpha.2

package/cascader/vue.js

@@ -1,21 +1,58 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-import { getConfig, deleteTag, getCheckedNodes, updateStyle, handleSuggestionClick, handleDelete, handleSuggestionKeyDown, getSuggestions, handleExpandChange, computePresentText, focusFirstNode, handleClear, handleInput, handleBlur, handleFocus, handleKeyDown, handleDropdownLeave, toggleDropDownVisible, computePresentTags, selfMounted, watchCheckedValue, computClearVisible, computePresentContent, watchValue, setInputHeightToTag, presentTextHandler, handleBeforeUpdate } from './index';
-import { removeResizeListener } from '@opentiny/vue-renderless/common/deps/resize-event';
-import userPopper from '@opentiny/vue-renderless/common/deps/vue-popper';
-import { DATEPICKER } from '@opentiny/vue-renderless/common';
-export var api = ['state', 'getCheckedNodes', 'computePresentText', 'handleSuggestionClick', 'handleSuggestionKeyDown', 'handleExpandChange', 'handleDropdownLeave', 'handleDelete', 'deleteTag', 'handleClear', 'handleInput', 'handleBlur', 'handleFocus', 'toggleDropDownVisible', 'handleKeyDown'];
-var initState = function initState(_ref) {
-  var reactive = _ref.reactive,
-    props = _ref.props,
-    computed = _ref.computed,
-    parent = _ref.parent,
-    api = _ref.api,
-    refs = _ref.refs,
-    t = _ref.t,
-    constants = _ref.constants;
-  var state = reactive({
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-PKUHTIDK.js";
+import {
+  getConfig,
+  deleteTag,
+  getCheckedNodes,
+  updateStyle,
+  handleSuggestionClick,
+  handleDelete,
+  handleSuggestionKeyDown,
+  getSuggestions,
+  handleExpandChange,
+  computePresentText,
+  focusFirstNode,
+  handleClear,
+  handleInput,
+  handleBlur,
+  handleFocus,
+  handleKeyDown,
+  handleDropdownLeave,
+  toggleDropDownVisible,
+  computePresentTags,
+  selfMounted,
+  watchCheckedValue,
+  computClearVisible,
+  computePresentContent,
+  watchValue,
+  setInputHeightToTag,
+  presentTextHandler,
+  handleBeforeUpdate
+} from "./index";
+import { removeResizeListener } from "@opentiny/vue-renderless/common/deps/resize-event";
+import userPopper from "@opentiny/vue-renderless/common/deps/vue-popper";
+import { DATEPICKER } from "@opentiny/vue-renderless/common";
+const api = [
+  "state",
+  "getCheckedNodes",
+  "computePresentText",
+  "handleSuggestionClick",
+  "handleSuggestionKeyDown",
+  "handleExpandChange",
+  "handleDropdownLeave",
+  "handleDelete",
+  "deleteTag",
+  "handleClear",
+  "handleInput",
+  "handleBlur",
+  "handleFocus",
+  "toggleDropDownVisible",
+  "handleKeyDown"
+];
+const initState = ({ reactive, props, computed, parent, api: api2, refs, t, constants }) => {
+  const state = reactive({
     dropDownVisible: false,
     checkedValue: props.modelValue || null,
     inputHover: false,
@@ -27,315 +64,118 @@ var initState = function initState(_ref) {
     suggestions: [],
     inputInitialHeight: 0,
     pressDeleteCount: 0,
-    realSize: computed(function () {
-      return props.size;
-    }),
-    formDisabled: computed(function () {
-      return (parent.tinyForm || {}).disabled;
-    }),
-    disabled: computed(function () {
-      return props.disabled || state.formDisabled;
-    }),
-    tagSize: computed(function () {
-      return ~['small', 'mini'].indexOf(state.realSize) ? 'mini' : 'small';
-    }),
-    isDisabled: computed(function () {
-      return state.disabled;
-    }),
-    config: computed(function () {
-      return api.getConfig();
-    }),
-    multiple: computed(function () {
-      return state.config.multiple;
-    }),
-    leafOnly: computed(function () {
-      return !state.config.checkStrictly;
-    }),
-    readonly: computed(function () {
-      return !props.filterable || state.multiple;
-    }),
-    clearBtnVisible: computed(function () {
-      return api.computClearVisible();
-    }),
-    panel: computed(function () {
-      return refs.panel;
-    }),
-    placeholder: computed(function () {
-      return props.placeholder || t(constants.placeholder);
-    }),
-    inputValues: computed(function () {
-      return state.multiple ? state.presentText : state.inputValue;
-    })
+    realSize: computed(() => props.size),
+    formDisabled: computed(() => (parent.tinyForm || {}).disabled),
+    disabled: computed(() => props.disabled || state.formDisabled),
+    tagSize: computed(() => ~["small", "mini"].indexOf(state.realSize) ? "mini" : "small"),
+    isDisabled: computed(() => state.disabled),
+    config: computed(() => api2.getConfig()),
+    multiple: computed(() => state.config.multiple),
+    leafOnly: computed(() => !state.config.checkStrictly),
+    readonly: computed(() => !props.filterable || state.multiple),
+    clearBtnVisible: computed(() => api2.computClearVisible()),
+    panel: computed(() => refs.panel),
+    placeholder: computed(() => props.placeholder || t(constants.placeholder)),
+    inputValues: computed(() => state.multiple ? state.presentText : state.inputValue)
   });
   return state;
 };
-var initApi = function initApi(_ref2) {
-  var api = _ref2.api,
-    state = _ref2.state,
-    constants = _ref2.constants,
-    dispatch = _ref2.dispatch,
-    emit = _ref2.emit,
-    refs = _ref2.refs,
-    props = _ref2.props,
-    updatePopper = _ref2.updatePopper,
-    nextTick = _ref2.nextTick,
-    parent = _ref2.parent;
-  Object.assign(api, {
-    state: state,
-    handleBlur: handleBlur({
-      constants: constants,
-      dispatch: dispatch,
-      emit: emit,
-      state: state
-    }),
+const initApi = ({ api: api2, state, constants, dispatch, emit, refs, props, updatePopper, nextTick, parent }) => {
+  Object.assign(api2, {
+    state,
+    handleBlur: handleBlur({ constants, dispatch, emit, state }),
     handleFocus: handleFocus(emit),
     handleClear: handleClear(state),
     getCheckedNodes: getCheckedNodes(state),
-    deleteTag: deleteTag({
-      emit: emit,
-      state: state
-    }),
+    deleteTag: deleteTag({ emit, state }),
     handleDropdownLeave: handleDropdownLeave(state),
-    focusFirstNode: focusFirstNode({
-      refs: refs,
-      state: state
-    }),
-    computClearVisible: computClearVisible({
-      props: props,
-      state: state
-    }),
-    updateStyle: updateStyle({
-      parent: parent,
-      refs: refs,
-      state: state,
-      updatePopper: updatePopper
-    }),
-    getSuggestions: getSuggestions({
-      nextTick: nextTick,
-      props: props,
-      state: state,
-      updatePopper: updatePopper
-    }),
-    handleExpandChange: handleExpandChange({
-      constants: constants,
-      emit: emit,
-      dispatch: dispatch,
-      nextTick: nextTick,
-      state: state,
-      updatePopper: updatePopper
-    }),
-    getConfig: getConfig({
-      parent: parent,
-      props: props
-    }),
-    setInputHeightToTag: setInputHeightToTag({
-      nextTick: nextTick,
-      parent: parent
-    }),
-    handleSuggestionClick: handleSuggestionClick({
-      api: api,
-      state: state
-    }),
-    handleDelete: handleDelete({
-      api: api,
-      state: state
-    }),
-    computePresentText: computePresentText({
-      props: props,
-      state: state
-    }),
-    handleSuggestionKeyDown: handleSuggestionKeyDown({
-      api: api
-    }),
-    handleInput: handleInput({
-      api: api,
-      state: state,
-      refs: refs
-    }),
-    handleKeyDown: handleKeyDown({
-      api: api
-    }),
-    watchValue: watchValue({
-      api: api,
-      state: state
-    }),
-    computePresentTags: computePresentTags({
-      api: api,
-      props: props,
-      state: state
-    }),
-    computePresentContent: computePresentContent({
-      api: api,
-      state: state
-    }),
-    watchCheckedValue: watchCheckedValue({
-      api: api,
-      emit: emit,
-      state: state
-    }),
-    toggleDropDownVisible: toggleDropDownVisible({
-      emit: emit,
-      nextTick: nextTick,
-      refs: refs,
-      state: state,
-      updatePopper: updatePopper
-    }),
-    selfMounted: selfMounted({
-      api: api,
-      parent: parent,
-      props: props,
-      refs: refs,
-      state: state
-    }),
-    handleBeforeUpdate: handleBeforeUpdate({
-      props: props,
-      api: api
-    })
+    focusFirstNode: focusFirstNode({ refs, state }),
+    computClearVisible: computClearVisible({ props, state }),
+    updateStyle: updateStyle({ parent, refs, state, updatePopper }),
+    getSuggestions: getSuggestions({ nextTick, props, state, updatePopper }),
+    handleExpandChange: handleExpandChange({ constants, emit, dispatch, nextTick, state, updatePopper }),
+    getConfig: getConfig({ parent, props }),
+    setInputHeightToTag: setInputHeightToTag({ nextTick, parent }),
+    handleSuggestionClick: handleSuggestionClick({ api: api2, state }),
+    handleDelete: handleDelete({ api: api2, state }),
+    computePresentText: computePresentText({ props, state }),
+    handleSuggestionKeyDown: handleSuggestionKeyDown({ api: api2 }),
+    handleInput: handleInput({ api: api2, state, refs }),
+    handleKeyDown: handleKeyDown({ api: api2 }),
+    watchValue: watchValue({ api: api2, state }),
+    computePresentTags: computePresentTags({ api: api2, props, state }),
+    computePresentContent: computePresentContent({ api: api2, state }),
+    watchCheckedValue: watchCheckedValue({ api: api2, emit, state }),
+    toggleDropDownVisible: toggleDropDownVisible({ emit, nextTick, refs, state, updatePopper }),
+    selfMounted: selfMounted({ api: api2, parent, props, refs, state }),
+    handleBeforeUpdate: handleBeforeUpdate({ props, api: api2 })
   });
 };
-var initWatch = function initWatch(_ref3) {
-  var watch = _ref3.watch,
-    state = _ref3.state,
-    api = _ref3.api,
-    props = _ref3.props,
-    nextTick = _ref3.nextTick,
-    updatePopper = _ref3.updatePopper;
-  watch(function () {
-    return state.disabled;
-  }, api.computePresentContent);
-  watch(function () {
-    return props.modelValue;
-  }, api.watchValue);
-  watch(function () {
-    return state.checkedValue;
-  }, api.watchCheckedValue);
-  watch(function () {
-    return props.options;
-  }, function () {
-    return nextTick(api.computePresentContent);
-  }, {
-    deep: true,
-    immediate: true
-  });
-  watch(function () {
-    return state.presentText;
-  }, function (value) {
-    return presentTextHandler({
-      state: state,
-      value: value
-    });
-  });
-  watch(function () {
-    return state.presentTags;
-  }, function (value, oldvalue) {
-    state.multiple && (value.length || oldvalue.length) && nextTick(function () {
-      return api.updateStyle();
-    });
-  });
-  watch(function () {
-    return state.filtering;
-  }, function () {
-    return nextTick(function () {
-      return updatePopper();
-    });
-  });
-  watch(function () {
-    return state.multiple;
-  }, api.setInputHeightToTag);
-  watch(function () {
-    return state.dropDownVisible;
-  }, function (value) {
-    return value && setTimeout(function () {
-      return updatePopper();
-    });
-  });
-  watch(function () {
-    return Array.isArray(state.checkedValue) && state.checkedValue.length;
-  }, function () {
-    return setTimeout(function () {
-      return updatePopper();
-    });
-  });
+const initWatch = ({ watch, state, api: api2, props, nextTick, updatePopper }) => {
+  watch(() => state.disabled, api2.computePresentContent);
+  watch(() => props.modelValue, api2.watchValue);
+  watch(() => state.checkedValue, api2.watchCheckedValue);
+  watch(
+    () => props.options,
+    () => nextTick(api2.computePresentContent),
+    { deep: true, immediate: true }
+  );
+  watch(
+    () => state.presentText,
+    (value) => presentTextHandler({ state, value })
+  );
+  watch(
+    () => state.presentTags,
+    (value, oldvalue) => {
+      state.multiple && (value.length || oldvalue.length) && nextTick(() => api2.updateStyle());
+    }
+  );
+  watch(
+    () => state.filtering,
+    () => nextTick(() => updatePopper())
+  );
+  watch(() => state.multiple, api2.setInputHeightToTag);
+  watch(
+    () => state.dropDownVisible,
+    (value) => value && setTimeout(() => updatePopper())
+  );
+  watch(
+    () => Array.isArray(state.checkedValue) && state.checkedValue.length,
+    () => setTimeout(() => updatePopper())
+  );
 };
-export var renderless = function renderless(props, _ref4, _ref5) {
-  var computed = _ref4.computed,
-    onMounted = _ref4.onMounted,
-    onBeforeUnmount = _ref4.onBeforeUnmount,
-    onDeactivated = _ref4.onDeactivated,
-    onUpdated = _ref4.onUpdated,
-    onBeforeUpdate = _ref4.onBeforeUpdate,
-    reactive = _ref4.reactive,
-    toRefs = _ref4.toRefs,
-    watch = _ref4.watch,
-    inject = _ref4.inject;
-  var t = _ref5.t,
-    refs = _ref5.refs,
-    emit = _ref5.emit,
-    nextTick = _ref5.nextTick,
-    constants = _ref5.constants,
-    parent = _ref5.parent,
-    slots = _ref5.slots,
-    dispatch = _ref5.dispatch;
-  parent.tinyForm = parent.tinyForm || inject('form', null);
-  var _userPopper = userPopper({
-      reactive: reactive,
-      watch: watch,
-      emit: emit,
-      props: _objectSpread(_objectSpread({}, props), {}, {
-        placement: DATEPICKER.PlacementMap.left,
-        popperOptions: {
-          boundariesPadding: 0,
-          gpuAcceleration: false
-        },
-        visibleArrow: true,
-        offset: 0,
-        boundariesPadding: 5,
-        arrowOffset: 35
-      }),
-      toRefs: toRefs,
-      refs: refs,
-      slots: slots,
-      nextTick: nextTick,
-      onBeforeUnmount: onBeforeUnmount,
-      onDeactivated: onDeactivated
-    }),
-    updatePopper = _userPopper.updatePopper;
-  var api = {};
-  var state = initState({
-    reactive: reactive,
-    props: props,
-    computed: computed,
-    parent: parent,
-    api: api,
-    refs: refs,
-    t: t,
-    constants: constants
+const renderless = (props, { computed, onMounted, onBeforeUnmount, onDeactivated, onUpdated, onBeforeUpdate, reactive, toRefs, watch, inject }, { t, refs, emit, nextTick, constants, parent, slots, dispatch }) => {
+  parent.tinyForm = parent.tinyForm || inject("form", null);
+  const { updatePopper } = userPopper({
+    reactive,
+    watch,
+    emit,
+    props: __spreadProps(__spreadValues({}, props), {
+      placement: DATEPICKER.PlacementMap.left,
+      popperOptions: { boundariesPadding: 0, gpuAcceleration: false },
+      visibleArrow: true,
+      offset: 0,
+      boundariesPadding: 5,
+      arrowOffset: 35
+    }),
+    toRefs,
+    refs,
+    slots,
+    nextTick,
+    onBeforeUnmount,
+    onDeactivated
   });
-  initApi({
-    api: api,
-    state: state,
-    constants: constants,
-    dispatch: dispatch,
-    emit: emit,
-    refs: refs,
-    props: props,
-    updatePopper: updatePopper,
-    nextTick: nextTick,
-    parent: parent
-  });
-  initWatch({
-    watch: watch,
-    state: state,
-    api: api,
-    props: props,
-    nextTick: nextTick,
-    updatePopper: updatePopper
-  });
-  onBeforeUpdate(api.handleBeforeUpdate);
-  onUpdated(api.updateStyle);
-  onMounted(api.selfMounted);
-  onBeforeUnmount(function () {
-    return removeResizeListener(parent.$el, api.updateStyle);
-  });
-  return api;
-};
+  const api2 = {};
+  const state = initState({ reactive, props, computed, parent, api: api2, refs, t, constants });
+  initApi({ api: api2, state, constants, dispatch, emit, refs, props, updatePopper, nextTick, parent });
+  initWatch({ watch, state, api: api2, props, nextTick, updatePopper });
+  onBeforeUpdate(api2.handleBeforeUpdate);
+  onUpdated(api2.updateStyle);
+  onMounted(api2.selfMounted);
+  onBeforeUnmount(() => removeResizeListener(parent.$el, api2.updateStyle));
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/cascader-menu/index.js

@@ -1,41 +1,34 @@
-export var handleExpand = function handleExpand(state) {
-  return function (e) {
-    return state.activeNode = e.target;
-  };
+import "../chunk-PKUHTIDK.js";
+const handleExpand = (state) => (e) => state.activeNode = e.target;
+const handleMouseMove = ({ api, parent, refs, state, svg }) => (e) => {
+  const { hoverZone } = refs;
+  if (!state.activeNode || !hoverZone) {
+    return;
+  }
+  if (state.activeNode.contains(e.target)) {
+    clearTimeout(state.hoverTimer);
+    const { left } = refs.cascaderMenu.$parent.$el.getBoundingClientRect();
+    const startX = e.clientX - left;
+    const { offsetWidth, offsetHeight } = refs.cascaderMenu.$parent.$el;
+    const top = state.activeNode.offsetTop;
+    const bottom = top + state.activeNode.offsetHeight;
+    hoverZone.innerHTML = `
+      ${svg}${startX} ${top} L${offsetWidth} 0 V${top} Z" />
+      ${svg}${startX} ${bottom} L${offsetWidth} ${offsetHeight} V${bottom} Z" />
+    `;
+  } else if (!state.hoverTimer) {
+    state.hoverTimer = setTimeout(api.clearHoverZone, parent.state.config.hoverThreshold);
+  }
 };
-export var handleMouseMove = function handleMouseMove(_ref) {
-  var api = _ref.api,
-    parent = _ref.parent,
-    refs = _ref.refs,
-    state = _ref.state,
-    svg = _ref.svg;
-  return function (e) {
-    var hoverZone = refs.hoverZone;
-    if (!state.activeNode || !hoverZone) {
-      return;
-    }
-    if (state.activeNode.contains(e.target)) {
-      clearTimeout(state.hoverTimer);
-      var _refs$cascaderMenu$$p = refs.cascaderMenu.$parent.$el.getBoundingClientRect(),
-        left = _refs$cascaderMenu$$p.left;
-      var startX = e.clientX - left;
-      var _refs$cascaderMenu$$p2 = refs.cascaderMenu.$parent.$el,
-        offsetWidth = _refs$cascaderMenu$$p2.offsetWidth,
-        offsetHeight = _refs$cascaderMenu$$p2.offsetHeight;
-      var top = state.activeNode.offsetTop;
-      var bottom = top + state.activeNode.offsetHeight;
-      hoverZone.innerHTML = "\n      ".concat(svg).concat(startX, " ").concat(top, " L").concat(offsetWidth, " 0 V").concat(top, " Z\" />\n      ").concat(svg).concat(startX, " ").concat(bottom, " L").concat(offsetWidth, " ").concat(offsetHeight, " V").concat(bottom, " Z\" />\n    ");
-    } else if (!state.hoverTimer) {
-      state.hoverTimer = setTimeout(api.clearHoverZone, parent.state.config.hoverThreshold);
-    }
-  };
+const clearHoverZone = (refs) => () => {
+  const { hoverZone } = refs;
+  if (!hoverZone) {
+    return;
+  }
+  hoverZone.innerHTML = "";
+};
+export {
+  clearHoverZone,
+  handleExpand,
+  handleMouseMove
 };
-export var clearHoverZone = function clearHoverZone(refs) {
-  return function () {
-    var hoverZone = refs.hoverZone;
-    if (!hoverZone) {
-      return;
-    }
-    hoverZone.innerHTML = '';
-  };
-};

package/cascader-menu/vue.js

@@ -1,36 +1,27 @@
-import { handleExpand, handleMouseMove, clearHoverZone } from './index';
-import { CASCADER } from '@opentiny/vue-renderless/common';
-import { random } from '@opentiny/vue-renderless/common/string';
-export var api = ['state', 'handleMouseMove', 'handleExpand'];
-export var renderless = function renderless(props, _ref, _ref2) {
-  var computed = _ref.computed,
-    reactive = _ref.reactive;
-  var vm = _ref2.vm,
-    parent = _ref2.parent;
-  var refs = vm.$refs;
-  var api = {};
-  var state = reactive({
+import "../chunk-PKUHTIDK.js";
+import { handleExpand, handleMouseMove, clearHoverZone } from "./index";
+import { CASCADER } from "@opentiny/vue-renderless/common";
+import { random } from "@opentiny/vue-renderless/common/string";
+const api = ["state", "handleMouseMove", "handleExpand"];
+const renderless = (props, { computed, reactive }, { vm, parent }) => {
+  const refs = vm.$refs;
+  const api2 = {};
+  const state = reactive({
     activeNode: null,
     hoverTimer: null,
-    id: Math.floor(random() * 10000),
-    isEmpty: computed(function () {
-      return !props.nodes.length;
-    }),
-    menuId: computed(function () {
-      return "".concat(CASCADER.MenuConnector).concat(state.id, "-").concat(props.index);
-    })
+    id: Math.floor(random() * 1e4),
+    isEmpty: computed(() => !props.nodes.length),
+    menuId: computed(() => `${CASCADER.MenuConnector}${state.id}-${props.index}`)
   });
-  Object.assign(api, {
-    state: state,
+  Object.assign(api2, {
+    state,
     clearHoverZone: clearHoverZone(refs),
     handleExpand: handleExpand(state),
-    handleMouseMove: handleMouseMove({
-      api: api,
-      parent: parent,
-      refs: refs,
-      state: state,
-      svg: CASCADER.SvgStr
-    })
+    handleMouseMove: handleMouseMove({ api: api2, parent, refs, state, svg: CASCADER.SvgStr })
   });
-  return api;
-};
+  return api2;
+};
+export {
+  api,
+  renderless
+};