@macive/ui 0.0.1 → 0.0.3

package/dist/src/components/RangeSlider/components/DualThumb/DualThumb.js

@@ -0,0 +1,342 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DualThumb = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const css_1 = require("../../../../utilities/css");
+const debounce_1 = require("../../../../utilities/debounce");
+const features_1 = require("../../../../utilities/features");
+const Labelled_1 = require("../../../Labelled");
+const Text_1 = require("../../../Text");
+// eslint-disable-next-line import/no-deprecated
+const typos_1 = require("../../../../typos");
+const EventListener_1 = require("../../../EventListener");
+const DualThumb_classnames_1 = __importDefault(require("./DualThumb.classnames"));
+const DualThumb_classnames_2 = __importDefault(require("./DualThumb.classnames"));
+var Control;
+(function (Control) {
+    Control[Control["Lower"] = 0] = "Lower";
+    Control[Control["Upper"] = 1] = "Upper";
+})(Control || (Control = {}));
+class DualThumb extends react_1.Component {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            value: sanitizeValue(this.props.value, this.props.min, this.props.max, this.props.step),
+            trackWidth: 0,
+            trackLeft: 0,
+        };
+        this.track = (0, react_1.createRef)();
+        this.trackWrapper = (0, react_1.createRef)();
+        this.thumbLower = (0, react_1.createRef)();
+        this.thumbUpper = (0, react_1.createRef)();
+        this.setTrackPosition = (0, debounce_1.debounce)(() => {
+            if (this.track.current) {
+                const thumbSize = 16;
+                const { width, left } = this.track.current.getBoundingClientRect();
+                const adjustedTrackWidth = width - thumbSize;
+                const adjustedTrackLeft = left + thumbSize / 2;
+                const range = this.props.max - this.props.min;
+                const minValuePosition = (this.props.min / range) * adjustedTrackWidth;
+                this.setState({
+                    trackWidth: adjustedTrackWidth,
+                    trackLeft: adjustedTrackLeft - minValuePosition,
+                });
+            }
+        }, 40, { leading: true, trailing: true, maxWait: 40 });
+        this.handleMouseDownThumbLower = (event) => {
+            if (event.button !== 0 || this.props.disabled)
+                return;
+            registerMouseMoveHandler(this.handleMouseMoveThumbLower);
+            event.stopPropagation();
+        };
+        this.handleMouseMoveThumbLower = (event) => {
+            const valueUpper = this.state.value[1];
+            this.setValue([this.actualXPosition(event.clientX), valueUpper], Control.Upper);
+        };
+        this.handleTouchStartThumbLower = (event) => {
+            if (this.props.disabled)
+                return;
+            registerTouchMoveHandler(this.handleTouchMoveThumbLower);
+            event.stopPropagation();
+        };
+        this.handleTouchMoveThumbLower = (event) => {
+            event.preventDefault();
+            const valueUpper = this.state.value[1];
+            this.setValue([this.actualXPosition(event.touches[0].clientX), valueUpper], Control.Upper);
+        };
+        this.handleMouseDownThumbUpper = (event) => {
+            if (event.button !== 0 || this.props.disabled)
+                return;
+            registerMouseMoveHandler(this.handleMouseMoveThumbUpper);
+            event.stopPropagation();
+        };
+        this.handleMouseMoveThumbUpper = (event) => {
+            const valueLower = this.state.value[0];
+            this.setValue([valueLower, this.actualXPosition(event.clientX)], Control.Lower);
+        };
+        this.handleTouchStartThumbUpper = (event) => {
+            if (this.props.disabled)
+                return;
+            registerTouchMoveHandler(this.handleTouchMoveThumbUpper);
+            event.stopPropagation();
+        };
+        this.handleTouchMoveThumbUpper = (event) => {
+            event.preventDefault();
+            const valueLower = this.state.value[0];
+            this.setValue([valueLower, this.actualXPosition(event.touches[0].clientX)], Control.Lower);
+        };
+        this.handleKeypressLower = (event) => {
+            if (this.props.disabled)
+                return;
+            const { incrementValueLower, decrementValueLower } = this;
+            const handlerMap = {
+                [typos_1.Key.UpArrow]: incrementValueLower,
+                [typos_1.Key.RightArrow]: incrementValueLower,
+                [typos_1.Key.DownArrow]: decrementValueLower,
+                [typos_1.Key.LeftArrow]: decrementValueLower,
+            };
+            const handler = handlerMap[event.keyCode];
+            if (handler != null) {
+                event.preventDefault();
+                event.stopPropagation();
+                handler();
+            }
+        };
+        this.handleKeypressUpper = (event) => {
+            if (this.props.disabled)
+                return;
+            const { incrementValueUpper, decrementValueUpper } = this;
+            const handlerMap = {
+                [typos_1.Key.UpArrow]: incrementValueUpper,
+                [typos_1.Key.RightArrow]: incrementValueUpper,
+                [typos_1.Key.DownArrow]: decrementValueUpper,
+                [typos_1.Key.LeftArrow]: decrementValueUpper,
+            };
+            const handler = handlerMap[event.keyCode];
+            if (handler != null) {
+                event.preventDefault();
+                event.stopPropagation();
+                handler();
+            }
+        };
+        this.incrementValueLower = () => {
+            this.setValue([this.state.value[0] + this.props.step, this.state.value[1]], Control.Upper);
+        };
+        this.decrementValueLower = () => {
+            this.setValue([this.state.value[0] - this.props.step, this.state.value[1]], Control.Upper);
+        };
+        this.incrementValueUpper = () => {
+            this.setValue([this.state.value[0], this.state.value[1] + this.props.step], Control.Lower);
+        };
+        this.decrementValueUpper = () => {
+            this.setValue([this.state.value[0], this.state.value[1] - this.props.step], Control.Lower);
+        };
+        this.dispatchValue = () => {
+            const { onChange, id } = this.props;
+            const { value } = this.state;
+            onChange(value, id);
+        };
+        this.setValue = (dirtyValue, control) => {
+            const { props: { min, max, step }, state: { value }, } = this;
+            const sanitizedValue = sanitizeValue(dirtyValue, min, max, step, control);
+            if (isTupleEqual(sanitizedValue, value) === false) {
+                this.setState({
+                    value: sanitizedValue,
+                }, this.dispatchValue);
+            }
+        };
+        this.handleMouseDownTrack = (event) => {
+            if (event.button !== 0 || this.props.disabled)
+                return;
+            event.preventDefault();
+            const clickXPosition = this.actualXPosition(event.clientX);
+            const { value } = this.state;
+            const distanceFromLowerThumb = Math.abs(value[0] - clickXPosition);
+            const distanceFromUpperThumb = Math.abs(value[1] - clickXPosition);
+            if (distanceFromLowerThumb <= distanceFromUpperThumb) {
+                this.setValue([clickXPosition, value[1]], Control.Upper);
+                registerMouseMoveHandler(this.handleMouseMoveThumbLower);
+                if (this.thumbLower.current != null) {
+                    this.thumbLower.current.focus();
+                }
+            }
+            else {
+                this.setValue([value[0], clickXPosition], Control.Lower);
+                registerMouseMoveHandler(this.handleMouseMoveThumbUpper);
+                if (this.thumbUpper.current != null) {
+                    this.thumbUpper.current.focus();
+                }
+            }
+        };
+        this.handleTouchStartTrack = (event) => {
+            if (this.props.disabled)
+                return;
+            event.preventDefault();
+            const clickXPosition = this.actualXPosition(event.touches[0].clientX);
+            const { value } = this.state;
+            const distanceFromLowerThumb = Math.abs(value[0] - clickXPosition);
+            const distanceFromUpperThumb = Math.abs(value[1] - clickXPosition);
+            if (distanceFromLowerThumb <= distanceFromUpperThumb) {
+                this.setValue([clickXPosition, value[1]], Control.Upper);
+                registerTouchMoveHandler(this.handleTouchMoveThumbLower);
+                if (this.thumbLower.current != null) {
+                    this.thumbLower.current.focus();
+                }
+            }
+            else {
+                this.setValue([value[0], clickXPosition], Control.Lower);
+                registerTouchMoveHandler(this.handleTouchMoveThumbUpper);
+                if (this.thumbUpper.current != null) {
+                    this.thumbUpper.current.focus();
+                }
+            }
+        };
+        this.actualXPosition = (dirtyXPosition) => {
+            if (this.track.current) {
+                const { min, max } = this.props;
+                const { trackLeft, trackWidth } = this.state;
+                const relativeX = dirtyXPosition - trackLeft;
+                const percentageOfTrack = relativeX / trackWidth;
+                return percentageOfTrack * (max - min);
+            }
+            else {
+                return 0;
+            }
+        };
+    }
+    static getDerivedStateFromProps(props, state) {
+        const { min, step, max, value, onChange, id } = props;
+        const { prevValue } = state;
+        if (isTupleEqual(prevValue, value)) {
+            return null;
+        }
+        const sanitizedValue = sanitizeValue(value, min, max, step);
+        if (!isTupleEqual(value, sanitizedValue)) {
+            onChange(sanitizedValue, id);
+        }
+        return {
+            prevValue: value,
+            value: sanitizedValue,
+        };
+    }
+    componentDidMount() {
+        this.setTrackPosition();
+        if (this.trackWrapper.current != null) {
+            this.trackWrapper.current.addEventListener('touchstart', this.handleTouchStartTrack, {
+                passive: false,
+            });
+        }
+    }
+    componentWillUnmount() {
+        if (this.trackWrapper.current != null) {
+            this.trackWrapper.current.removeEventListener('touchstart', this.handleTouchStartTrack);
+        }
+    }
+    render() {
+        const { id, min, max, prefix, suffix, disabled, output, error, onFocus, onBlur, label, labelAction, labelHidden, helpText, } = this.props;
+        const { value } = this.state;
+        const idLower = id;
+        const idUpper = `${id}Upper`;
+        const describedBy = [];
+        if (error) {
+            describedBy.push(`${id}Error`);
+        }
+        const ariaDescribedBy = describedBy.length ? describedBy.join(' ') : undefined;
+        const trackWrapperClassName = (0, css_1.classNames)(DualThumb_classnames_2.default.TrackWrapper, error && DualThumb_classnames_2.default.error, disabled && DualThumb_classnames_2.default.disabled);
+        const thumbLowerClassName = (0, css_1.classNames)(DualThumb_classnames_2.default.Thumbs, DualThumb_classnames_2.default.ThumbLower, disabled && DualThumb_classnames_2.default.disabled);
+        const thumbUpperClassName = (0, css_1.classNames)(DualThumb_classnames_2.default.Thumbs, DualThumb_classnames_2.default.ThumbUpper, disabled && DualThumb_classnames_2.default.disabled);
+        const trackWidth = this.state.trackWidth;
+        const range = max - min;
+        const minValuePosition = (min / range) * trackWidth;
+        const leftPositionThumbLower = (value[0] / range) * trackWidth - minValuePosition;
+        const leftPositionThumbUpper = (value[1] / range) * trackWidth - minValuePosition;
+        const outputLowerClassName = (0, css_1.classNames)(DualThumb_classnames_2.default.Output, DualThumb_classnames_2.default.OutputLower);
+        const outputMarkupLower = !disabled && output ? ((0, jsx_runtime_1.jsx)("output", { htmlFor: idLower, className: outputLowerClassName, style: {
+                left: `${leftPositionThumbLower}px`,
+            }, children: (0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default.OutputBubble, children: (0, jsx_runtime_1.jsx)(Text_1.Text, { as: 'span', variant: 'headingXs', alignment: 'center', children: value[0] }) }) })) : null;
+        const outputUpperClassName = (0, css_1.classNames)(DualThumb_classnames_2.default.Output, DualThumb_classnames_2.default.OutputUpper);
+        const outputMarkupUpper = !disabled && output ? ((0, jsx_runtime_1.jsx)("output", { htmlFor: idUpper, className: outputUpperClassName, style: {
+                left: `${leftPositionThumbUpper}px`,
+            }, children: (0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default.OutputBubble, children: (0, jsx_runtime_1.jsx)(Text_1.Text, { as: 'span', variant: 'headingXs', alignment: 'center', children: value[1] }) }) })) : null;
+        const cssVars = {
+            '--pc-range-slider-progress-lower': `${leftPositionThumbLower}px`,
+            '--pc-range-slider-progress-upper': `${leftPositionThumbUpper}px`,
+        };
+        const prefixMarkup = prefix && (0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default.Prefix, children: prefix });
+        const suffixMarkup = suffix && (0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default.Suffix, children: suffix });
+        return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(Labelled_1.Labelled, { id: id, label: label, error: error, action: labelAction, labelHidden: labelHidden, helpText: helpText, children: (0, jsx_runtime_1.jsxs)("div", { className: (0, css_1.classNames)(DualThumb_classnames_2.default.DualThumb, DualThumb_classnames_1.default.RangeSlider), children: [prefixMarkup, (0, jsx_runtime_1.jsxs)("div", { className: trackWrapperClassName, onMouseDown: this.handleMouseDownTrack, ref: this.trackWrapper, children: [(0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default.Track, style: cssVars, ref: this.track }), (0, jsx_runtime_1.jsx)("div", { className: DualThumb_classnames_2.default['Track--dashed'] }), (0, jsx_runtime_1.jsx)("div", { id: idLower, className: thumbLowerClassName, style: {
+                                            left: `${leftPositionThumbLower}px`,
+                                        }, role: 'slider', "aria-disabled": disabled, "aria-valuemin": min, "aria-valuemax": max, "aria-valuenow": value[0], "aria-invalid": Boolean(error), "aria-describedby": ariaDescribedBy, "aria-labelledby": (0, Labelled_1.labelID)(id), onFocus: onFocus, onBlur: onBlur, tabIndex: 0, onKeyDown: this.handleKeypressLower, onMouseDown: this.handleMouseDownThumbLower, onTouchStart: this.handleTouchStartThumbLower, ref: this.thumbLower }), outputMarkupLower, (0, jsx_runtime_1.jsx)("div", { id: idUpper, className: thumbUpperClassName, style: {
+                                            left: `${leftPositionThumbUpper}px`,
+                                        }, role: 'slider', "aria-disabled": disabled, "aria-valuemin": min, "aria-valuemax": max, "aria-valuenow": value[1], "aria-invalid": Boolean(error), "aria-describedby": ariaDescribedBy, "aria-labelledby": (0, Labelled_1.labelID)(id), onFocus: onFocus, onBlur: onBlur, tabIndex: 0, onKeyDown: this.handleKeypressUpper, onMouseDown: this.handleMouseDownThumbUpper, onTouchStart: this.handleTouchStartThumbUpper, ref: this.thumbUpper }), outputMarkupUpper] }), suffixMarkup] }) }), (0, jsx_runtime_1.jsx)(EventListener_1.EventListener, { event: 'resize', handler: this.setTrackPosition })] }));
+    }
+}
+exports.DualThumb = DualThumb;
+DualThumb.contextType = features_1.FeaturesContext;
+function registerMouseMoveHandler(handler) {
+    document.addEventListener('mousemove', handler);
+    document.addEventListener('mouseup', () => {
+        document.removeEventListener('mousemove', handler);
+    }, { once: true });
+}
+function registerTouchMoveHandler(handler) {
+    const removeHandler = () => {
+        document.removeEventListener('touchmove', handler);
+        document.removeEventListener('touchend', removeHandler);
+        document.removeEventListener('touchcancel', removeHandler);
+    };
+    document.addEventListener('touchmove', handler, { passive: false });
+    document.addEventListener('touchend', removeHandler, { once: true });
+    document.addEventListener('touchcancel', removeHandler, { once: true });
+}
+function sanitizeValue(value, min, max, step, control = Control.Upper) {
+    let upperValue = inBoundsUpper(roundedToStep(value[1]));
+    let lowerValue = inBoundsLower(roundedToStep(value[0]));
+    const maxLowerValue = upperValue - step;
+    const minUpperValue = lowerValue + step;
+    if (control === Control.Upper && lowerValue > maxLowerValue) {
+        lowerValue = maxLowerValue;
+    }
+    else if (control === Control.Lower && upperValue < minUpperValue) {
+        upperValue = minUpperValue;
+    }
+    return [lowerValue, upperValue];
+    function inBoundsUpper(value) {
+        const lowerMin = min + step;
+        if (value < lowerMin) {
+            return lowerMin;
+        }
+        else if (value > max) {
+            return max;
+        }
+        else {
+            return value;
+        }
+    }
+    function inBoundsLower(value) {
+        const upperMax = max - step;
+        if (value < min) {
+            return min;
+        }
+        else if (value > upperMax) {
+            return upperMax;
+        }
+        else {
+            return value;
+        }
+    }
+    function roundedToStep(value) {
+        return Math.round(value / step) * step;
+    }
+}
+// eslint-disable-next-line id-length
+function isTupleEqual(a, b) {
+    if (a == null || b == null) {
+        return false;
+    }
+    return a[0] === b[0] && a[1] === b[1];
+}

