@dnb/eufemia 9.27.0 → 9.30.0

package/components/slider/SliderHelpers.d.ts

@@ -0,0 +1,23 @@
+import { formatOptionParams, formatValue, formatReturnType } from '../number-format/NumberUtils';
+import type { ValueTypes } from './types';
+export declare const percentToValue: (percent: number, min: number, max: number, isReverse: boolean) => number;
+export declare const roundToStep: (number: number, step: number) => number;
+export declare const getOffset: (node: HTMLElement) => {
+    top: number;
+    left: number;
+};
+export declare const getMousePosition: (event: MouseEvent & TouchEvent) => {
+    x: number;
+    y: number;
+};
+export declare const calculatePercent: (node: HTMLElement, event: MouseEvent | TouchEvent, isVertical: boolean) => number;
+export declare const clamp: (value: number, min?: number, max?: number) => number;
+export declare const roundValue: (value: number, step: number) => number;
+export declare const createMockDiv: ({ width, height }: {
+    width: any;
+    height: any;
+}) => HTMLDivElement;
+export declare const getUpdatedValues: (value: Array<number>, index: number, newValue: number) => ValueTypes;
+export declare const closestIndex: (goal: number, array: Array<number>) => number;
+export declare const formatNumber: (value: formatValue, opts?: formatOptionParams) => formatReturnType;
+export declare const getHumanNumber: (value: number, numberFormat: formatOptionParams) => string;

package/components/slider/SliderHelpers.js

@@ -0,0 +1,158 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+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; }
+
+import "core-js/modules/es.parse-float.js";
+import "core-js/modules/es.number.to-fixed.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.array.find-index.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.object.get-own-property-descriptor.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import { format } from '../number-format/NumberUtils';
+export var percentToValue = function percentToValue(percent, min, max, isReverse) {
+  if (typeof min === 'string') {
+    min = parseFloat(min);
+  }
+
+  if (typeof max === 'string') {
+    max = parseFloat(max);
+  }
+
+  var num = (max - min) * percent / 100 + min;
+
+  if (isReverse) {
+    num = max + min - num;
+  }
+
+  return num;
+};
+export var roundToStep = function roundToStep(number, step) {
+  return Math.round(number / step) * step;
+};
+export var getOffset = function getOffset(node) {
+  var _ref = typeof window !== 'undefined' ? window : {
+    pageYOffset: 0,
+    pageXOffset: 0
+  },
+      pageYOffset = _ref.pageYOffset,
+      pageXOffset = _ref.pageXOffset;
+
+  var _node$getBoundingClie = node.getBoundingClientRect(),
+      left = _node$getBoundingClie.left,
+      top = _node$getBoundingClie.top;
+
+  return {
+    top: top + pageYOffset,
+    left: left + pageXOffset
+  };
+};
+export var getMousePosition = function getMousePosition(event) {
+  if (event.changedTouches && event.changedTouches[0]) {
+    return {
+      x: event.changedTouches[0].pageX,
+      y: event.changedTouches[0].pageY
+    };
+  }
+
+  return {
+    x: event.pageX,
+    y: event.pageY
+  };
+};
+export var calculatePercent = function calculatePercent(node, event, isVertical) {
+  var _node$getBoundingClie2 = node.getBoundingClientRect(),
+      width = _node$getBoundingClie2.width,
+      height = _node$getBoundingClie2.height;
+
+  var _getOffset = getOffset(node),
+      top = _getOffset.top,
+      left = _getOffset.left;
+
+  var _getMousePosition = getMousePosition(event),
+      x = _getMousePosition.x,
+      y = _getMousePosition.y;
+
+  var value = isVertical ? y - top : x - left;
+  var onePercent = (isVertical ? height : width) / 100;
+  return Math.abs(clamp(value / onePercent));
+};
+export var clamp = function clamp(value) {
+  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 100;
+  return Math.min(Math.max(value, min), max);
+};
+export var roundValue = function roundValue(value, step) {
+  return step > 0 ? roundToStep(value, step) : parseFloat(parseFloat(String(value)).toFixed(3));
+};
+export var createMockDiv = function createMockDiv(_ref2) {
+  var width = _ref2.width,
+      height = _ref2.height;
+  var div = document.createElement('div');
+
+  _extends(div.style, {
+    width: "".concat(width, "px"),
+    height: "".concat(height, "px")
+  });
+
+  div.getBoundingClientRect = function () {
+    return {
+      width: width,
+      height: height,
+      top: 0,
+      left: 0,
+      right: width,
+      bottom: height
+    };
+  };
+
+  return div;
+};
+export var getUpdatedValues = function getUpdatedValues(value, index, newValue) {
+  return value.map(function (val, i) {
+    if (i === index) {
+      val = newValue;
+    }
+
+    return val;
+  });
+};
+export var closestIndex = function closestIndex(goal, array) {
+  var res = _toConsumableArray(array).sort(function (a, b) {
+    return Math.abs(goal - a) - Math.abs(goal - b);
+  })[0];
+
+  return array.findIndex(function (num) {
+    return num === res;
+  });
+};
+export var formatNumber = function formatNumber(value) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+  if (opts) {
+    return format(value, opts);
+  }
+
+  return value;
+};
+export var getHumanNumber = function getHumanNumber(value, numberFormat) {
+  var num = value;
+
+  var _ref3 = numberFormat ? formatNumber(num, _objectSpread(_objectSpread({}, numberFormat || {}), {}, {
+    returnAria: true
+  })) : {
+    aria: null
+  },
+      humanNumber = _ref3.aria;
+
+  return String(humanNumber || value);
+};

