@vnmfify/core/picker/picker.js

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

import _map from "lodash/map";
import _isArray from "lodash/isArray";
import _isEmpty from "lodash/isEmpty";
var _excluded = ["defaultValue", "value", "className", "loading", "readonly", "siblingCount", "children", "onChange", "onCancel", "onConfirm"];

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

import { useUncontrolled } from "@vnmfify/hooks";
import { View } from "@vnxjs/components";
import classNames from "classnames";
import * as React from "react";
import { Children, useCallback, useRef } from "react";
import Loading from "../loading";
import { prefixClassname } from "../styles";
import { useRefs, useToRef } from "../utils/state";
import { isElementOf } from "../utils/validate";
import PickerColumns from "./picker-columns";
import { PickerColumn } from "./picker.composition";
import PickerContext from "./picker.context";
import { DEFAULT_SIBLING_COUNT, validPickerColumn } from "./picker.shared";

function usePickerChildren(children) {
  var __children__ = [];
  var columns = [];
  Children.toArray(children).forEach(child => {
    if (isElementOf(child, PickerColumn)) {
      var element = child;

      if (_isEmpty(columns)) {
        __children__.push( /*#__PURE__*/React.createElement(PickerColumns, {
          key: "-1",
          children: columns
        }));
      }

      columns.push(element);
    } else {
      __children__.push(child);
    }
  });
  return __children__;
}

function usePickerValues(value) {
  return _isArray(value) ? value : [value];
}

function Picker(props) {
  var {
    defaultValue,
    value: valueProp,
    className,
    loading,
    readonly,
    siblingCount = DEFAULT_SIBLING_COUNT,
    children: childrenProp,
    onChange,
    onCancel,
    onConfirm
  } = props,
      restProps = _objectWithoutProperties(props, _excluded);

  var {
    getRefs: getColumnRefs,
    setRefs: setColumnRefs,
    clearRefs: clearColumnRefs
  } = useRefs();
  var {
    value,
    setValue
  } = useUncontrolled({
    value: valueProp,
    defaultValue
  });
  var multiValueRef = useToRef(_isArray(value));
  var values = usePickerValues(value);
  var children = usePickerChildren(childrenProp);
  var valueOptionsRef = useRef([]);
  var setValueOptions = useCallback((option, unverifiedColumn) => {
    var column = validPickerColumn(unverifiedColumn);

    if (option && column) {
      var {
        index: columnIndex
      } = column;
      valueOptionsRef.current[columnIndex] = option;
    }
  }, []);
  var handleChange = useCallback((values, option, column) => {
    setValue(values);
    onChange === null || onChange === void 0 ? void 0 : onChange(values, option, column);
  }, [onChange, setValue]);
  var stopMomentum = useCallback(() => getColumnRefs().filter(columnRef => columnRef.current).forEach(columnRef => columnRef.current.stopMomentum()), [getColumnRefs]);

  var handleAction = action => () => {
    stopMomentum();
    action === null || action === void 0 ? void 0 : action(_map(valueOptionsRef.current, _ref => {
      var {
        value
      } = _ref;
      return value;
    }), _map(valueOptionsRef.current, valueOption => _objectSpread({}, valueOption)));
  };

  var getValueOptions = useCallback(() => valueOptionsRef.current, []);
  var isMultiValue = useCallback(() => multiValueRef.current, [multiValueRef]);
  return /*#__PURE__*/React.createElement(PickerContext.Provider, {
    value: {
      readonly,
      siblingCount,
      values,
      getValueOptions,
      isMultiValue,
      setValueOptions,
      clearColumnRefs,
      setColumnRefs,
      onChange: handleChange,
      onConfirm: handleAction(onConfirm),
      onCancel: handleAction(onCancel)
    }
  }, /*#__PURE__*/React.createElement(View, _objectSpread({
    className: classNames(prefixClassname("picker"), className)
  }, restProps), loading && /*#__PURE__*/React.createElement(Loading, {
    className: prefixClassname("picker__loading")
  }), children));
}

export default Picker;
//# sourceMappingURL=picker.js.map