package/dist/src/components/RangeSlider/components/DualThumb/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DualThumb"), exports);

package/dist/src/components/RangeSlider/components/SingleThumb/SingleThumb.classnames.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SingleThumbClassnames = {
+    "RangeSlider": "SingleThumb-RangeSlider",
+    "error": "SingleThumb-error",
+    "SingleThumb": "SingleThumb-SingleThumb",
+    "disabled": "SingleThumb-disabled",
+    "InputWrapper": "SingleThumb-InputWrapper",
+    "Prefix": "SingleThumb-Prefix",
+    "Suffix": "SingleThumb-Suffix",
+    "Input": "SingleThumb-Input",
+    "Output": "SingleThumb-Output",
+    "Input:active+&": "SingleThumb-Input:active+&",
+    "OutputBubble": "SingleThumb-OutputBubble"
+};
+exports.default = SingleThumbClassnames;

package/dist/src/components/RangeSlider/components/SingleThumb/SingleThumb.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleThumb = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const clamp_1 = require("../../../../utilities/clamp");
+const css_1 = require("../../../../utilities/css");
+const Labelled_1 = require("../../../Labelled");
+const Text_1 = require("../../../Text");
+const utilities_1 = require("../../utilities");
+const SingleThumb_classnames_1 = __importDefault(require("./SingleThumb.classnames"));
+const SingleThumb_classnames_2 = __importDefault(require("./SingleThumb.classnames"));
+function SingleThumb(props) {
+    const { id, error, helpText, value, min, max, disabled, output, prefix, suffix, label, labelAction, labelHidden, step, onBlur, onFocus, } = props;
+    const clampedValue = (0, clamp_1.clamp)(value, min, max);
+    const describedBy = [];
+    if (error) {
+        describedBy.push(`${id}Error`);
+    }
+    if (helpText) {
+        describedBy.push((0, Labelled_1.helpTextID)(id));
+    }
+    const ariaDescribedBy = describedBy.length ? describedBy.join(' ') : undefined;
+    const sliderProgress = ((clampedValue - min) * 100) / (max - min);
+    const outputFactor = (0, utilities_1.invertNumber)((sliderProgress - 50) / 100);
+    const cssVars = {
+        '--pc-range-slider-min': min,
+        '--pc-range-slider-max': max,
+        '--pc-range-slider-current': clampedValue,
+        '--pc-range-slider-progress': `${sliderProgress}%`,
+        '--pc-range-slider-output-factor': `${outputFactor}`,
+    };
+    const outputMarkup = !disabled && output && ((0, jsx_runtime_1.jsx)("output", { htmlFor: id, className: SingleThumb_classnames_2.default.Output, children: (0, jsx_runtime_1.jsx)("div", { className: SingleThumb_classnames_2.default.OutputBubble, children: (0, jsx_runtime_1.jsx)(Text_1.Text, { as: 'span', variant: 'headingXs', alignment: 'center', children: clampedValue }) }) }));
+    const prefixMarkup = prefix && (0, jsx_runtime_1.jsx)("div", { className: SingleThumb_classnames_2.default.Prefix, children: prefix });
+    const suffixMarkup = suffix && (0, jsx_runtime_1.jsx)("div", { className: SingleThumb_classnames_2.default.Suffix, children: suffix });
+    const className = (0, css_1.classNames)(SingleThumb_classnames_2.default.SingleThumb, SingleThumb_classnames_1.default.RangeSlider, error && SingleThumb_classnames_2.default.error, disabled && SingleThumb_classnames_2.default.disabled);
+    return ((0, jsx_runtime_1.jsx)(Labelled_1.Labelled, { id: id, label: label, error: error, action: labelAction, labelHidden: labelHidden, helpText: helpText, children: (0, jsx_runtime_1.jsxs)("div", { className: className, style: cssVars, children: [prefixMarkup, (0, jsx_runtime_1.jsxs)("div", { className: SingleThumb_classnames_2.default.InputWrapper, children: [(0, jsx_runtime_1.jsx)("input", { type: 'range', className: SingleThumb_classnames_2.default.Input, id: id, name: id, min: min, max: max, step: step, value: clampedValue, disabled: disabled, onChange: handleChange, onFocus: onFocus, onBlur: onBlur, "aria-valuemin": min, "aria-valuemax": max, "aria-valuenow": clampedValue, "aria-invalid": Boolean(error), "aria-describedby": ariaDescribedBy }), outputMarkup] }), suffixMarkup] }) }));
+    function handleChange(event) {
+        const { onChange } = props;
+        onChange && onChange(parseFloat(event.currentTarget.value), id);
+    }
+}
+exports.SingleThumb = SingleThumb;

