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

package/cascader-panel/index.js

@@ -1,101 +1,62 @@
-import { isNull } from '@opentiny/vue-renderless/common/type';
-import { isEqual } from '@opentiny/vue-renderless/common/object';
-import { isEmpty } from '@opentiny/vue-renderless/cascader';
-import { KEY_CODE, CASCADER } from '@opentiny/vue-renderless/common';
-export var watchCheckedValue = function watchCheckedValue(_ref) {
-  var api = _ref.api,
-    emit = _ref.emit,
-    props = _ref.props,
-    state = _ref.state;
-  return function (value) {
-    if (!isEqual(value, props.modelValue)) {
-      state.checkStrictly && api.calculateCheckedNodePaths();
-      emit('update:modelValue', value);
-      emit('change', value);
-    }
-  };
+import "../chunk-PKUHTIDK.js";
+import { isNull } from "@opentiny/vue-renderless/common/type";
+import { isEqual } from "@opentiny/vue-renderless/common/object";
+import { isEmpty } from "@opentiny/vue-renderless/cascader";
+import { KEY_CODE, CASCADER } from "@opentiny/vue-renderless/common";
+const watchCheckedValue = ({ api, emit, props, state }) => (value) => {
+  if (!isEqual(value, props.modelValue)) {
+    state.checkStrictly && api.calculateCheckedNodePaths();
+    emit("update:modelValue", value);
+    emit("change", value);
+  }
 };
-export var initStore = function initStore(_ref2) {
-  var api = _ref2.api,
-    props = _ref2.props,
-    state = _ref2.state,
-    Store = _ref2.Store;
-  return function () {
-    if (state.config.lazy && isEmpty(props.options)) {
-      api.lazyLoad();
-    } else {
-      state.store = new Store(props.options, state.config);
-      state.menus = [state.store.getNodes()];
-      api.syncMenuState();
-    }
-  };
+const initStore = ({ api, props, state, Store }) => () => {
+  if (state.config.lazy && isEmpty(props.options)) {
+    api.lazyLoad();
+  } else {
+    state.store = new Store(props.options, state.config);
+    state.menus = [state.store.getNodes()];
+    api.syncMenuState();
+  }
 };
-export var syncCheckedValue = function syncCheckedValue(_ref3) {
-  var api = _ref3.api,
-    props = _ref3.props,
-    state = _ref3.state;
-  return function () {
-    if (!isEqual(props.modelValue, state.checkedValue)) {
-      state.checkedValue = props.modelValue;
-      api.syncMenuState();
-    }
-  };
+const syncCheckedValue = ({ api, props, state }) => () => {
+  if (!isEqual(props.modelValue, state.checkedValue)) {
+    state.checkedValue = props.modelValue;
+    api.syncMenuState();
+  }
 };
-export var syncMenuState = function syncMenuState(_ref4) {
-  var api = _ref4.api,
-    nextTick = _ref4.nextTick,
-    state = _ref4.state;
-  return function () {
-    api.syncActivePath();
-    state.multiple && api.syncMultiCheckState();
-    state.checkStrictly && api.calculateCheckedNodePaths();
-    nextTick(function () {
-      return api.scrollIntoView;
-    });
-  };
+const syncMenuState = ({ api, nextTick, state }) => () => {
+  api.syncActivePath();
+  state.multiple && api.syncMultiCheckState();
+  state.checkStrictly && api.calculateCheckedNodePaths();
+  nextTick(() => api.scrollIntoView);
 };
-export var syncMultiCheckState = function syncMultiCheckState(_ref5) {
-  var api = _ref5.api,
-    state = _ref5.state;
-  return function () {
-    var nodes = api.getFlattedNodes(state.leafOnly);
-    nodes.forEach(function (node) {
-      node.syncCheckState(state.checkedValue);
-    });
-  };
+const syncMultiCheckState = ({ api, state }) => () => {
+  const nodes = api.getFlattedNodes(state.leafOnly);
+  nodes.forEach((node) => {
+    node.syncCheckState(state.checkedValue);
+  });
 };
-export var syncActivePath = function syncActivePath(_ref6) {
-  var api = _ref6.api,
-    state = _ref6.state;
-  return function () {
-    if (!isEmpty(state.activePath)) {
-      var nodes = state.activePath.map(function (node) {
-        return api.getNodeByValue(node.getValue());
-      });
-      if (isNull(nodes[0])) {
-        state.activePath = [];
-      } else {
-        api.expandNodes(nodes);
-      }
-    } else if (!isEmpty(state.checkedValue)) {
-      var value = state.multiple ? state.checkedValue[0] : state.checkedValue;
-      var checkedNode = api.getNodeByValue(value) || {};
-      var _nodes = (checkedNode.pathNodes || []).slice(0, -1);
-      api.expandNodes(_nodes);
-    } else {
+const syncActivePath = ({ api, state }) => () => {
+  if (!isEmpty(state.activePath)) {
+    const nodes = state.activePath.map((node) => api.getNodeByValue(node.getValue()));
+    if (isNull(nodes[0])) {
       state.activePath = [];
-      state.menus = [state.store.getNodes()];
+    } else {
+      api.expandNodes(nodes);
     }
-  };
-};
-export var expandNodes = function expandNodes(api) {
-  return function (nodes) {
-    return nodes.forEach(function (node) {
-      return api.handleExpand(node, true);
-    });
-  };
+  } else if (!isEmpty(state.checkedValue)) {
+    const value = state.multiple ? state.checkedValue[0] : state.checkedValue;
+    const checkedNode = api.getNodeByValue(value) || {};
+    const nodes = (checkedNode.pathNodes || []).slice(0, -1);
+    api.expandNodes(nodes);
+  } else {
+    state.activePath = [];
+    state.menus = [state.store.getNodes()];
+  }
 };
-export var coerceTruthyValueToArray = function coerceTruthyValueToArray(val) {
+const expandNodes = (api) => (nodes) => nodes.forEach((node) => api.handleExpand(node, true));
+const coerceTruthyValueToArray = (val) => {
   if (Array.isArray(val)) {
     return val;
   } else if (val) {
@@ -103,265 +64,222 @@ export var coerceTruthyValueToArray = function coerceTruthyValueToArray(val) {
   }
   return [];
 };
-export var calculateCheckedNodePaths = function calculateCheckedNodePaths(_ref7) {
-  var api = _ref7.api,
-    state = _ref7.state;
-  return function () {
-    var checkedValues = state.multiple ? coerceTruthyValueToArray(state.checkedValue) : [state.checkedValue];
-    state.checkedNodePaths = checkedValues.map(function (v) {
-      var checkedNode = api.getNodeByValue(v);
-      return checkedNode ? checkedNode.pathNodes : [];
-    });
-  };
+const calculateCheckedNodePaths = ({ api, state }) => () => {
+  const checkedValues = state.multiple ? coerceTruthyValueToArray(state.checkedValue) : [state.checkedValue];
+  state.checkedNodePaths = checkedValues.map((v) => {
+    const checkedNode = api.getNodeByValue(v);
+    return checkedNode ? checkedNode.pathNodes : [];
+  });
 };
-export var focusNode = function focusNode(api) {
-  return function (el) {
-    if (!el) {
-      return;
-    }
-    el.focus();
-    !api.isLeaf(el) && el.click();
-  };
-};
-export var getMenuIndex = function getMenuIndex() {
-  return function (el) {
-    if (!el) {
-      return;
-    }
-    var pieces = el.id.split('-');
-    return Number(pieces[pieces.length - 2]);
-  };
+const focusNode = (api) => (el) => {
+  if (!el) {
+    return;
+  }
+  el.focus();
+  !api.isLeaf(el) && el.click();
 };
-export var checkNode = function checkNode(api) {
-  return function (el) {
-    if (!el) {
-      return;
-    }
-    var input = el.querySelector('input');
-    if (input) {
-      input.click();
-    } else if (api.isLeaf(el)) {
-      el.click();
-    }
-  };
+const getMenuIndex = () => (el) => {
+  if (!el) {
+    return;
+  }
+  const pieces = el.id.split("-");
+  return Number(pieces[pieces.length - 2]);
 };
-export var handleKeyDown = function handleKeyDown(_ref8) {
-  var api = _ref8.api,
-    emit = _ref8.emit,
-    menus = _ref8.menus;
-  return function (event) {
-    var target = event.target,
-      keyCode = event.keyCode;
-    if (keyCode === KEY_CODE.ArrowUp) {
-      var prev = api.getSibling(target, -1);
-      focusNode(prev);
-    } else if (keyCode === KEY_CODE.ArrowDown) {
-      var next = api.getSibling(target, 1);
-      focusNode(next);
-    } else if (keyCode === KEY_CODE.ArrowLeft) {
-      var preMenu = menus[getMenuIndex(target) - 1];
-      if (preMenu) {
-        var expandedNode = preMenu.$el.querySelector(CASCADER.CascaderNodeExpand);
-        focusNode(expandedNode);
-      }
-    } else if (keyCode === KEY_CODE.ArrowRight) {
-      var nextMenu = menus[getMenuIndex(target) + 1];
-      if (nextMenu) {
-        var firstNode = nextMenu.$el.querySelector(CASCADER.CascaderNodeTab);
-        focusNode(firstNode);
-      }
-    } else if (keyCode === KEY_CODE.Enter) {
-      checkNode(target);
-    } else if (~[KEY_CODE.Escape, KEY_CODE.Tab].indexOf(keyCode)) {
-      emit('close');
-    }
-  };
+const checkNode = (api) => (el) => {
+  if (!el) {
+    return;
+  }
+  const input = el.querySelector("input");
+  if (input) {
+    input.click();
+  } else if (api.isLeaf(el)) {
+    el.click();
+  }
 };
-export var handleExpand = function handleExpand(_ref9) {
-  var emit = _ref9.emit,
-    state = _ref9.state;
-  return function (node, silent) {
-    var level = node.level;
-    var path = state.activePath.slice(0, level - 1);
-    var menus = state.menus.slice(0, level);
-    if (!node.isLeaf) {
-      path.push(node);
-      menus.push(node.children);
+const handleKeyDown = ({ api, emit, menus }) => (event) => {
+  const { target, keyCode } = event;
+  if (keyCode === KEY_CODE.ArrowUp) {
+    const prev = api.getSibling(target, -1);
+    focusNode(prev);
+  } else if (keyCode === KEY_CODE.ArrowDown) {
+    const next = api.getSibling(target, 1);
+    focusNode(next);
+  } else if (keyCode === KEY_CODE.ArrowLeft) {
+    const preMenu = menus[getMenuIndex(target) - 1];
+    if (preMenu) {
+      const expandedNode = preMenu.$el.querySelector(CASCADER.CascaderNodeExpand);
+      focusNode(expandedNode);
     }
-    state.activePath = path;
-    state.menus = menus;
-    if (!silent) {
-      var pathValues = path.map(function (node) {
-        return node.getValue();
-      });
-      emit('active-item-change', pathValues);
-      emit('expand-change', pathValues);
+  } else if (keyCode === KEY_CODE.ArrowRight) {
+    const nextMenu = menus[getMenuIndex(target) + 1];
+    if (nextMenu) {
+      const firstNode = nextMenu.$el.querySelector(CASCADER.CascaderNodeTab);
+      focusNode(firstNode);
     }
-  };
+  } else if (keyCode === KEY_CODE.Enter) {
+    checkNode(target);
+  } else if (~[KEY_CODE.Escape, KEY_CODE.Tab].indexOf(keyCode)) {
+    emit("close");
+  }
 };
-export var handleCheckChange = function handleCheckChange(state) {
-  return function (value) {
-    state.checkedValue = value;
-  };
+const handleExpand = ({ emit, state }) => (node, silent) => {
+  const { level } = node;
+  const path = state.activePath.slice(0, level - 1);
+  const menus = state.menus.slice(0, level);
+  if (!node.isLeaf) {
+    path.push(node);
+    menus.push(node.children);
+  }
+  state.activePath = path;
+  state.menus = menus;
+  if (!silent) {
+    const pathValues = path.map((node2) => node2.getValue());
+    emit("active-item-change", pathValues);
+    emit("expand-change", pathValues);
+  }
 };
-export var lazyLoad = function lazyLoad(_ref10) {
-  var api = _ref10.api,
-    $parent = _ref10.$parent,
-    state = _ref10.state,
-    Store = _ref10.Store;
-  return function (node, onFullfiled) {
-    if (!node) {
-      node = node || {
-        root: true,
-        level: 0
-      };
-      state.store = new Store([], state.config);
-      state.menus = [state.store.getNodes()];
-    }
-    node.loading = true;
-    var afterLoad = function afterLoad(dataList) {
-      var parent = node.root ? null : node;
-      dataList && dataList.length && state.store.appendNodes(dataList, parent);
-      node.loading = false;
-      node.loaded = true;
-      if (Array.isArray(state.checkedValue)) {
-        var nodeValue = state.checkedValue[state.loadCount++];
-        var valueKey = state.config.value;
-        var leafKey = state.config.leaf;
-        if (Array.isArray(dataList) && dataList.filter(function (item) {
-          return item[valueKey] === nodeValue;
-        }).length > 0) {
-          var checkedNode = state.store.getNodeByValue(nodeValue);
-          if (!checkedNode.data[leafKey]) {
-            api.lazyLoad(checkedNode, function () {
-              api.handleExpand(checkedNode);
-            });
-          }
-          if ($parent.computePresentText && state.loadCount === state.checkedValue.length) {
-            $parent.computePresentText();
-          }
+const handleCheckChange = (state) => (value) => {
+  state.checkedValue = value;
+};
+const lazyLoad = ({ api, $parent, state, Store }) => (node, onFullfiled) => {
+  if (!node) {
+    node = node || { root: true, level: 0 };
+    state.store = new Store([], state.config);
+    state.menus = [state.store.getNodes()];
+  }
+  node.loading = true;
+  const afterLoad = (dataList) => {
+    const parent = node.root ? null : node;
+    dataList && dataList.length && state.store.appendNodes(dataList, parent);
+    node.loading = false;
+    node.loaded = true;
+    if (Array.isArray(state.checkedValue)) {
+      const nodeValue = state.checkedValue[state.loadCount++];
+      const valueKey = state.config.value;
+      const leafKey = state.config.leaf;
+      if (Array.isArray(dataList) && dataList.filter((item) => item[valueKey] === nodeValue).length > 0) {
+        const checkedNode = state.store.getNodeByValue(nodeValue);
+        if (!checkedNode.data[leafKey]) {
+          api.lazyLoad(checkedNode, () => {
+            api.handleExpand(checkedNode);
+          });
+        }
+        if ($parent.computePresentText && state.loadCount === state.checkedValue.length) {
+          $parent.computePresentText();
         }
       }
-      onFullfiled && onFullfiled(dataList);
-    };
-    state.config.lazyLoad(node, afterLoad);
+    }
+    onFullfiled && onFullfiled(dataList);
   };
+  state.config.lazyLoad(node, afterLoad);
 };
-export var calculateMultiCheckedValue = function calculateMultiCheckedValue(_ref11) {
-  var api = _ref11.api,
-    state = _ref11.state;
-  return function () {
-    state.checkedValue = api.getCheckedNodes(state.leafOnly).map(function (node) {
-      return node.getValueByOption();
-    });
-  };
+const calculateMultiCheckedValue = ({ api, state }) => () => {
+  state.checkedValue = api.getCheckedNodes(state.leafOnly).map((node) => node.getValueByOption());
 };
-export var scrollIntoView = function scrollIntoView(_ref12) {
-  var menus = _ref12.menus;
-  return function () {
-    menus.forEach(function (menu) {
-      var menuElement = menu.$el;
-      if (menuElement) {
-        var container = menuElement.querySelector(CASCADER.ScrollWrap);
-        var activeNode = menuElement.querySelector(CASCADER.CascaderActice) || menuElement.querySelector(CASCADER.ActivePath);
-        scrollIntoView(container, activeNode);
-      }
-    });
-  };
-};
-export var getNodeByValue = function getNodeByValue(state) {
-  return function (val) {
-    return state.store.getNodeByValue(val);
-  };
+const scrollIntoView = ({ menus }) => () => {
+  menus.forEach((menu) => {
+    const menuElement = menu.$el;
+    if (menuElement) {
+      const container = menuElement.querySelector(CASCADER.ScrollWrap);
+      const activeNode = menuElement.querySelector(CASCADER.CascaderActice) || menuElement.querySelector(CASCADER.ActivePath);
+      scrollIntoView(container, activeNode);
+    }
+  });
 };
-export var getFlattedNodes = function getFlattedNodes(state) {
-  return function (leafOnly) {
-    var cached = !state.config.lazy;
-    return state.store.getFlattedNodes(leafOnly, cached);
-  };
+const getNodeByValue = (state) => (val) => state.store.getNodeByValue(val);
+const getFlattedNodes = (state) => (leafOnly) => {
+  const cached = !state.config.lazy;
+  return state.store.getFlattedNodes(leafOnly, cached);
 };
-export var getCheckedNodes = function getCheckedNodes(_ref13) {
-  var api = _ref13.api,
-    state = _ref13.state;
-  return function (leafOnly, cascaderCheckedValue) {
-    var isCascaderChecked = function isCascaderChecked(str, checkedValue) {
-      var flag = true;
-      if (!state.multiple || !checkedValue) {
-        return flag;
-      }
-      flag = false;
-      if (!Array.isArray(checkedValue)) {
-        return flag;
-      }
-      for (var i = 0; i < checkedValue.length; i++) {
-        if (Array.isArray(checkedValue[i]) && checkedValue[i].length) {
-          flag = checkedValue[i][checkedValue[i].length - 1] === str;
-        }
-        if (flag) {
-          break;
-        }
-      }
+const getCheckedNodes = ({ api, state }) => (leafOnly, cascaderCheckedValue) => {
+  const isCascaderChecked = (str, checkedValue) => {
+    let flag = true;
+    if (!state.multiple || !checkedValue) {
       return flag;
-    };
-    if (state.multiple) {
-      var nodes = api.getFlattedNodes(leafOnly);
-      return nodes.filter(function (node) {
-        return node.checked && isCascaderChecked(node.value, cascaderCheckedValue);
-      });
     }
-    return isEmpty(state.checkedValue) ? [] : [api.getNodeByValue(state.checkedValue)];
-  };
-};
-export var clearCheckedNodes = function clearCheckedNodes(_ref14) {
-  var api = _ref14.api,
-    state = _ref14.state;
-  return function () {
-    var _state$config = state.config,
-      multiple = _state$config.multiple,
-      emitPath = _state$config.emitPath;
-    if (multiple) {
-      api.getCheckedNodes(state.leafOnly).filter(function (node) {
-        return !node.isDisabled;
-      }).forEach(function (node) {
-        return node.doCheck(false);
-      });
-      api.calculateMultiCheckedValue();
-    } else {
-      state.checkedValue = emitPath ? [] : null;
+    flag = false;
+    if (!Array.isArray(checkedValue)) {
+      return flag;
     }
+    for (let i = 0; i < checkedValue.length; i++) {
+      if (Array.isArray(checkedValue[i]) && checkedValue[i].length) {
+        flag = checkedValue[i][checkedValue[i].length - 1] === str;
+      }
+      if (flag) {
+        break;
+      }
+    }
+    return flag;
   };
+  if (state.multiple) {
+    const nodes = api.getFlattedNodes(leafOnly);
+    return nodes.filter((node) => node.checked && isCascaderChecked(node.value, cascaderCheckedValue));
+  }
+  return isEmpty(state.checkedValue) ? [] : [api.getNodeByValue(state.checkedValue)];
 };
-export var isLeaf = function isLeaf() {
-  return function (el) {
-    return !el.getAttribute('data-owns');
-  };
+const clearCheckedNodes = ({ api, state }) => () => {
+  const { multiple, emitPath } = state.config;
+  if (multiple) {
+    api.getCheckedNodes(state.leafOnly).filter((node) => !node.isDisabled).forEach((node) => node.doCheck(false));
+    api.calculateMultiCheckedValue();
+  } else {
+    state.checkedValue = emitPath ? [] : null;
+  }
 };
-export var getSibling = function getSibling(el, distance) {
-  var parentNode = el.parentNode;
+const isLeaf = () => (el) => !el.getAttribute("data-owns");
+const getSibling = (el, distance) => {
+  const { parentNode } = el;
   if (parentNode) {
-    var siblings = parentNode.querySelectorAll(CASCADER.CascaderNodeTab);
-    var index = Array.prototype.indexOf.call(siblings, el);
+    const siblings = parentNode.querySelectorAll(CASCADER.CascaderNodeTab);
+    const index = Array.prototype.indexOf.call(siblings, el);
     return siblings[index + distance] || null;
   }
   return null;
 };
-export var valueEquals = function valueEquals(a, b) {
+const valueEquals = (a, b) => {
   if (a === b) {
     return true;
   }
-  if (!(b instanceof Array)) {
+  if (!Array.isArray(b)) {
     return false;
   }
-  if (!(a instanceof Array)) {
+  if (!Array.isArray(a)) {
     return false;
   }
   if (a.length !== b.length) {
     return false;
   }
-  for (var i = 0, len = a.length; i !== len; ++i) {
+  for (let i = 0, len = a.length; i !== len; ++i) {
     if (a[i] !== b[i]) {
       return false;
     }
   }
   return true;
-};
+};
+export {
+  calculateCheckedNodePaths,
+  calculateMultiCheckedValue,
+  checkNode,
+  clearCheckedNodes,
+  coerceTruthyValueToArray,
+  expandNodes,
+  focusNode,
+  getCheckedNodes,
+  getFlattedNodes,
+  getMenuIndex,
+  getNodeByValue,
+  getSibling,
+  handleCheckChange,
+  handleExpand,
+  handleKeyDown,
+  initStore,
+  isLeaf,
+  lazyLoad,
+  scrollIntoView,
+  syncActivePath,
+  syncCheckedValue,
+  syncMenuState,
+  syncMultiCheckState,
+  valueEquals,
+  watchCheckedValue
+};