@vnmfify/core/stepper/stepper.js

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

var _excluded = ["className", "defaultValue", "value", "min", "max", "step", "size", "disabled", "precision", "longPress", "shape", "children", "onChange"];

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, cloneElement, isValidElement, useCallback, useMemo } from "react";
import { prefixClassname } from "../styles";
import { addNumber, formatNumber } from "../utils/format/number";
import { getLogger } from "../utils/logger";
import { useToRef } from "../utils/state";
import StepperButton from "./stepper-button";
import StepperInput from "./stepper-input";
import StepperContext from "./stepper.context";
var {
  deprecated
} = getLogger("Stepper");

function useStepperChildren(children) {
  return useMemo(() => {
    var __children__ = {};
    Children.forEach(children, child => {
      if (! /*#__PURE__*/isValidElement(child)) {
        return;
      }

      var element = child;
      var elementType = element.type;

      if (elementType === StepperButton) {
        if (__children__.decrease === undefined) {
          __children__.decrease = /*#__PURE__*/cloneElement(element, {
            type: "decrease"
          });
        } else if (__children__.increase === undefined) {
          __children__.increase = /*#__PURE__*/cloneElement(element, {
            type: "increase"
          });
        }
      } else if (elementType === StepperInput) {
        __children__.input = element;
      }
    });

    if (!children) {
      var element = /*#__PURE__*/React.createElement(StepperButton, null);

      if (__children__.decrease === undefined) {
        __children__.decrease = /*#__PURE__*/cloneElement(element, {
          type: "decrease"
        });
      }

      if (__children__.input === undefined) {
        __children__.input = /*#__PURE__*/React.createElement(StepperInput, null);
      }

      if (__children__.increase === undefined) {
        __children__.increase = /*#__PURE__*/cloneElement(element, {
          type: "increase"
        });
      }
    }

    return __children__;
  }, [children]);
}

function Stepper(props) {
  var {
    className,
    defaultValue,
    value: valueProp,
    min = 1,
    max = Number.MAX_VALUE,
    step = 1,
    size,
    disabled,
    precision = 0,
    longPress = true,
    shape = "rounded",
    children: childrenProp,
    onChange: onChangeProp
  } = props,
      restProps = _objectWithoutProperties(props, _excluded);

  if (shape === "round") {
    deprecated('Use the shape="circular" prop instead of the shape="round" prop');
  }

  var {
    decrease,
    input,
    increase
  } = useStepperChildren(childrenProp);
  var {
    value = 0,
    setValue
  } = useUncontrolled({
    value: valueProp,
    defaultValue,
    onChange: onChangeProp
  });
  var formatValue = useCallback(value => {
    if (value === "") {
      return value;
    }

    value = formatNumber(String(value), precision > 0);
    value = value === "" ? 0 : +value;
    value = Number.isNaN(value) ? +min : value;
    value = Math.max(Math.min(+max, value), +min);

    if (precision > 0) {
      value = value.toFixed(+precision);
    }

    return value;
  }, [max, min, precision]);
  var valueRef = useToRef(formatValue(value));
  var onStep = useCallback(actionType => {
    var diff = actionType === "decrease" ? -step : +step;
    setValue(formatValue(addNumber(valueRef.current, diff)));
  }, [formatValue, setValue, step, valueRef]);
  return /*#__PURE__*/React.createElement(StepperContext.Provider, {
    value: {
      value: valueRef.current,
      min,
      max,
      size,
      disabled,
      precision,
      longPress,
      formatValue,
      onChange: setValue,
      onStep
    }
  }, /*#__PURE__*/React.createElement(View, _objectSpread({
    className: classNames(prefixClassname("stepper"), {
      [prefixClassname("stepper--square")]: shape === "square",
      [prefixClassname("stepper--rounded")]: shape === "rounded",
      [prefixClassname("stepper--circular")]: shape === "circular" || shape === "round"
    }, className)
  }, restProps), decrease, input, increase));
}

export default Stepper;
//# sourceMappingURL=stepper.js.map