package/dist/src/components/RangeSlider/components/SingleThumb/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SingleThumb"), exports);

package/dist/src/components/RangeSlider/components/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DualThumb"), exports);
+__exportStar(require("./SingleThumb"), exports);

package/dist/src/components/RangeSlider/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RangeSlider"), exports);

package/dist/src/components/RangeSlider/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/components/RangeSlider/utilities/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invertNumber = void 0;
+var invertNumber_1 = require("./invertNumber");
+Object.defineProperty(exports, "invertNumber", { enumerable: true, get: function () { return invertNumber_1.invertNumber; } });

package/dist/src/components/RangeSlider/utilities/invertNumber.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invertNumber = void 0;
+function invertNumber(number) {
+    if (Math.sign(number) === 1) {
+        return -Math.abs(number);
+    }
+    else if (Math.sign(number) === -1) {
+        return Math.abs(number);
+    }
+    else {
+        return 0;
+    }
+}
+exports.invertNumber = invertNumber;

package/dist/src/components/ResourceItem/ResourceItem.classnames.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ResourceItemClassnames = {
+    "hasBulkActions": "ResourceItem-hasBulkActions",
+    "focusedInner": "ResourceItem-focusedInner",
+    "persistActions": "ResourceItem-persistActions",
+    "Link": "ResourceItem-Link",
+    "ResourceItem": "ResourceItem-ResourceItem",
+    "Actions": "ResourceItem-Actions",
+    "ItemWrapper": "ResourceItem-ItemWrapper",
+    "focusedInner.focused.selected": "ResourceItem-focusedInner.focused.selected",
+    "Button": "ResourceItem-Button",
+    "selectable": "ResourceItem-selectable",
+    "selectMode": "ResourceItem-selectMode",
+    "selected": "ResourceItem-selected",
+    "ListItem": "ResourceItem-ListItem",
+    "ListItem+&": "ResourceItem-ListItem+&",
+    "selectMode)": "ResourceItem-selectMode)",
+    "focused::after": "ResourceItem-focused::after",
+    "focused": "ResourceItem-focused"
+};
+exports.default = ResourceItemClassnames;