package/components/slider/SliderInstance.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Web Slider Component
+ *
+ */
+/// <reference types="react" />
+export declare function SliderInstance(): JSX.Element;

package/components/slider/SliderInstance.js

@@ -0,0 +1,162 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+var _SubtractButton, _AddButton, _AlignmentHelper, _SliderMainTrack, _SliderSuffix;
+
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.string.replace.js";
+import React from 'react';
+import classnames from 'classnames';
+import { isTrue } from '../../shared/component-helper';
+import AlignmentHelper from '../../shared/AlignmentHelper';
+import { createSpacingClasses } from '../space/SpacingHelper';
+import { createSkeletonClass, skeletonDOMAttributes } from '../skeleton/SkeletonHelper';
+import Context from '../../shared/Context';
+import Suffix from '../../shared/helpers/Suffix';
+import Button from '../button/Button';
+import FormLabel from '../form-label/FormLabel';
+import FormStatus from '../form-status/FormStatus';
+import { SliderMainTrack, SliderTrackAfter, SliderTrackBefore } from './SliderTrack';
+import { SliderThumb } from './SliderThumb';
+import { useSliderProps } from './hooks/useSliderProps';
+import { clamp, getHumanNumber } from './SliderHelpers';
+export function SliderInstance() {
+  var context = React.useContext(Context);
+
+  var _useSliderProps = useSliderProps(),
+      isReverse = _useSliderProps.isReverse,
+      isVertical = _useSliderProps.isVertical,
+      showButtons = _useSliderProps.showButtons,
+      showStatus = _useSliderProps.showStatus,
+      allProps = _useSliderProps.allProps;
+
+  var id = allProps.id,
+      label = allProps.label,
+      labelSrOnly = allProps.labelSrOnly,
+      labelDirection = allProps.labelDirection,
+      status = allProps.status,
+      statusProps = allProps.statusProps,
+      statusState = allProps.statusState,
+      statusNoAnimation = allProps.statusNoAnimation,
+      globalStatusId = allProps.globalStatusId,
+      stretch = allProps.stretch,
+      skeleton = allProps.skeleton,
+      disabled = allProps.disabled,
+      className = allProps.className;
+  var mainParams = {
+    className: classnames("dnb-slider dnb-form-component", createSkeletonClass(null, skeleton), createSpacingClasses(allProps), className, isVertical && 'dnb-slider--vertical', disabled && 'dnb-slider__state--disabled', !showButtons && 'dnb-slider--no-buttons', isTrue(stretch) && 'dnb-slider--stretch', label && labelDirection && "dnb-slider__label--".concat(labelDirection), showStatus && 'dnb-slider__form-status', status && "dnb-slider__status--".concat(statusState))
+  };
+  var subtractButton = showButtons ? _SubtractButton || (_SubtractButton = React.createElement(SubtractButton, null)) : null;
+  var addButton = showButtons ? _AddButton || (_AddButton = React.createElement(AddButton, null)) : null;
+  skeletonDOMAttributes(mainParams, skeleton, context);
+  return React.createElement("span", mainParams, label && React.createElement(FormLabel, {
+    id: id + '-label',
+    text: label,
+    disabled: disabled,
+    skeleton: skeleton,
+    label_direction: labelDirection,
+    sr_only: labelSrOnly
+  }), React.createElement("span", {
+    className: "dnb-slider__wrapper"
+  }, _AlignmentHelper || (_AlignmentHelper = React.createElement(AlignmentHelper, null)), React.createElement(FormStatus, _extends({
+    show: showStatus,
+    id: id + '-form-status',
+    global_status_id: globalStatusId,
+    label: label,
+    text_id: id + '-status',
+    text: status,
+    status: statusState,
+    no_animation: statusNoAnimation,
+    skeleton: skeleton
+  }, statusProps)), React.createElement("span", {
+    className: "dnb-slider__inner"
+  }, showButtons && (isReverse ? addButton : subtractButton), _SliderMainTrack || (_SliderMainTrack = React.createElement(SliderMainTrack, null, React.createElement(SliderThumb, null), React.createElement(SliderTrackBefore, null), React.createElement(SliderTrackAfter, null))), showButtons && (isReverse ? subtractButton : addButton), _SliderSuffix || (_SliderSuffix = React.createElement(SliderSuffix, null)))));
+}
+
+function SliderSuffix() {
+  var _useSliderProps2 = useSliderProps(),
+      allProps = _useSliderProps2.allProps;
+
+  var id = allProps.id,
+      suffix = allProps.suffix;
+  return suffix ? React.createElement(Suffix, {
+    className: "dnb-slider__suffix",
+    id: id + '-suffix',
+    context: allProps
+  }, suffix) : null;
+}
+
+function SubtractButton() {
+  var _useSliderProps3 = useSliderProps(),
+      emitChange = _useSliderProps3.emitChange,
+      value = _useSliderProps3.value,
+      attributes = _useSliderProps3.attributes,
+      allProps = _useSliderProps3.allProps;
+
+  var step = allProps.step,
+      min = allProps.min,
+      max = allProps.max,
+      disabled = allProps.disabled,
+      skeleton = allProps.skeleton,
+      subtractTitle = allProps.subtractTitle,
+      numberFormat = allProps.numberFormat;
+
+  var onSubtractClickHandler = function onSubtractClickHandler(event) {
+    emitChange(event, clamp(value - (step || 1), min, max));
+  };
+
+  var subtractParams = {};
+
+  if (typeof attributes['aria-hidden'] !== 'undefined') {
+    subtractParams['aria-hidden'] = attributes['aria-hidden'];
+  }
+
+  var humanNumber = getHumanNumber(value, numberFormat);
+  return React.createElement(Button, _extends({
+    className: "dnb-slider__button dnb-slider__button--subtract",
+    variant: "secondary",
+    icon: "subtract",
+    size: "small",
+    "aria-label": subtractTitle === null || subtractTitle === void 0 ? void 0 : subtractTitle.replace('%s', humanNumber),
+    on_click: onSubtractClickHandler,
+    disabled: disabled,
+    skeleton: skeleton
+  }, subtractParams));
+}
+
+function AddButton() {
+  var _useSliderProps4 = useSliderProps(),
+      emitChange = _useSliderProps4.emitChange,
+      value = _useSliderProps4.value,
+      attributes = _useSliderProps4.attributes,
+      allProps = _useSliderProps4.allProps;
+
+  var step = allProps.step,
+      min = allProps.min,
+      max = allProps.max,
+      disabled = allProps.disabled,
+      skeleton = allProps.skeleton,
+      addTitle = allProps.addTitle,
+      numberFormat = allProps.numberFormat;
+
+  var onAddClickHandler = function onAddClickHandler(event) {
+    emitChange(event, clamp(value + (step || 1), min, max));
+  };
+
+  var addParams = {};
+
+  if (typeof attributes['aria-hidden'] !== 'undefined') {
+    addParams['aria-hidden'] = attributes['aria-hidden'];
+  }
+
+  var humanNumber = getHumanNumber(value, numberFormat);
+  return React.createElement(Button, _extends({
+    className: "dnb-slider__button dnb-slider__button--add",
+    variant: "secondary",
+    icon: "add",
+    size: "small",
+    "aria-label": addTitle === null || addTitle === void 0 ? void 0 : addTitle.replace('%s', humanNumber),
+    on_click: onAddClickHandler,
+    disabled: disabled,
+    skeleton: skeleton
+  }, addParams));
+}

