@dnb/eufemia 9.28.0 → 9.29.0

package/es/components/slider/SliderHelpers.js

@@ -0,0 +1,124 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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 { format } from '../number-format/NumberUtils';
+export const percentToValue = (percent, min, max) => {
+  if (typeof min === 'string') {
+    min = parseFloat(min);
+  }
+
+  if (typeof max === 'string') {
+    max = parseFloat(max);
+  }
+
+  return (max - min) * percent / 100 + min;
+};
+export const roundToStep = (number, step) => Math.round(number / step) * step;
+export const getOffset = node => {
+  const {
+    pageYOffset,
+    pageXOffset
+  } = typeof window !== 'undefined' ? window : {
+    pageYOffset: 0,
+    pageXOffset: 0
+  };
+  const {
+    left,
+    top
+  } = node.getBoundingClientRect();
+  return {
+    top: top + pageYOffset,
+    left: left + pageXOffset
+  };
+};
+export const 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 const calculatePercent = (node, event, isVertical, isReverted) => {
+  const {
+    width,
+    height
+  } = node.getBoundingClientRect();
+  const {
+    top,
+    left
+  } = getOffset(node);
+  const {
+    x,
+    y
+  } = getMousePosition(event);
+  const value = isVertical ? y - top : x - left;
+  const onePercent = (isVertical ? height : width) / 100;
+  return Math.abs((isReverted ? 100 : 0) - clamp(value / onePercent));
+};
+export const clamp = (value, min = 0, max = 100) => Math.min(Math.max(value, min), max);
+export const roundValue = (value, step) => {
+  return step > 0 ? roundToStep(value, step) : parseFloat(parseFloat(String(value)).toFixed(3));
+};
+export const createMockDiv = ({
+  width,
+  height
+}) => {
+  const div = document.createElement('div');
+
+  _extends(div.style, {
+    width: `${width}px`,
+    height: `${height}px`
+  });
+
+  div.getBoundingClientRect = () => ({
+    width,
+    height,
+    top: 0,
+    left: 0,
+    right: width,
+    bottom: height
+  });
+
+  return div;
+};
+export const getUpdatedValues = (value, index, newValue) => {
+  return value.map((val, i) => {
+    if (i === index) {
+      val = newValue;
+    }
+
+    return val;
+  });
+};
+export const closestIndex = (goal, array) => {
+  const res = [...array].sort((a, b) => Math.abs(goal - a) - Math.abs(goal - b))[0];
+  return array.findIndex(num => num === res);
+};
+export const formatNumber = (value, opts = null) => {
+  if (opts) {
+    return format(value, opts);
+  }
+
+  return value;
+};
+export const getHumanNumber = (value, numberFormat) => {
+  const num = value;
+  const {
+    aria: humanNumber
+  } = numberFormat ? formatNumber(num, _objectSpread(_objectSpread({}, numberFormat || {}), {}, {
+    returnAria: true
+  })) : {
+    aria: null
+  };
+  return String(humanNumber || value);
+};

package/es/components/slider/SliderInstance.d.ts

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

package/es/components/slider/SliderInstance.js

