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

package/time-range/index.js

@@ -1,203 +1,142 @@
-import { clearMilliseconds, timeWithinRange, limitTimeRange, modifyDate } from '@opentiny/vue-renderless/common/deps/date-util';
-export var minTimeOfDay = function minTimeOfDay(_ref) {
-  var MIN_TIME = _ref.MIN_TIME;
-  return function (date) {
-    return modifyDate(MIN_TIME, date.getFullYear(), date.getMonth(), date.getDate());
-  };
-};
-export var maxTimeOfDay = function maxTimeOfDay(_ref2) {
-  var MAX_TIME = _ref2.MAX_TIME;
-  return function (date) {
-    return modifyDate(MAX_TIME, date.getFullYear(), date.getMonth(), date.getDate());
-  };
-};
-export var advanceTime = function advanceTime(api) {
-  return function (date, amount) {
-    return new Date(Math.min(date.getTime() + amount, api.maxTimeOfDay(date).getTime()));
-  };
+import "../chunk-PKUHTIDK.js";
+import { clearMilliseconds, timeWithinRange, limitTimeRange, modifyDate } from "@opentiny/vue-renderless/common/deps/date-util";
+const minTimeOfDay = ({ MIN_TIME }) => (date) => modifyDate(MIN_TIME, date.getFullYear(), date.getMonth(), date.getDate());
+const maxTimeOfDay = ({ MAX_TIME }) => (date) => modifyDate(MAX_TIME, date.getFullYear(), date.getMonth(), date.getDate());
+const advanceTime = (api) => (date, amount) => new Date(Math.min(date.getTime() + amount, api.maxTimeOfDay(date).getTime()));
+const compuAmPmMode = (state) => () => {
+  if ((state.format || "").includes("A")) {
+    return "A";
+  }
+  if ((state.format || "").includes("a")) {
+    return "a";
+  }
+  return "";
 };
-export var compuAmPmMode = function compuAmPmMode(state) {
-  return function () {
-    if ((state.format || '').indexOf('A') !== -1) {
-      return 'A';
+const watchValue = ({ api, state }) => (value) => {
+  if (Array.isArray(value)) {
+    if (value[0]) {
+      state.minDate = new Date(value[0]);
+    } else {
+      state.minDate = value[1] ? new Date(api.minTimeOfDay(new Date(value[1])).getTime()) : new Date();
     }
-    if ((state.format || '').indexOf('a') !== -1) {
-      return 'a';
+    if (value[1]) {
+      state.maxDate = new Date(value[1]);
+    } else {
+      state.maxDate = value[0] ? api.advanceTime(new Date(value[0]), 60 * 60 * 1e3) : api.advanceTime(new Date(), 60 * 60 * 1e3);
     }
-    return '';
-  };
-};
-export var watchValue = function watchValue(_ref3) {
-  var api = _ref3.api,
-    state = _ref3.state;
-  return function (value) {
-    if (Array.isArray(value)) {
-      if (value[0]) {
-        state.minDate = new Date(value[0]);
-      } else {
-        state.minDate = value[1] ? new Date(api.minTimeOfDay(new Date(value[1])).getTime()) : new Date();
-      }
-      if (value[1]) {
-        state.maxDate = new Date(value[1]);
-      } else {
-        state.maxDate = value[0] ? api.advanceTime(new Date(value[0]), 60 * 60 * 1000) : api.advanceTime(new Date(), 60 * 60 * 1000);
-      }
+  } else {
+    if (Array.isArray(state.defaultValue)) {
+      state.minDate = new Date(state.defaultValue[0]);
+      state.maxDate = new Date(state.defaultValue[1]);
+    } else if (state.defaultValue) {
+      state.minDate = new Date(state.defaultValue);
+      state.maxDate = api.advanceTime(new Date(state.defaultValue), 60 * 60 * 1e3);
     } else {
-      if (Array.isArray(state.defaultValue)) {
-        state.minDate = new Date(state.defaultValue[0]);
-        state.maxDate = new Date(state.defaultValue[1]);
-      } else if (state.defaultValue) {
-        state.minDate = new Date(state.defaultValue);
-        state.maxDate = api.advanceTime(new Date(state.defaultValue), 60 * 60 * 1000);
-      } else {
-        state.minDate = new Date();
-        state.maxDate = api.advanceTime(new Date(), 60 * 60 * 1000);
-      }
+      state.minDate = new Date();
+      state.maxDate = api.advanceTime(new Date(), 60 * 60 * 1e3);
     }
-  };
+  }
 };
-var adjustSpinners = function adjustSpinners(refs) {
+const adjustSpinners = (refs) => {
   refs.minSpinner.adjustSpinners();
   refs.maxSpinner.adjustSpinners();
 };
-var setMaxMinData = function setMaxMinData(state) {
+const setMaxMinData = (state) => {
   if (Array.isArray(state.oldValue)) {
     state.oldValue[0] && (state.minDate = clearMilliseconds(state.oldValue[0]));
     state.oldValue[1] && (state.maxDate = clearMilliseconds(state.oldValue[1]));
   }
 };
-export var watchVisible = function watchVisible(_ref4) {
-  var nextTick = _ref4.nextTick,
-    refs = _ref4.refs,
-    state = _ref4.state;
-  return function (value) {
-    if (value) {
-      state.oldValue = state.value;
-      nextTick(function () {
-        setMaxMinData(state);
-        adjustSpinners(refs);
-      });
-    }
-  };
-};
-export var handleClear = function handleClear(emit) {
-  return function () {
-    return emit('pick', null);
-  };
-};
-export var handleCancel = function handleCancel(_ref5) {
-  var emit = _ref5.emit,
-    refs = _ref5.refs,
-    state = _ref5.state;
-  return function () {
-    state.visible = false;
-    emit('pick', state.oldValue);
-    setMaxMinData(state);
-    adjustSpinners(refs);
-  };
-};
-export var handleMinChange = function handleMinChange(_ref6) {
-  var api = _ref6.api,
-    state = _ref6.state;
-  return function (date) {
-    state.minDate = clearMilliseconds(date);
-    api.handleChange();
-  };
-};
-export var handleMaxChange = function handleMaxChange(_ref7) {
-  var api = _ref7.api,
-    state = _ref7.state;
-  return function (date) {
-    state.maxDate = clearMilliseconds(date);
-    api.handleChange();
-  };
-};
-export var handleChange = function handleChange(_ref8) {
-  var api = _ref8.api,
-    emit = _ref8.emit,
-    refs = _ref8.refs,
-    state = _ref8.state;
-  return function () {
-    if (api.isValidValue([state.minDate, state.maxDate])) {
-      refs.minSpinner.state.selectableRange = [[api.minTimeOfDay(state.minDate), state.maxDate]];
-      refs.maxSpinner.state.selectableRange = [[state.minDate, api.maxTimeOfDay(state.maxDate)]];
-      emit('pick', [state.minDate, state.maxDate], state.visible);
-    }
-  };
-};
-export var setMinSelectionRange = function setMinSelectionRange(_ref9) {
-  var emit = _ref9.emit,
-    state = _ref9.state;
-  return function (start, end) {
-    emit('select-range', start, end, 'min');
-    state.selectionRange = [start, end];
-  };
+const watchVisible = ({ nextTick, refs, state }) => (value) => {
+  if (value) {
+    state.oldValue = state.value;
+    nextTick(() => {
+      setMaxMinData(state);
+      adjustSpinners(refs);
+    });
+  }
 };
-export var setMaxSelectionRange = function setMaxSelectionRange(_ref10) {
-  var emit = _ref10.emit,
-    state = _ref10.state;
-  return function (start, end) {
-    emit('select-range', start, end, 'max');
-    state.selectionRange = [start + state.offset, end + state.offset];
-  };
+const handleClear = (emit) => () => emit("pick", null);
+const handleCancel = ({ emit, refs, state }) => () => {
+  state.visible = false;
+  emit("pick", state.oldValue);
+  setMaxMinData(state);
+  adjustSpinners(refs);
+};
+const handleMinChange = ({ api, state }) => (date) => {
+  state.minDate = clearMilliseconds(date);
+  api.handleChange();
+};
+const handleMaxChange = ({ api, state }) => (date) => {
+  state.maxDate = clearMilliseconds(date);
+  api.handleChange();
+};
+const handleChange = ({ api, emit, refs, state }) => () => {
+  if (api.isValidValue([state.minDate, state.maxDate])) {
+    refs.minSpinner.state.selectableRange = [[api.minTimeOfDay(state.minDate), state.maxDate]];
+    refs.maxSpinner.state.selectableRange = [[state.minDate, api.maxTimeOfDay(state.maxDate)]];
+    emit("pick", [state.minDate, state.maxDate], state.visible);
+  }
 };
-export var handleConfirm = function handleConfirm(_ref11) {
-  var emit = _ref11.emit,
-    refs = _ref11.refs,
-    state = _ref11.state;
-  return function () {
-    var visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var minSelectableRange = refs.minSpinner.state.selectableRange;
-    var maxSelectableRange = refs.maxSpinner.state.selectableRange;
-    state.minDate = limitTimeRange(state.minDate, minSelectableRange, state.format);
-    state.maxDate = limitTimeRange(state.maxDate, maxSelectableRange, state.format);
-    emit('pick', [state.minDate, state.maxDate], visible);
-  };
+const setMinSelectionRange = ({ emit, state }) => (start, end) => {
+  emit("select-range", start, end, "min");
+  state.selectionRange = [start, end];
+};
+const setMaxSelectionRange = ({ emit, state }) => (start, end) => {
+  emit("select-range", start, end, "max");
+  state.selectionRange = [start + state.offset, end + state.offset];
+};
+const handleConfirm = ({ emit, refs, state }) => (visible = false) => {
+  const minSelectableRange = refs.minSpinner.state.selectableRange;
+  const maxSelectableRange = refs.maxSpinner.state.selectableRange;
+  state.minDate = limitTimeRange(state.minDate, minSelectableRange, state.format);
+  state.maxDate = limitTimeRange(state.maxDate, maxSelectableRange, state.format);
+  emit("pick", [state.minDate, state.maxDate], visible);
+};
+const changeSelectionRange = ({ refs, state }) => (step) => {
+  const list = state.showSeconds ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
+  const mapping = ["hours", "minutes"].concat(state.showSeconds ? ["seconds"] : []);
+  const index = list.indexOf(state.selectionRange[0]);
+  const next = (index + step + list.length) % list.length;
+  const half = list.length / 2;
+  if (next < half) {
+    refs.minSpinner.emitSelectRange(mapping[next]);
+  } else {
+    refs.maxSpinner.emitSelectRange(mapping[next - half]);
+  }
 };
-export var changeSelectionRange = function changeSelectionRange(_ref12) {
-  var refs = _ref12.refs,
-    state = _ref12.state;
-  return function (step) {
-    var list = state.showSeconds ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
-    var mapping = ['hours', 'minutes'].concat(state.showSeconds ? ['seconds'] : []);
-    var index = list.indexOf(state.selectionRange[0]);
-    var next = (index + step + list.length) % list.length;
-    var half = list.length / 2;
-    if (next < half) {
-      refs.minSpinner.emitSelectRange(mapping[next]);
-    } else {
-      refs.maxSpinner.emitSelectRange(mapping[next - half]);
-    }
-  };
+const isValidValue = ({ refs, state }) => (date) => Array.isArray(date) && timeWithinRange(state.minDate, refs.minSpinner.state.selectableRange) && timeWithinRange(state.maxDate, refs.maxSpinner.state.selectableRange);
+const handleKeydown = ({ api, state }) => (event) => {
+  const keyCode = event.keyCode;
+  const mapping = { 38: -1, 40: 1, 37: -1, 39: 1 };
+  if (keyCode === 37 || keyCode === 39) {
+    const step = mapping[keyCode];
+    api.changeSelectionRange(step);
+    event.preventDefault();
+    return;
+  }
+  if (keyCode === 38 || keyCode === 40) {
+    const step = mapping[keyCode];
+    state.spinner.scrollDown(step);
+    event.preventDefault();
+  }
 };
-export var isValidValue = function isValidValue(_ref13) {
-  var refs = _ref13.refs,
-    state = _ref13.state;
-  return function (date) {
-    return Array.isArray(date) && timeWithinRange(state.minDate, refs.minSpinner.state.selectableRange) && timeWithinRange(state.maxDate, refs.maxSpinner.state.selectableRange);
-  };
+export {
+  advanceTime,
+  changeSelectionRange,
+  compuAmPmMode,
+  handleCancel,
+  handleChange,
+  handleClear,
+  handleConfirm,
+  handleKeydown,
+  handleMaxChange,
+  handleMinChange,
+  isValidValue,
+  maxTimeOfDay,
+  minTimeOfDay,
+  setMaxSelectionRange,
+  setMinSelectionRange,
+  watchValue,
+  watchVisible
 };
-export var handleKeydown = function handleKeydown(_ref14) {
-  var api = _ref14.api,
-    state = _ref14.state;
-  return function (event) {
-    var keyCode = event.keyCode;
-    var mapping = {
-      38: -1,
-      40: 1,
-      37: -1,
-      39: 1
-    };
-    if (keyCode === 37 || keyCode === 39) {
-      var step = mapping[keyCode];
-      api.changeSelectionRange(step);
-      event.preventDefault();
-      return;
-    }
-    if (keyCode === 38 || keyCode === 40) {
-      var _step = mapping[keyCode];
-      state.spinner.scrollDown(_step);
-      event.preventDefault();
-    }
-  };
-};

package/time-range/vue.js

@@ -1,15 +1,30 @@
-import { handleKeydown, isValidValue, changeSelectionRange, handleConfirm, setMaxSelectionRange, setMinSelectionRange, handleChange, handleMaxChange, handleMinChange, handleCancel, handleClear, watchVisible, watchValue, minTimeOfDay, maxTimeOfDay, advanceTime, compuAmPmMode } from './index';
-import { parseDate } from '@opentiny/vue-renderless/common/deps/date-util';
-export var api = ['state', 'handleMinChange', 'handleConfirm', 'setMinSelectionRange', 'handleCancel', 'setMaxSelectionRange', 'handleMaxChange'];
-var initState = function initState(_ref) {
-  var reactive = _ref.reactive,
-    computed = _ref.computed,
-    refs = _ref.refs,
-    api = _ref.api;
-  var state = reactive({
-    popperClass: '',
+import "../chunk-PKUHTIDK.js";
+import {
+  handleKeydown,
+  isValidValue,
+  changeSelectionRange,
+  handleConfirm,
+  setMaxSelectionRange,
+  setMinSelectionRange,
+  handleChange,
+  handleMaxChange,
+  handleMinChange,
+  handleCancel,
+  handleClear,
+  watchVisible,
+  watchValue,
+  minTimeOfDay,
+  maxTimeOfDay,
+  advanceTime,
+  compuAmPmMode
+} from "./index";
+import { parseDate } from "@opentiny/vue-renderless/common/deps/date-util";
+const api = ["state", "handleMinChange", "handleConfirm", "setMinSelectionRange", "handleCancel", "setMaxSelectionRange", "handleMaxChange"];
+const initState = ({ reactive, computed, refs, api: api2 }) => {
+  const state = reactive({
+    popperClass: "",
     defaultValue: null,
-    format: 'HH:mm:ss',
+    format: "HH:mm:ss",
     visible: false,
     value: [],
     oldValue: [new Date(), new Date()],
@@ -17,113 +32,46 @@ var initState = function initState(_ref) {
     arrowControl: false,
     maxDate: new Date(),
     minDate: new Date(),
-    showSeconds: computed(function () {
-      return (state.format || '').indexOf('ss') !== -1;
-    }),
-    offset: computed(function () {
-      return state.showSeconds ? 11 : 8;
-    }),
-    spinner: computed(function () {
-      return state.selectionRange[0] < state.offset ? refs.minSpinner : refs.maxSpinner;
-    }),
-    btnDisabled: computed(function () {
-      return state.minDate.getTime() > state.maxDate.getTime();
-    }),
-    amPmMode: computed(function () {
-      return api.compuAmPmMode();
-    })
+    showSeconds: computed(() => (state.format || "").includes("ss")),
+    offset: computed(() => state.showSeconds ? 11 : 8),
+    spinner: computed(() => state.selectionRange[0] < state.offset ? refs.minSpinner : refs.maxSpinner),
+    btnDisabled: computed(() => state.minDate.getTime() > state.maxDate.getTime()),
+    amPmMode: computed(() => api2.compuAmPmMode())
   });
   return state;
 };
-export var renderless = function renderless(props, _ref2, _ref3) {
-  var computed = _ref2.computed,
-    reactive = _ref2.reactive,
-    watch = _ref2.watch,
-    nextTick = _ref2.nextTick;
-  var t = _ref3.t,
-    refs = _ref3.refs,
-    $emit = _ref3.emit;
-  var api = {};
-  var emit = props.emitter ? props.emitter.emit : $emit;
-  var MIN_TIME = parseDate('00:00:00', 'HH:mm:ss', t);
-  var MAX_TIME = parseDate('23:59:59', 'HH:mm:ss', t);
-  var state = initState({
-    reactive: reactive,
-    computed: computed,
-    refs: refs,
-    api: api
-  });
-  Object.assign(api, {
-    t: t,
-    state: state,
+const renderless = (props, { computed, reactive, watch, nextTick }, { t, refs, emit: $emit }) => {
+  const api2 = {};
+  const emit = props.emitter ? props.emitter.emit : $emit;
+  const MIN_TIME = parseDate("00:00:00", "HH:mm:ss", t);
+  const MAX_TIME = parseDate("23:59:59", "HH:mm:ss", t);
+  const state = initState({ reactive, computed, refs, api: api2 });
+  Object.assign(api2, {
+    t,
+    state,
     handleClear: handleClear(emit),
     compuAmPmMode: compuAmPmMode(state),
-    maxTimeOfDay: maxTimeOfDay({
-      MAX_TIME: MAX_TIME
-    }),
-    minTimeOfDay: minTimeOfDay({
-      MIN_TIME: MIN_TIME
-    }),
-    changeSelectionRange: changeSelectionRange({
-      refs: refs,
-      state: state
-    }),
-    setMaxSelectionRange: setMaxSelectionRange({
-      emit: emit,
-      state: state
-    }),
-    setMinSelectionRange: setMinSelectionRange({
-      emit: emit,
-      state: state
-    }),
-    isValidValue: isValidValue({
-      refs: refs,
-      state: state
-    }),
-    handleConfirm: handleConfirm({
-      emit: emit,
-      refs: refs,
-      state: state
-    }),
-    handleCancel: handleCancel({
-      emit: emit,
-      refs: refs,
-      state: state
-    }),
-    watchVisible: watchVisible({
-      nextTick: nextTick,
-      refs: refs,
-      state: state
-    }),
-    advanceTime: advanceTime(api),
-    watchValue: watchValue({
-      api: api,
-      state: state
-    }),
-    handleKeydown: handleKeydown({
-      api: api,
-      state: state
-    }),
-    handleChange: handleChange({
-      api: api,
-      emit: emit,
-      refs: refs,
-      state: state
-    }),
-    handleMinChange: handleMinChange({
-      api: api,
-      state: state
-    }),
-    handleMaxChange: handleMaxChange({
-      api: api,
-      state: state
-    })
+    maxTimeOfDay: maxTimeOfDay({ MAX_TIME }),
+    minTimeOfDay: minTimeOfDay({ MIN_TIME }),
+    changeSelectionRange: changeSelectionRange({ refs, state }),
+    setMaxSelectionRange: setMaxSelectionRange({ emit, state }),
+    setMinSelectionRange: setMinSelectionRange({ emit, state }),
+    isValidValue: isValidValue({ refs, state }),
+    handleConfirm: handleConfirm({ emit, refs, state }),
+    handleCancel: handleCancel({ emit, refs, state }),
+    watchVisible: watchVisible({ nextTick, refs, state }),
+    advanceTime: advanceTime(api2),
+    watchValue: watchValue({ api: api2, state }),
+    handleKeydown: handleKeydown({ api: api2, state }),
+    handleChange: handleChange({ api: api2, emit, refs, state }),
+    handleMinChange: handleMinChange({ api: api2, state }),
+    handleMaxChange: handleMaxChange({ api: api2, state })
   });
-  watch(function () {
-    return state.value;
-  }, api.watchValue);
-  watch(function () {
-    return state.visible;
-  }, api.watchVisible);
-  return api;
-};
+  watch(() => state.value, api2.watchValue);
+  watch(() => state.visible, api2.watchVisible);
+  return api2;
+};
+export {
+  api,
+  renderless
+};