package/components/slider/SliderProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { SliderProps, SliderContextTypes } from './types';
+export declare const SliderContext: React.Context<SliderContextTypes>;
+export declare function SliderProvider(localProps: SliderProps): JSX.Element;

package/components/slider/SliderProvider.js

@@ -0,0 +1,236 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["step", "label", "labelDirection", "labelSrOnly", "status", "statusState", "statusProps", "statusNoAnimation", "globalStatusId", "stretch", "suffix", "thumbTitle", "subtractTitle", "addTitle", "hideButtons", "multiThumbBehavior", "numberFormat", "skeleton", "max", "min", "disabled", "className", "id", "onInit", "onChange", "onDragStart", "onDragEnd", "vertical", "reverse", "value", "children"];
+import "core-js/modules/es.array.reverse.js";
+import "core-js/modules/es.object.to-string.js";
+import React from 'react';
+import { includeValidProps } from '../../components/form-row/FormRowHelpers';
+import { usePropsWithContext } from '../../shared/hooks';
+import { warn, isTrue, makeUniqueId, dispatchCustomElementEvent, getStatusState } from '../../shared/component-helper';
+import Context from '../../shared/Context';
+import { closestIndex, formatNumber, getUpdatedValues, roundValue } from './SliderHelpers';
+import { convertSnakeCaseProps } from '../../shared/helpers/withSnakeCaseProps';
+var defaultProps = {
+  statusState: 'error',
+  addTitle: '+',
+  subtractTitle: '−',
+  min: 0,
+  max: 100,
+  value: -1,
+  multiThumbBehavior: 'swap'
+};
+export var SliderContext = React.createContext(null);
+export function SliderProvider(localProps) {
+  var context = React.useContext(Context);
+  var allProps = convertSnakeCaseProps(usePropsWithContext(localProps, defaultProps, {
+    skeleton: context === null || context === void 0 ? void 0 : context.skeleton
+  }, context === null || context === void 0 ? void 0 : context.getTranslation(localProps).Slider, includeValidProps(context === null || context === void 0 ? void 0 : context.FormRow, {
+    vertical: null
+  }), context === null || context === void 0 ? void 0 : context.Slider));
+
+  var _React$useState = React.useState(makeUniqueId),
+      _React$useState2 = _slicedToArray(_React$useState, 1),
+      _id = _React$useState2[0];
+
+  if (!allProps.id) {
+    allProps.id = _id;
+  }
+
+  var step = allProps.step,
+      label = allProps.label,
+      labelDirection = allProps.labelDirection,
+      labelSrOnly = allProps.labelSrOnly,
+      status = allProps.status,
+      statusState = allProps.statusState,
+      statusProps = allProps.statusProps,
+      statusNoAnimation = allProps.statusNoAnimation,
+      globalStatusId = allProps.globalStatusId,
+      stretch = allProps.stretch,
+      suffix = allProps.suffix,
+      title = allProps.thumbTitle,
+      subtractTitle = allProps.subtractTitle,
+      addTitle = allProps.addTitle,
+      hideButtons = allProps.hideButtons,
+      multiThumbBehavior = allProps.multiThumbBehavior,
+      numberFormat = allProps.numberFormat,
+      skeleton = allProps.skeleton,
+      max = allProps.max,
+      min = allProps.min,
+      disabled = allProps.disabled,
+      className = allProps.className,
+      id = allProps.id,
+      onInit = allProps.onInit,
+      onChange = allProps.onChange,
+      onDragStart = allProps.onDragStart,
+      onDragEnd = allProps.onDragEnd,
+      _vertical = allProps.vertical,
+      _reverse = allProps.reverse,
+      _value = allProps.value,
+      _children = allProps.children,
+      attributes = _objectWithoutProperties(allProps, _excluded);
+
+  var _React$useState3 = React.useState(_value),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      value = _React$useState4[0],
+      setValue = _React$useState4[1];
+
+  var realtimeValue = React.useRef(_value);
+
+  var _React$useState5 = React.useState('initial'),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      thumbState = _React$useState6[0],
+      setThumbState = _React$useState6[1];
+
+  var thumbIndex = React.useRef(-1);
+
+  var _React$useState7 = React.useState(isTrue(_vertical)),
+      _React$useState8 = _slicedToArray(_React$useState7, 1),
+      isVertical = _React$useState8[0];
+
+  var _React$useState9 = React.useState(isVertical ? !isTrue(_reverse) : isTrue(_reverse)),
+      _React$useState10 = _slicedToArray(_React$useState9, 1),
+      isReverse = _React$useState10[0];
+
+  var isMulti = Array.isArray(value);
+
+  var setThumbIndex = function setThumbIndex(index) {
+    if (!isNaN(index)) {
+      thumbIndex.current = index;
+    }
+  };
+
+  if (allProps.use_scrollwheel) {
+    warn('use_scrollwheel is not supported anymore!');
+  }
+
+  var getAndUpdateCurrentIndex = function getAndUpdateCurrentIndex(currentValue) {
+    var currentIndex = null;
+
+    if (thumbIndex.current > -1) {
+      currentIndex = thumbIndex.current;
+    } else {
+      currentIndex = closestIndex(currentValue, value);
+      setThumbIndex(currentIndex);
+    }
+
+    return currentIndex;
+  };
+
+  var updateValue = function updateValue(value) {
+    setValue(value);
+    realtimeValue.current = value;
+  };
+
+  var emitChange = function emitChange(event, rawValue) {
+    if (disabled || isTrue(skeleton)) {
+      return;
+    }
+
+    var numberValue = roundValue(rawValue, step);
+    var multiValues = numberValue;
+
+    if (numberValue > -1) {
+      if (isMulti) {
+        var currentIndex = getAndUpdateCurrentIndex(numberValue);
+        var lower = realtimeValue.current[currentIndex - 1];
+        var upper = realtimeValue.current[currentIndex + 1];
+
+        if (multiThumbBehavior === 'omit') {
+          if (numberValue < lower) {
+            numberValue = lower;
+          }
+
+          if (numberValue > upper) {
+            numberValue = upper;
+          }
+        }
+
+        multiValues = getUpdatedValues(multiThumbBehavior === 'push' ? realtimeValue.current : value, currentIndex, numberValue);
+
+        if (multiThumbBehavior === 'push') {
+          if (typeof lower !== 'undefined' && numberValue < lower) {
+            multiValues[currentIndex - 1] = numberValue;
+          }
+
+          if (typeof upper !== 'undefined' && numberValue >= upper) {
+            multiValues[currentIndex + 1] = numberValue;
+          }
+        }
+
+        if (numberValue === realtimeValue.current[currentIndex]) {
+          return;
+        }
+      } else if (numberValue === realtimeValue.current) {
+        return;
+      }
+
+      if (typeof onChange === 'function') {
+        var obj = {
+          value: multiValues,
+          rawValue: rawValue,
+          raw_value: rawValue,
+          event: event,
+          number: null
+        };
+
+        if (numberFormat) {
+          obj.number = formatNumber(numberValue, numberFormat);
+        }
+
+        dispatchCustomElementEvent(allProps, 'onChange', obj);
+      }
+
+      updateValue(multiValues);
+    }
+  };
+
+  React.useEffect(function () {
+    if (isMulti) {
+      var hasChanged = _value.some(function (val, i) {
+        return val !== value[i];
+      });
+
+      if (hasChanged) {
+        updateValue(_value);
+      }
+    } else {
+      updateValue(_value);
+    }
+  }, [_value, isMulti]);
+  var trackRef = React.useRef();
+  var jumpedTimeout = React.useRef();
+
+  var setJumpedState = function setJumpedState() {
+    setThumbState('jumped');
+    clearTimeout(jumpedTimeout.current);
+    jumpedTimeout.current = setTimeout(function () {
+      return setThumbState('normal');
+    }, 100);
+  };
+
+  var showStatus = getStatusState(status);
+  var showButtons = !isMulti && !isTrue(hideButtons);
+  var values = isMulti ? value : [value];
+  return React.createElement(SliderContext.Provider, {
+    value: {
+      isMulti: isMulti,
+      isReverse: isReverse,
+      isVertical: isVertical,
+      value: value,
+      values: values,
+      setValue: setValue,
+      attributes: attributes,
+      showStatus: showStatus,
+      showButtons: showButtons,
+      thumbState: thumbState,
+      setThumbState: setThumbState,
+      thumbIndex: thumbIndex,
+      setThumbIndex: setThumbIndex,
+      emitChange: emitChange,
+      allProps: allProps,
+      trackRef: trackRef,
+      setJumpedState: setJumpedState,
+      jumpedTimeout: jumpedTimeout
+    }
+  }, localProps.children);
+}

package/components/slider/SliderThumb.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare function SliderThumb(): JSX.Element;