@@ -0,0 +1,167 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+var _SubtractButton, _AddButton, _AlignmentHelper, _SliderMainTrack, _SliderSuffix;
+
+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() {
+  const context = React.useContext(Context);
+  const {
+    isReverse,
+    isVertical,
+    showButtons,
+    showStatus,
+    allProps
+  } = useSliderProps();
+  const {
+    id,
+    label,
+    labelSrOnly,
+    labelDirection,
+    status,
+    statusProps,
+    statusState,
+    statusNoAnimation,
+    globalStatusId,
+    stretch,
+    skeleton,
+    disabled,
+    className
+  } = allProps;
+  const mainParams = {
+    className: classnames("dnb-slider dnb-form-component", createSkeletonClass(null, skeleton), createSpacingClasses(allProps), className, isReverse && 'dnb-slider--reverse', isVertical && 'dnb-slider--vertical', disabled && 'dnb-slider__state--disabled', !showButtons && 'dnb-slider--no-buttons', isTrue(stretch) && 'dnb-slider--stretch', label && labelDirection && `dnb-slider__label--${labelDirection}`, showStatus && 'dnb-slider__form-status', status && `dnb-slider__status--${statusState}`)
+  };
+  const subtractButton = showButtons ? _SubtractButton || (_SubtractButton = React.createElement(SubtractButton, null)) : null;
+  const 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() {
+  const {
+    allProps
+  } = useSliderProps();
+  const {
+    id,
+    suffix
+  } = allProps;
+  return suffix ? React.createElement(Suffix, {
+    className: "dnb-slider__suffix",
+    id: id + '-suffix',
+    context: allProps
+  }, suffix) : null;
+}
+
+function SubtractButton() {
+  const {
+    emitChange,
+    value,
+    attributes,
+    allProps
+  } = useSliderProps();
+  const {
+    step,
+    min,
+    max,
+    disabled,
+    skeleton,
+    subtractTitle,
+    numberFormat
+  } = allProps;
+
+  const onSubtractClickHandler = event => {
+    emitChange(event, clamp(value - (step || 1), min, max));
+  };
+
+  const subtractParams = {};
+
+  if (typeof attributes['aria-hidden'] !== 'undefined') {
+    subtractParams['aria-hidden'] = attributes['aria-hidden'];
+  }
+
+  const 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() {
+  const {
+    emitChange,
+    value,
+    attributes,
+    allProps
+  } = useSliderProps();
+  const {
+    step,
+    min,
+    max,
+    disabled,
+    skeleton,
+    addTitle,
+    numberFormat
+  } = allProps;
+
+  const onAddClickHandler = event => {
+    emitChange(event, clamp(value + (step || 1), min, max));
+  };
+
+  const addParams = {};
+
+  if (typeof attributes['aria-hidden'] !== 'undefined') {
+    addParams['aria-hidden'] = attributes['aria-hidden'];
+  }
+
+  const 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/es/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/es/components/slider/SliderProvider.js

@@ -0,0 +1,178 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+const _excluded = ["step", "label", "labelDirection", "labelSrOnly", "status", "statusState", "statusProps", "statusNoAnimation", "globalStatusId", "stretch", "suffix", "thumbTitle", "subtractTitle", "addTitle", "hideButtons", "numberFormat", "skeleton", "max", "min", "disabled", "className", "id", "onInit", "onChange", "onDragStart", "onDragEnd", "vertical", "reverse", "value", "children"];
+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';
+const defaultProps = {
+  statusState: 'error',
+  addTitle: '+',
+  subtractTitle: '−',
+  min: 0,
+  max: 100,
+  value: -1
+};
+export const SliderContext = React.createContext(null);
+export function SliderProvider(localProps) {
+  const context = React.useContext(Context);
+  const 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));
+  const [_id] = React.useState(makeUniqueId);
+
+  if (!allProps.id) {
+    allProps.id = _id;
+  }
+
+  const {
+    step,
+    label,
+    labelDirection,
+    labelSrOnly,
+    status,
+    statusState,
+    statusProps,
+    statusNoAnimation,
+    globalStatusId,
+    stretch,
+    suffix,
+    thumbTitle: title,
+    subtractTitle,
+    addTitle,
+    hideButtons,
+    numberFormat,
+    skeleton,
+    max,
+    min,
+    disabled,
+    className,
+    id,
+    onInit,
+    onChange,
+    onDragStart,
+    onDragEnd,
+    vertical: _vertical,
+    reverse: _reverse,
+    value: _value,
+    children: _children
+  } = allProps,
+        attributes = _objectWithoutProperties(allProps, _excluded);
+
+  const [value, setValue] = React.useState(_value);
+  const [thumbState, setThumbState] = React.useState('initial');
+  const thumbIndex = React.useRef(-1);
+  const [isVertical] = React.useState(isTrue(_vertical));
+  const [isReverse] = React.useState(isVertical ? !isTrue(_reverse) : isTrue(_reverse));
+  const isMulti = Array.isArray(value);
+
+  const setThumbIndex = index => {
+    if (!isNaN(index)) {
+      thumbIndex.current = index;
+    }
+  };
+
+  if (allProps.use_scrollwheel) {
+    warn('use_scrollwheel is not supported anymore!');
+  }
+
+  const getAndUpdateCurrentIndex = currentValue => {
+    let currentIndex = null;
+
+    if (thumbIndex.current > -1) {
+      currentIndex = thumbIndex.current;
+    } else {
+      currentIndex = closestIndex(currentValue, value);
+      setThumbIndex(currentIndex);
+    }
+
+    return currentIndex;
+  };
+
+  const emitChange = (event, rawValue) => {
+    if (disabled || isTrue(skeleton)) {
+      return;
+    }
+
+    const currentValue = roundValue(rawValue, step);
+
+    if (currentValue > -1 && rawValue !== value) {
+      let newValue = currentValue;
+
+      if (isMulti) {
+        const currentIndex = getAndUpdateCurrentIndex(currentValue);
+        newValue = getUpdatedValues(value, currentIndex, currentValue);
+      }
+
+      if (typeof onChange === 'function') {
+        const obj = {
+          value: newValue,
+          rawValue,
+          raw_value: rawValue,
+          event,
+          number: null
+        };
+
+        if (numberFormat) {
+          obj.number = formatNumber(currentValue, numberFormat);
+        }
+
+        dispatchCustomElementEvent(allProps, 'onChange', obj);
+      }
+
+      setValue(newValue);
+    }
+  };
+
+  React.useEffect(() => {
+    if (isMulti) {
+      const hasChanged = _value.some((val, i) => {
+        return val !== value[i];
+      });
+
+      if (hasChanged) {
+        setValue(_value);
+      }
+    } else {
+      setValue(_value);
+    }
+  }, [_value, isMulti]);
+  const trackRef = React.useRef();
+  const jumpedTimeout = React.useRef();
+
+  const setJumpedState = () => {
+    setThumbState('jumped');
+    clearTimeout(jumpedTimeout.current);
+    jumpedTimeout.current = setTimeout(() => setThumbState('normal'), 100);
+  };
+
+  const showStatus = getStatusState(status);
+  const showButtons = !isMulti && !isTrue(hideButtons);
+  const values = isMulti ? value : [value];
+  return React.createElement(SliderContext.Provider, {
+    value: {
+      isMulti,
+      isReverse,
+      isVertical,
+      value,
+      values,
+      setValue,
+      attributes,
+      showStatus,
+      showButtons,
+      thumbState,
+      setThumbState,
+      thumbIndex,
+      setThumbIndex,
+      emitChange,
+      allProps,
+      trackRef,
+      setJumpedState,
+      jumpedTimeout
+    }
+  }, localProps.children);
+}

package/es/components/slider/SliderThumb.d.ts

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

package/es/components/slider/SliderThumb.js

@@ -0,0 +1,100 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+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 React from 'react';
+import { combineDescribedBy, combineLabelledBy, validateDOMAttributes } from '../../shared/component-helper';
+import Button from '../button/Button';
+import { useSliderEvents } from './hooks/useSliderEvents';
+import { useSliderProps } from './hooks/useSliderProps';
+import { clamp, getHumanNumber } from './SliderHelpers';
+export function SliderThumb() {
+  const {
+    values,
+    thumbIndex,
+    isVertical,
+    showStatus,
+    attributes,
+    allProps
+  } = useSliderProps();
+  const {
+    id,
+    label,
+    min,
+    max,
+    step,
+    skeleton,
+    disabled,
+    suffix,
+    numberFormat
+  } = allProps;
+  const {
+    onThumbMouseDownHandler,
+    onThumbMouseUpHandler,
+    onThumbBlurHandler,
+    onThumbFocusHandler,
+    onHelperChangeHandler,
+    onHelperFocusHandler
+  } = useSliderEvents();
+
+  const thumbParams = _objectSpread({
+    onBlur: onThumbBlurHandler,
+    onFocus: onThumbFocusHandler
+  }, attributes);
+
+  const helperParams = {};
+
+  if (label) {
+    helperParams['aria-labelledby'] = combineLabelledBy(helperParams, label ? id + '-label' : null);
+  }
+
+  if (showStatus || suffix) {
+    helperParams['aria-describedby'] = combineDescribedBy(helperParams, showStatus ? id + '-status' : null, suffix ? id + '-suffix' : null);
+  }
+
+  validateDOMAttributes(null, helperParams);
+  validateDOMAttributes(allProps, thumbParams);
+  return React.createElement(React.Fragment, null, values.map((value, i) => {
+    const index = thumbIndex.current;
+    const percent = clamp((value - min) * 100 / (max - min));
+    const style = {
+      zIndex: index === i ? 4 : 3,
+      [`${isVertical ? 'top' : 'left'}`]: `${percent}%`
+    };
+    const humanNumber = getHumanNumber(value, numberFormat);
+    return React.createElement(React.Fragment, {
+      key: i
+    }, React.createElement("span", {
+      className: "dnb-slider__thumb",
+      style: style
+    }, React.createElement("input", _extends({
+      type: "range",
+      className: "dnb-slider__button-helper",
+      min: min,
+      max: max,
+      step: step,
+      value: value,
+      disabled: disabled,
+      onChange: onHelperChangeHandler,
+      onFocus: onHelperFocusHandler,
+      "aria-valuemin": min,
+      "aria-valuemax": max,
+      "aria-valuenow": value,
+      "aria-valuetext": humanNumber ? humanNumber : undefined,
+      "aria-orientation": isVertical ? 'vertical' : 'horizontal',
+      "data-index": i
+    }, helperParams)), React.createElement(Button, _extends({
+      element: "span",
+      type: "",
+      variant: "secondary",
+      disabled: disabled,
+      skeleton: skeleton,
+      "data-index": i,
+      onMouseDown: onThumbMouseDownHandler,
+      onMouseUp: onThumbMouseUpHandler
+    }, thumbParams))));
+  }));
+}

package/es/components/slider/SliderTrack.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare function SliderMainTrack({ children, }: {
+    children: React.ReactNode | React.ReactNode[];
+}): JSX.Element;
+export declare function SliderTrackBefore(): JSX.Element;
+export declare function SliderTrackAfter(): JSX.Element;

package/es/components/slider/SliderTrack.js

@@ -0,0 +1,99 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+
+var _span;
+
+import React from 'react';
+import { dispatchCustomElementEvent, validateDOMAttributes } from '../../shared/component-helper';
+import { useSliderEvents } from './hooks/useSliderEvents';
+import { useSliderProps } from './hooks/useSliderProps';
+import { clamp, formatNumber } from './SliderHelpers';
+export function SliderMainTrack({
+  children
+}) {
+  const {
+    isMulti,
+    value,
+    allProps,
+    trackRef,
+    jumpedTimeout,
+    thumbState
+  } = useSliderProps();
+  const {
+    id,
+    numberFormat,
+    onInit
+  } = allProps;
+  const {
+    onTrackClickHandler,
+    onThumbMouseDownHandler,
+    removeEvents
+  } = useSliderEvents();
+  React.useEffect(() => {
+    if (typeof onInit === 'function' && !isMulti) {
+      const obj = {
+        value,
+        number: null
+      };
+
+      if (numberFormat) {
+        obj.number = formatNumber(value, numberFormat);
+      }
+
+      dispatchCustomElementEvent(allProps, 'onInit', obj);
+    }
+
+    return () => {
+      removeEvents();
+      clearTimeout(jumpedTimeout.current);
+    };
+  }, []);
+  const trackParams = {
+    className: 'dnb-slider__track' + (thumbState ? ` dnb-slider__state--${thumbState}` : ""),
+    onTouchStart: onTrackClickHandler,
+    onTouchStartCapture: onThumbMouseDownHandler,
+    onMouseDown: onTrackClickHandler,
+    onMouseDownCapture: onThumbMouseDownHandler
+  };
+  validateDOMAttributes(null, trackParams);
+  return React.createElement("span", _extends({
+    id: id,
+    ref: trackRef
+  }, trackParams), children);
+}
+const trackObj = [['right', 'left'], ['bottom', 'top']];
+export function SliderTrackBefore() {
+  const {
+    values: origValues,
+    isVertical,
+    thumbIndex,
+    allProps: {
+      min,
+      max
+    }
+  } = useSliderProps();
+  const values = origValues.sort((a, b) => a - b);
+  const isBetween = values.length >= 2;
+
+  if (isBetween && values[0] > values[values.length - 1]) {
+    values.reverse();
+  }
+
+  const index = thumbIndex.current;
+  const upperValue = values[isBetween ? 0 : index > -1 ? index : 0];
+  const upperPercent = isBetween ? clamp((upperValue - min) * 100 / (max - min)) : 0;
+  const lowerValue = values[isBetween ? values.length - 1 : index > -1 ? index : 0];
+  const lowerPercent = 100 - clamp((lowerValue - min) * 100 / (max - min));
+  const units = [trackObj[isVertical ? 1 : 0][0], trackObj[isVertical ? 1 : 0][1]];
+  const style = {};
+  style[units[0]] = `${lowerPercent}%`;
+  style[units[1]] = `${upperPercent}%`;
+  return React.createElement("span", {
+    className: "dnb-slider__line dnb-slider__line__before",
+    style: style
+  });
+}
+export function SliderTrackAfter() {
+  return _span || (_span = React.createElement("span", {
+    className: "dnb-slider__line dnb-slider__line__after"
+  }));
+}