@opentiny/vue-renderless 3.5.0 → 3.6.0

package/wheel/index.js

@@ -0,0 +1,187 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { cloneDeep } from '@opentiny/vue-renderless/chart-core/deps/utils';
+export var created = function created(api) {
+  return function () {
+    api.loadPickerData();
+    api.loadWheels();
+  };
+};
+export var loadPickerData = function loadPickerData(_ref) {
+  var props = _ref.props,
+    state = _ref.state;
+  return function () {
+    state.dataSource = cloneDeep(props.dataSource);
+    state.defaultSelectedIndexs = cloneDeep(props.defaultSelectedIndexs);
+    var level_1 = state.dataSource;
+    var level_n = getNextLevel([], state.dataSource, state.defaultSelectedIndexs, 0);
+    if (level_n.length === 0) {
+      state.pickerData = [level_1];
+    } else {
+      state.pickerData = [level_1].concat(_toConsumableArray(level_n));
+    }
+  };
+};
+export var getNextLevel = function getNextLevel(levelItems, children, nextIndexs, start) {
+  var _children$nextIndexs$, _children$nextIndexs$2;
+  var levelItem = (_children$nextIndexs$ = (_children$nextIndexs$2 = children[nextIndexs[start]]) === null || _children$nextIndexs$2 === void 0 ? void 0 : _children$nextIndexs$2.children) !== null && _children$nextIndexs$ !== void 0 ? _children$nextIndexs$ : [];
+  if (start !== nextIndexs.length - 1) {
+    levelItems.push(levelItem);
+    return getNextLevel(levelItems, levelItem, nextIndexs, ++start);
+  } else {
+    return levelItems;
+  }
+};
+export var wheelChanged = function wheelChanged(_ref2) {
+  var api = _ref2.api,
+    state = _ref2.state;
+  return function (newIndexs, oldIndexs) {
+    if (newIndexs.length > 1) {
+      newIndexs.forEach(function (ii, ri) {
+        if (newIndexs[ri] !== oldIndexs[ri] && ri !== newIndexs.length - 1) {
+          var children = getChildren(state.dataSource, newIndexs, 0, ri);
+          state.pickerData.splice(ri + 1, 1, children);
+        }
+      });
+    }
+    api.wheelsTo(newIndexs);
+    api.changeWheelItemStyle(state.pickerData, newIndexs);
+  };
+};
+export var getChildren = function getChildren(levelItems, newIndexs, start, maxLoop) {
+  var _levelItems$newIndexs, _levelItems$newIndexs2;
+  var levelItem = (_levelItems$newIndexs = (_levelItems$newIndexs2 = levelItems[newIndexs[start]]) === null || _levelItems$newIndexs2 === void 0 ? void 0 : _levelItems$newIndexs2.children) !== null && _levelItems$newIndexs !== void 0 ? _levelItems$newIndexs : [];
+  if (start !== maxLoop) {
+    return getChildren(levelItem, newIndexs, ++start, maxLoop);
+  } else {
+    return levelItem;
+  }
+};
+export var wheelsTo = function wheelsTo(_ref3) {
+  var api = _ref3.api,
+    state = _ref3.state,
+    nextTick = _ref3.nextTick;
+  return function (indexs) {
+    nextTick(function () {
+      state.wheels.forEach(function (wheel, i) {
+        wheel.wheelTo(indexs[i], 0);
+        api.refreshWheel(wheel);
+      });
+    });
+  };
+};
+export var refreshWheel = function refreshWheel(nextTick) {
+  return function (wheel) {
+    nextTick(function () {
+      wheel.refresh();
+    });
+  };
+};
+export var loadWheels = function loadWheels(_ref4) {
+  var api = _ref4.api,
+    props = _ref4.props,
+    state = _ref4.state,
+    nextTick = _ref4.nextTick,
+    refs = _ref4.refs;
+  return function () {
+    if (state.wheels.length === 0) {
+      nextTick(function () {
+        state.wheels = [];
+        var wheelWrapper = refs.wheelWrapper;
+        if (props.hasFooter) {
+          for (var i = 0; i < state.pickerData.length; i++) {
+            api.createWheelHasFooter(wheelWrapper, i);
+          }
+        } else {
+          api.createWheelNoFooter(wheelWrapper);
+        }
+      });
+    }
+  };
+};
+export var createWheelHasFooter = function createWheelHasFooter(_ref5) {
+  var api = _ref5.api,
+    state = _ref5.state,
+    emit = _ref5.emit,
+    BScroll = _ref5.BScroll;
+  return function (wheelWrapper, i) {
+    var wheels = state.wheels;
+    if (!wheels[i]) {
+      wheels[i] = state.wheels[i] = new BScroll(wheelWrapper.children[i], {
+        wheel: {
+          selectedIndex: state.defaultSelectedIndexs[i],
+          wheelWrapperClass: 'wheel-scroll',
+          wheelItemClass: 'wheel-item'
+        },
+        probeType: 3
+      });
+      state.prevSelectedIndexs = state.defaultSelectedIndexs;
+      wheels[i].on('wheelIndexChanged', function () {
+        var currentSelectedIndex = wheels[i].getSelectedIndex();
+        var currentSelectedIndexs = [].concat(_toConsumableArray(state.prevSelectedIndexs.slice(0, i)), [currentSelectedIndex], _toConsumableArray(new Array(state.defaultSelectedIndexs.length - i - 1).fill(0)));
+        api.wheelChanged(currentSelectedIndexs, state.prevSelectedIndexs);
+        state.prevSelectedIndexs = currentSelectedIndexs;
+        emit('change', currentSelectedIndexs);
+      });
+      api.wheelsTo(state.defaultSelectedIndexs);
+      api.changeWheelItemStyle(state.pickerData, state.defaultSelectedIndexs);
+    } else {
+      wheels[i].refresh();
+    }
+    return wheels[i];
+  };
+};
+export var createWheelNoFooter = function createWheelNoFooter(_ref6) {
+  var api = _ref6.api,
+    state = _ref6.state,
+    BScroll = _ref6.BScroll;
+  return function (wheelWrapper) {
+    var wheels = state.wheels;
+    if (!wheels[0]) {
+      wheels[0] = state.wheels[0] = new BScroll(wheelWrapper.children[0], {
+        probeType: 3,
+        click: true
+      });
+      api.changeWheelItemStyle(state.pickerData, state.defaultSelectedIndexs);
+      api.refreshWheel(wheels[0]);
+    } else {
+      wheels[0].refresh();
+    }
+    return wheels[0];
+  };
+};
+export var changeWheelItemStyle = function changeWheelItemStyle(state) {
+  return function (pickerData, currentSelectedIndexs) {
+    pickerData.forEach(function (item, index) {
+      state.pickerData[index] = item.map(function (rItem, i) {
+        rItem.selected = i === currentSelectedIndexs[index];
+        return rItem;
+      });
+    });
+  };
+};
+export var dealWheels = function dealWheels(state) {
+  return function () {
+    state.wheels.forEach(function (wheel) {
+      wheel.destroy();
+    });
+    state.wheels = [];
+    state.pickerData = [];
+    state.prevSelectedIndexs = [];
+    state.defaultSelectedIndexs = [];
+  };
+};
+export var clickWheelItem = function clickWheelItem(_ref7) {
+  var api = _ref7.api,
+    state = _ref7.state,
+    emit = _ref7.emit;
+  return function (index) {
+    api.changeWheelItemStyle(state.pickerData, [index]);
+    var rItem = state.pickerData[0][index];
+    if (state.defaultSelectedIndexs[0] !== index) {
+      var selectedLabel = rItem === null || rItem === void 0 ? void 0 : rItem.label;
+      emit('clickWheelItem', [index], selectedLabel, rItem);
+    } else {
+      emit('clickWheelItem', [], '', []);
+    }
+  };
+};

