@opentiny/vue-renderless 3.6.0-alpha.1 → 3.6.1-alpha.0

package/time-panel/index.js

@@ -1,189 +1,126 @@
-import scrollIntoView from '@opentiny/vue-renderless/common/deps/scroll-into-view';
-import { DATEPICKER } from '@opentiny/vue-renderless/common';
-export var parseTime = function parseTime() {
-  return function (time) {
-    var values = (time || '').split(':');
-    if (values.length >= 2) {
-      var hours = parseInt(values[0], 10);
-      var minutes = parseInt(values[1], 10);
-      return {
-        hours: hours,
-        minutes: minutes
-      };
-    }
-    return null;
-  };
-};
-export var compareTime = function compareTime(api) {
-  return function (time1, time2) {
-    var value1 = api.parseTime(time1);
-    var value2 = api.parseTime(time2);
-    var minutes1 = value1.minutes + value1.hours * 60;
-    var minutes2 = value2.minutes + value2.hours * 60;
-    if (minutes1 === minutes2) {
-      return 0;
-    }
-    return minutes1 > minutes2 ? 1 : -1;
-  };
-};
-export var formatTime = function formatTime() {
-  return function (time) {
-    return (time.hours < 10 ? '0' + time.hours : time.hours) + ':' + (time.minutes < 10 ? '0' + time.minutes : time.minutes);
-  };
-};
-export var nextTime = function nextTime(api) {
-  return function (time, step) {
-    var timeValue = api.parseTime(time);
-    var stepValue = api.parseTime(step);
-    var next = {
-      hours: timeValue.hours,
-      minutes: timeValue.minutes
+import "../chunk-PKUHTIDK.js";
+import scrollIntoView from "@opentiny/vue-renderless/common/deps/scroll-into-view";
+import { DATEPICKER } from "@opentiny/vue-renderless/common";
+const parseTime = () => (time) => {
+  const values = (time || "").split(":");
+  if (values.length >= 2) {
+    const hours = parseInt(values[0], 10);
+    const minutes = parseInt(values[1], 10);
+    return {
+      hours,
+      minutes
     };
-    next.minutes += stepValue.minutes;
-    next.hours += stepValue.hours;
-    next.hours += Math.floor(next.minutes / 60);
-    next.minutes = next.minutes % 60;
-    return api.formatTime(next);
-  };
+  }
+  return null;
 };
-export var emitDestroy = function emitDestroy(emit) {
-  return function () {
-    return emit('dodestroy');
-  };
+const compareTime = (api) => (time1, time2) => {
+  const value1 = api.parseTime(time1);
+  const value2 = api.parseTime(time2);
+  const minutes1 = value1.minutes + value1.hours * 60;
+  const minutes2 = value2.minutes + value2.hours * 60;
+  if (minutes1 === minutes2) {
+    return 0;
+  }
+  return minutes1 > minutes2 ? 1 : -1;
 };
-export var emitPick = function emitPick(_ref) {
-  var emit = _ref.emit,
-    state = _ref.state;
-  return function () {
-    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      _ref2$value = _ref2.value,
-      value = _ref2$value === void 0 ? null : _ref2$value,
-      _ref2$visible = _ref2.visible,
-      visible = _ref2$visible === void 0 ? false : _ref2$visible;
-    var lastEmitValue = JSON.stringify({
-      value: value,
-      visible: visible
-    });
-    if (!state.lastEmitValue || state.lastEmitValue !== lastEmitValue) {
-      state.lastEmitValue = lastEmitValue;
-      emit('pick', value, visible);
-    }
+const formatTime = () => (time) => (time.hours < 10 ? "0" + time.hours : time.hours) + ":" + (time.minutes < 10 ? "0" + time.minutes : time.minutes);
+const nextTime = (api) => (time, step) => {
+  const timeValue = api.parseTime(time);
+  const stepValue = api.parseTime(step);
+  const next = {
+    hours: timeValue.hours,
+    minutes: timeValue.minutes
   };
+  next.minutes += stepValue.minutes;
+  next.hours += stepValue.hours;
+  next.hours += Math.floor(next.minutes / 60);
+  next.minutes = next.minutes % 60;
+  return api.formatTime(next);
 };
-export var watchValue = function watchValue(_ref3) {
-  var api = _ref3.api,
-    nextTick = _ref3.nextTick;
-  return function (value) {
-    if (!value) {
-      return;
-    }
-    nextTick(function () {
-      return api.scrollToOption();
-    });
-  };
+const emitDestroy = (emit) => () => emit("dodestroy");
+const emitPick = ({ emit, state }) => ({ value = null, visible = false } = {}) => {
+  const lastEmitValue = JSON.stringify({ value, visible });
+  if (!state.lastEmitValue || state.lastEmitValue !== lastEmitValue) {
+    state.lastEmitValue = lastEmitValue;
+    emit("pick", value, visible);
+  }
 };
-export var computItems = function computItems(_ref4) {
-  var api = _ref4.api,
-    state = _ref4.state;
-  return function () {
-    var start = state.start;
-    var end = state.end;
-    var step = state.step;
-    var result = [];
-    if (start && end && step) {
-      var current = start;
-      while (api.compareTime(current, end) <= 0) {
-        result.push({
-          value: current,
-          disabled: api.compareTime(current, state.minTime || DATEPICKER.CompareOne) <= 0 || api.compareTime(current, state.maxTime || DATEPICKER.CompareHundred) >= 0
-        });
-        current = api.nextTime(current, step);
-      }
+const watchValue = ({ api, nextTick }) => (value) => {
+  if (!value) {
+    return;
+  }
+  nextTick(() => api.scrollToOption());
+};
+const computItems = ({ api, state }) => () => {
+  const start = state.start;
+  const end = state.end;
+  const step = state.step;
+  const result = [];
+  if (start && end && step) {
+    let current = start;
+    while (api.compareTime(current, end) <= 0) {
+      result.push({
+        value: current,
+        disabled: api.compareTime(current, state.minTime || DATEPICKER.CompareOne) <= 0 || api.compareTime(current, state.maxTime || DATEPICKER.CompareHundred) >= 0
+      });
+      current = api.nextTime(current, step);
     }
-    return result;
-  };
+  }
+  return result;
 };
-export var handleClick = function handleClick(api) {
-  return function (item) {
-    return !item.disabled && api.emitPick({
-      value: item.value
-    });
-  };
+const handleClick = (api) => (item) => !item.disabled && api.emitPick({ value: item.value });
+const handleClear = ({ api, state }) => () => {
+  state.defaultValue = "";
+  state.defaultTime = "";
+  api.emitPick();
 };
-export var handleClear = function handleClear(_ref5) {
-  var api = _ref5.api,
-    state = _ref5.state;
-  return function () {
-    state.defaultValue = '';
-    state.defaultTime = '';
-    api.emitPick();
-  };
+const scrollToOption = ({ refs }) => (selector = DATEPICKER.selClass) => {
+  const menu = refs.popper.querySelector(DATEPICKER.queryClass);
+  scrollIntoView(menu, menu.querySelector(selector));
 };
-export var scrollToOption = function scrollToOption(_ref6) {
-  var refs = _ref6.refs;
-  return function () {
-    var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DATEPICKER.selClass;
-    var menu = refs.popper.querySelector(DATEPICKER.queryClass);
-    scrollIntoView(menu, menu.querySelector(selector));
-  };
-};
-export var handleMenuEnter = function handleMenuEnter(_ref7) {
-  var api = _ref7.api,
-    nextTick = _ref7.nextTick,
-    state = _ref7.state;
-  return function () {
-    var selected = state.items.map(function (item) {
-      return item.value;
-    }).indexOf(state.value) !== -1;
-    var hasDefault = state.items.map(function (item) {
-      return item.value;
-    }).indexOf(state["default"]) !== -1;
-    var option = selected && DATEPICKER.selClass || hasDefault && DATEPICKER.defaultClass || DATEPICKER.disableClass;
-    nextTick(function () {
-      return api.scrollToOption(option);
-    });
-  };
+const handleMenuEnter = ({ api, nextTick, state }) => () => {
+  const selected = state.items.map((item) => item.value).includes(state.value);
+  const hasDefault = state.items.map((item) => item.value).includes(state.default);
+  const option = selected && DATEPICKER.selClass || hasDefault && DATEPICKER.defaultClass || DATEPICKER.disableClass;
+  nextTick(() => api.scrollToOption(option));
 };
-export var scrollDown = function scrollDown(_ref8) {
-  var api = _ref8.api,
-    state = _ref8.state;
-  return function (step) {
-    var items = state.items;
-    var length = items.length;
-    var total = items.length;
-    var index = items.map(function (item) {
-      return item.value;
-    }).indexOf(state.value);
-    while (total--) {
-      index = (index + step + length) % length;
-      if (!items[index].disabled) {
-        api.emitPick({
-          value: items[index].value,
-          visible: true
-        });
-        return;
-      }
+const scrollDown = ({ api, state }) => (step) => {
+  const items = state.items;
+  const length = items.length;
+  let total = items.length;
+  let index = items.map((item) => item.value).indexOf(state.value);
+  while (total--) {
+    index = (index + step + length) % length;
+    if (!items[index].disabled) {
+      api.emitPick({ value: items[index].value, visible: true });
+      return;
     }
-  };
+  }
 };
-export var isValidValue = function isValidValue(state) {
-  return function (date) {
-    return state.items.filter(function (item) {
-      return !item.disabled;
-    }).map(function (item) {
-      return item.value;
-    }).indexOf(date) !== -1;
-  };
+const isValidValue = (state) => (date) => state.items.filter((item) => !item.disabled).map((item) => item.value).includes(date);
+const handleKeydown = ({ api }) => (event) => {
+  const keyCode = event.keyCode;
+  if (keyCode === 38 || keyCode === 40) {
+    const mapping = DATEPICKER.MappingKeyCode;
+    const offset = mapping[keyCode.toString()];
+    api.scrollDown(offset);
+    event.stopPropagation();
+  }
+};
+export {
+  compareTime,
+  computItems,
+  emitDestroy,
+  emitPick,
+  formatTime,
+  handleClear,
+  handleClick,
+  handleKeydown,
+  handleMenuEnter,
+  isValidValue,
+  nextTime,
+  parseTime,
+  scrollDown,
+  scrollToOption,
+  watchValue
 };
-export var handleKeydown = function handleKeydown(_ref9) {
-  var api = _ref9.api;
-  return function (event) {
-    var keyCode = event.keyCode;
-    if (keyCode === 38 || keyCode === 40) {
-      var mapping = DATEPICKER.MappingKeyCode;
-      var offset = mapping[keyCode.toString()];
-      api.scrollDown(offset);
-      event.stopPropagation();
-    }
-  };
-};

package/time-panel/scrollIntoView.js

@@ -1,23 +1,25 @@
-export default (function (container, selected) {
+import "../chunk-PKUHTIDK.js";
+var scrollIntoView_default = (container, selected) => {
   if (!selected) {
     container.scrollTop = 0;
     return;
   }
-  var offsetParents = [];
-  var pointer = selected.offsetParent;
+  const offsetParents = [];
+  let pointer = selected.offsetParent;
   while (pointer && container !== pointer && container.contains(pointer)) {
     offsetParents.push(pointer);
     pointer = pointer.offsetParent;
   }
-  var top = selected.offsetTop + offsetParents.reduce(function (prev, curr) {
-    return prev + curr.offsetTop;
-  }, 0);
-  var bottom = top + selected.offsetHeight;
-  var viewRectTop = container.scrollTop;
-  var viewRectBottom = viewRectTop + container.clientHeight;
+  const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
+  const bottom = top + selected.offsetHeight;
+  const viewRectTop = container.scrollTop;
+  const viewRectBottom = viewRectTop + container.clientHeight;
   if (top < viewRectTop) {
     container.scrollTop = top;
   } else if (bottom > viewRectBottom) {
     container.scrollTop = bottom - container.clientHeight;
   }
-});
+};
+export {
+  scrollIntoView_default as default
+};

package/time-panel/vue.js

@@ -1,110 +1,80 @@
-import { handleKeydown, isValidValue, scrollDown, handleMenuEnter, scrollToOption, handleClear, handleClick, parseTime, formatTime, nextTime, compareTime, watchValue, computItems, emitPick, emitDestroy } from './index';
-import { DATEPICKER } from '@opentiny/vue-renderless/common';
-export var api = ['state', 'handleMenuEnter', 'handleClick', 'handleClear', 'emitDestroy'];
-var initState = function initState(_ref) {
-  var reactive = _ref.reactive,
-    computed = _ref.computed,
-    api = _ref.api;
-  var Start = DATEPICKER.Start,
-    End = DATEPICKER.End,
-    Step = DATEPICKER.Step;
-  var state = reactive({
-    popperClass: '',
+import "../chunk-PKUHTIDK.js";
+import {
+  handleKeydown,
+  isValidValue,
+  scrollDown,
+  handleMenuEnter,
+  scrollToOption,
+  handleClear,
+  handleClick,
+  parseTime,
+  formatTime,
+  nextTime,
+  compareTime,
+  watchValue,
+  computItems,
+  emitPick,
+  emitDestroy
+} from "./index";
+import { DATEPICKER } from "@opentiny/vue-renderless/common";
+const api = ["state", "handleMenuEnter", "handleClick", "handleClear", "emitDestroy"];
+const initState = ({ reactive, computed, api: api2 }) => {
+  const { Start, End, Step } = DATEPICKER;
+  const state = reactive({
+    popperClass: "",
     start: Start,
     end: End,
     step: Step,
-    realValue: '',
-    defaultValue: '',
-    defaultTime: '',
+    realValue: "",
+    defaultValue: "",
+    defaultTime: "",
     visible: false,
-    minTime: '',
-    maxTime: '',
+    minTime: "",
+    maxTime: "",
     width: 0,
-    lastEmitValue: '',
-    items: computed(function () {
-      return api.computItems();
-    }),
-    "default": computed(function () {
-      return state.defaultValue || state.defaultTime || '';
-    }),
+    lastEmitValue: "",
+    items: computed(() => api2.computItems()),
+    default: computed(() => state.defaultValue || state.defaultTime || ""),
     value: computed({
-      get: function get() {
-        return state.realValue || state["default"];
-      },
-      set: function set(value) {
-        var valid = state.items.some(function (item) {
-          return item.value === value;
-        });
-        state.realValue = valid ? value : '';
+      get: () => state.realValue || state.default,
+      set: (value) => {
+        const valid = state.items.some((item) => item.value === value);
+        state.realValue = valid ? value : "";
       }
     })
   });
   return state;
 };
-export var renderless = function renderless(props, _ref2, _ref3) {
-  var computed = _ref2.computed,
-    reactive = _ref2.reactive,
-    watch = _ref2.watch,
-    nextTick = _ref2.nextTick;
-  var refs = _ref3.refs,
-    $emit = _ref3.emit;
-  var api = {};
-  var emit = props.emitter ? props.emitter.emit : $emit;
-  var state = initState({
-    reactive: reactive,
-    computed: computed,
-    api: api
-  });
-  Object.assign(api, {
-    state: state,
+const renderless = (props, { computed, reactive, watch, nextTick }, { refs, emit: $emit }) => {
+  const api2 = {};
+  const emit = props.emitter ? props.emitter.emit : $emit;
+  const state = initState({ reactive, computed, api: api2 });
+  Object.assign(api2, {
+    state,
     parseTime: parseTime(),
     formatTime: formatTime(),
     isValidValue: isValidValue(state),
-    scrollToOption: scrollToOption({
-      refs: refs
-    }),
-    emitPick: emitPick({
-      emit: emit,
-      state: state
-    }),
+    scrollToOption: scrollToOption({ refs }),
+    emitPick: emitPick({ emit, state }),
     emitDestroy: emitDestroy(emit),
-    nextTime: nextTime(api),
-    compareTime: compareTime(api),
-    handleClick: handleClick(api),
-    scrollDown: scrollDown({
-      api: api,
-      state: state
-    }),
-    handleClear: handleClear({
-      api: api,
-      state: state
-    }),
-    watchValue: watchValue({
-      api: api,
-      nextTick: nextTick
-    }),
-    handleKeydown: handleKeydown({
-      api: api
-    }),
-    computItems: computItems({
-      api: api,
-      state: state
-    }),
-    handleMenuEnter: handleMenuEnter({
-      api: api,
-      nextTick: nextTick,
-      state: state
-    })
-  });
-  watch(function () {
-    return state.value;
-  }, api.watchValue);
-  watch(function () {
-    return state.visible;
-  }, function () {
-    return setTimeout(function () {
-      return state.fnUpdatePopper && state.fnUpdatePopper();
-    });
+    nextTime: nextTime(api2),
+    compareTime: compareTime(api2),
+    handleClick: handleClick(api2),
+    scrollDown: scrollDown({ api: api2, state }),
+    handleClear: handleClear({ api: api2, state }),
+    watchValue: watchValue({ api: api2, nextTick }),
+    handleKeydown: handleKeydown({ api: api2 }),
+    computItems: computItems({ api: api2, state }),
+    handleMenuEnter: handleMenuEnter({ api: api2, nextTick, state })
   });
-  return api;
-};
+  watch(() => state.value, api2.watchValue);
+  watch(
+    () => state.visible,
+    () => setTimeout(() => state.fnUpdatePopper && state.fnUpdatePopper())
+  );
+  return api2;
+};
+export {
+  api,
+  renderless
+};