@appbuckets/react-ui/LinearProgress/lib/useProgressProps.js

Just Another React UI Framework

'use strict';

var tslib = require('tslib');
var React = require('react');
var clsx = require('clsx');

function _interopDefaultLegacy(e) {
  return e && typeof e === 'object' && 'default' in e ? e : { default: e };
}

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(
          n,
          k,
          d.get
            ? d
            : {
                enumerable: true,
                get: function () {
                  return e[k];
                },
              }
        );
      }
    });
  }
  n['default'] = e;
  return Object.freeze(n);
}

var React__namespace = /*#__PURE__*/ _interopNamespace(React);
var clsx__default = /*#__PURE__*/ _interopDefaultLegacy(clsx);

function useProgressProps(props) {
  var appearance = props.appearance,
    className = props.className,
    _a = props.colorSteps,
    _b = _a === void 0 ? {} : _a,
    _c = _b.low,
    lowStep = _c === void 0 ? 20 : _c,
    _d = _b.midLow,
    midLowStep = _d === void 0 ? 40 : _d,
    _e = _b.midHigh,
    midHighStep = _e === void 0 ? 60 : _e,
    _f = _b.high,
    highStep = _f === void 0 ? 80 : _f,
    discreet = props.discreet,
    inverted = props.inverted,
    userDefinedMax = props.max,
    userDefinedMin = props.min,
    size = props.size,
    userDefinedValue = props.value,
    rest = tslib.__rest(props, [
      'appearance',
      'className',
      'colorSteps',
      'discreet',
      'inverted',
      'max',
      'min',
      'size',
      'value',
    ]);
  var memoizedProgressProps = React__namespace.useMemo(
    function () {
      var _a;
      // ----
      // Normalize Value and Percentage
      // ----
      var tmpValue = Math.round(userDefinedValue * 100) / 100;
      var tmpMax = Math.round(userDefinedMax * 100) / 100;
      var progressMin = Math.round(userDefinedMin * 100) / 100;
      var hasOverValue = tmpMax < tmpValue;
      var progressValue = hasOverValue ? tmpMax : tmpValue;
      var progressMax = hasOverValue ? tmpValue : tmpMax;
      var progressPercentage = Math.round(
        ((tmpValue - progressMin) / (tmpMax - progressMin)) * 100
      );
      var progressWidth = Math.round(
        ((progressValue - progressMin) / (progressMax - progressMin)) * 100
      );
      // ----
      // Build the Class to Define LinearProgress Color
      // ----
      var colorClassName = (function () {
        /** If is discreet, return null */
        if (discreet) {
          return null;
        }
        /** If an appearance color has been declared, it will win on auto color */
        if (appearance) {
          return appearance;
        }
        if (progressPercentage <= lowStep) {
          return inverted ? 'high' : 'low';
        }
        if (progressPercentage > lowStep && progressPercentage <= midLowStep) {
          return inverted ? 'mid-high' : 'mid-low';
        }
        if (
          progressPercentage > midLowStep &&
          progressPercentage <= midHighStep
        ) {
          return 'mid';
        }
        if (
          progressPercentage > midHighStep &&
          progressPercentage <= highStep
        ) {
          return inverted ? 'mid-low' : 'mid-high';
        }
        return inverted ? 'low' : 'high';
      })();
      // ----
      // Build Component Classes and Element Type
      // ----
      var classes = clsx__default['default'](
        ((_a = {
          overvalued: hasOverValue,
          inverted: inverted,
          progress: true,
        }),
        (_a[
          'is-'.concat(
            size === null || size === void 0 ? void 0 : size.replace(/\s/g, '-')
          )
        ] = size),
        (_a[
          'is-'.concat(
            colorClassName === null || colorClassName === void 0
              ? void 0
              : colorClassName.replace(/\s/g, '-')
          )
        ] = colorClassName),
        _a),
        className
      );
      return {
        className: classes,
        progress: {
          max: progressMax,
          min: progressMin,
          overvalued: hasOverValue,
          percentage: progressPercentage,
          rawMax: tmpMax,
          rawValue: tmpValue,
          width: progressWidth,
          value: progressValue,
        },
      };
    },
    [
      appearance,
      className,
      discreet,
      highStep,
      inverted,
      lowStep,
      midHighStep,
      midLowStep,
      size,
      userDefinedMax,
      userDefinedMin,
      userDefinedValue,
    ]
  );
  return tslib.__assign(tslib.__assign({}, memoizedProgressProps), {
    rest: rest,
  });
}

module.exports = useProgressProps;