package/wheel/vue.js

@@ -0,0 +1,110 @@
+import { created, loadPickerData, wheelChanged, changeWheelItemStyle, loadWheels, createWheelHasFooter, createWheelNoFooter, wheelsTo, refreshWheel, dealWheels, clickWheelItem } from './index';
+export var api = ['state', 'created', 'loadPickerData', 'wheelChanged', 'changeWheelItemStyle', 'loadWheels', 'createWheelHasFooter', 'createWheelNoFooter', 'wheelsTo', 'refreshWheel', 'dealWheels', 'clickWheelItem'];
+var initState = function initState(reactive) {
+  var state = reactive({
+    dataSource: [],
+    defaultSelectedIndexs: [],
+    pickerData: [],
+    wheels: [],
+    prevSelectedIndexs: []
+  });
+  return state;
+};
+var initApi = function initApi(_ref) {
+  var api = _ref.api,
+    props = _ref.props,
+    state = _ref.state,
+    emit = _ref.emit,
+    nextTick = _ref.nextTick,
+    refs = _ref.refs,
+    BScroll = _ref.BScroll;
+  Object.assign(api, {
+    state: state,
+    created: created(api),
+    loadPickerData: loadPickerData({
+      props: props,
+      state: state
+    }),
+    wheelChanged: wheelChanged({
+      api: api,
+      state: state
+    }),
+    changeWheelItemStyle: changeWheelItemStyle(state),
+    loadWheels: loadWheels({
+      api: api,
+      props: props,
+      state: state,
+      nextTick: nextTick,
+      refs: refs
+    }),
+    createWheelHasFooter: createWheelHasFooter({
+      api: api,
+      state: state,
+      emit: emit,
+      BScroll: BScroll
+    }),
+    createWheelNoFooter: createWheelNoFooter({
+      api: api,
+      state: state,
+      BScroll: BScroll
+    }),
+    wheelsTo: wheelsTo({
+      api: api,
+      state: state,
+      nextTick: nextTick
+    }),
+    refreshWheel: refreshWheel(nextTick),
+    dealWheels: dealWheels(state),
+    clickWheelItem: clickWheelItem({
+      api: api,
+      state: state,
+      emit: emit
+    })
+  });
+};
+var initWatch = function initWatch(_ref2) {
+  var watch = _ref2.watch,
+    api = _ref2.api,
+    props = _ref2.props,
+    state = _ref2.state,
+    nextTick = _ref2.nextTick;
+  watch(function () {
+    return props.defaultSelectedIndexs;
+  }, function () {
+    api.dealWheels(state);
+    nextTick(function () {
+      api.created(api);
+    });
+  });
+};
+export var renderless = function renderless(props, _ref3, _ref4, _ref5) {
+  var onMounted = _ref3.onMounted,
+    reactive = _ref3.reactive,
+    watch = _ref3.watch;
+  var emit = _ref4.emit,
+    nextTick = _ref4.nextTick,
+    refs = _ref4.refs;
+  var BScroll = _ref5.BScroll;
+  var api = {};
+  var state = initState(reactive);
+  initApi({
+    api: api,
+    props: props,
+    state: state,
+    emit: emit,
+    nextTick: nextTick,
+    refs: refs,
+    BScroll: BScroll
+  });
+  initWatch({
+    watch: watch,
+    api: api,
+    props: props,
+    state: state,
+    nextTick: nextTick
+  });
+  onMounted(function () {
+    api.created(api);
+  });
+  return api;
+};