@vnmfify/core/datetime-picker/use-datetime-picker.js

```shell npm i @vnmfify/core -S ```

import _toString from "lodash/toString";
import _isUndefined from "lodash/isUndefined";
import _toNumber from "lodash/toNumber";
import _size from "lodash/size";
import _forEach from "lodash/forEach";
import _padStart from "lodash/padStart";
import _times from "lodash/times";
import _map from "lodash/map";
import { useMemo } from "react";
import { clampDate, getDatetime, getEndDayOfMonth, MAX_DATE, MIN_DATE, useDatetimeRanges } from "./datetime-picker.shared";

var defaultFormatter = (type, value) => value;

export function useDatetimePicker() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  var {
    defaultValue = undefined,
    value = undefined,
    min: minDate = MIN_DATE,
    max: maxDate = MAX_DATE,
    type = "datetime",
    fields = [],
    filter,
    formatter = defaultFormatter
  } = options;
  var clampDefaultValue = clampDate(defaultValue, minDate, maxDate);
  var clampValue = clampDate(value !== null && value !== void 0 ? value : defaultValue, minDate, maxDate);
  var ranges = useDatetimeRanges(clampValue, minDate, maxDate, type, fields);
  var columns = useMemo(() => _map(ranges, _ref => {
    var {
      type,
      range
    } = _ref;

    var values = _times(range[1] - range[0] + 1, index => _padStart("".concat(range[0] + index), 2, "0"));

    if (filter) {
      values = filter(type, values);
    }

    var children = _map(values, value => ({
      value,
      children: formatter(type, value)
    }));

    return {
      type,
      value: type,
      children
    };
  }), [filter, formatter, ranges]);

  function toDate(datetimeValue) {
    var date = new Date(minDate.getTime());

    _forEach(columns, (_ref2, index) => {
      var {
        type
      } = _ref2;

      switch (type) {
        case "year":
          if (_size(datetimeValue) > index) {
            date.setFullYear(_toNumber(datetimeValue[index]));
          }

          break;

        case "month":
          if (_size(datetimeValue) > index) {
            date.setMonth(_toNumber(datetimeValue[index]) - 1);
          }

          break;

        case "day":
          if (_size(datetimeValue) > index) {
            var endDayOfMonth = getEndDayOfMonth(date.getFullYear(), date.getMonth() + 1);

            var day = _toNumber(datetimeValue[index]);

            date.setDate(day > endDayOfMonth ? endDayOfMonth : day);
          }

          break;

        case "hour":
          if (_size(datetimeValue) > index) {
            date.setHours(_toNumber(datetimeValue[index]));
          }

          break;

        case "minute":
          if (_size(datetimeValue) > index) {
            date.setMinutes(_toNumber(datetimeValue[index]));
          }

          break;

        case "second":
          if (_size(datetimeValue) > index) {
            date.setSeconds(_toNumber(datetimeValue[index]));
          }

          break;
      }
    });

    return clampDate(date, minDate, maxDate);
  }

  function toValue(date) {
    if (_isUndefined(date)) {
      return date;
    }

    var [year, month, day, hour, minute, second] = getDatetime(date);
    return _map(columns, column => {
      switch (column.type) {
        case "year":
          return _toString(year);

        case "month":
          return _padStart(_toString(month), 2, "0");

        case "day":
          return _padStart(_toString(day), 2, "0");

        case "hour":
          return _padStart(_toString(hour), 2, "0");

        case "minute":
          return _padStart(_toString(minute), 2, "0");

        case "second":
          return _padStart(_toString(second), 2, "0");

        default:
          return "";
      }
    });
  }

  return {
    toDate,
    defaultValue: toValue(_isUndefined(defaultValue) ? defaultValue : clampDefaultValue),
    value: toValue(_isUndefined(value) ? value : clampValue),
    columns
  };
}
export default useDatetimePicker;
//# sourceMappingURL=use-datetime-picker.js.map