@jobber/components 4.85.4-CJS-to-ESM.1 → 4.85.4-CJS-to-ESM.4

package/dist/AnimatedPresence/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AnimatedPresence = require('../AnimatedPresence-20a02aaa.js');
+require('react');
+require('framer-motion');
+require('@jobber/design');
+
+
+
+exports.AnimatedPresence = AnimatedPresence.AnimatedPresence;

package/dist/AnimatedPresence/index.mjs

@@ -0,0 +1,4 @@
+export { A as AnimatedPresence } from '../AnimatedPresence-bbccdaf7.js';
+import 'react';
+import 'framer-motion';
+import '@jobber/design';

package/dist/AnimatedPresence-20a02aaa.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var design = require('@jobber/design');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const TIMING_QUICK = toSeconds(design.tokens["timing-quick"]);
+const TIMING_BASE = toSeconds(design.tokens["timing-base"]);
+const baseTransition = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const fade = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const popIn = {
+    visible: Object.assign({ scale: 1 }, baseTransition.visible),
+    hidden: Object.assign({ scale: 0.95 }, baseTransition.hidden),
+};
+const fromTop = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: -design.tokens["space-base"] }, baseTransition.hidden),
+};
+const fromBottom = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: design.tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeft = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -design.tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRight = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: design.tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeftToRight = {
+    initial: Object.assign({ x: -design.tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: design.tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRightToLeft = {
+    initial: Object.assign({ x: design.tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -design.tokens["space-base"] }, baseTransition.hidden),
+};
+function toSeconds(ms) {
+    return ms / 1000;
+}
+
+function usePreviousValue(value) {
+    const [previousValue, setPreviousValue] = React.useState(value);
+    React.useEffect(() => {
+        setPreviousValue(value);
+    }, [value]);
+    return [previousValue, setPreviousValue];
+}
+
+const transitions = {
+    fromBottom,
+    fromTop,
+    fromLeft,
+    fromRight,
+    popIn,
+    fromLeftToRight,
+    fromRightToLeft,
+    fade,
+};
+function AnimatedPresence(props) {
+    const shouldReduceMotion = framerMotion.useReducedMotion();
+    if (shouldReduceMotion) {
+        return React__default["default"].createElement(React__default["default"].Fragment, null, props.children);
+    }
+    return React__default["default"].createElement(InternalAnimatedPresence, Object.assign({}, props));
+}
+function InternalAnimatedPresence({ transition = "fromTop", initial = false, children, }) {
+    const transitionVariation = transitions[transition];
+    const hasInitialTransition = "initial" in transitionVariation;
+    const childCount = React.Children.count(children);
+    // Set the initial value to 0 so it staggers the animation on mount when
+    // initial is true.
+    const [lastChildIndex, setLastChildIndex] = usePreviousValue(0);
+    // Whenever the children count changes, update the last index.
+    React.useEffect(() => {
+        setLastChildIndex(childCount - 1);
+    }, [childCount]);
+    return (React__default["default"].createElement(framerMotion.AnimatePresence, { initial: initial, mode: "popLayout" }, React.Children.map(children, (child, i) => child && (React__default["default"].createElement(framerMotion.motion.div, { layout: true, variants: transitionVariation, initial: hasInitialTransition ? "initial" : "hidden", animate: "visible", exit: "hidden", transition: {
+            duration: TIMING_BASE,
+            delay: generateDelayTime(i),
+        } }, child)))));
+    function generateDelayTime(index) {
+        // Don't add a delay if it's already rendered.
+        if (lastChildIndex > index)
+            return 0;
+        // Stagger the animation starting after the previous last child index.
+        return (index - lastChildIndex) * TIMING_QUICK;
+    }
+}
+
+exports.AnimatedPresence = AnimatedPresence;

package/dist/AnimatedPresence-bbccdaf7.js

@@ -0,0 +1,98 @@
+import React, { useState, useEffect, Children } from 'react';
+import { useReducedMotion, AnimatePresence, motion } from 'framer-motion';
+import { tokens } from '@jobber/design';
+
+const TIMING_QUICK = toSeconds(tokens["timing-quick"]);
+const TIMING_BASE = toSeconds(tokens["timing-base"]);
+const baseTransition = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const fade = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const popIn = {
+    visible: Object.assign({ scale: 1 }, baseTransition.visible),
+    hidden: Object.assign({ scale: 0.95 }, baseTransition.hidden),
+};
+const fromTop = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: -tokens["space-base"] }, baseTransition.hidden),
+};
+const fromBottom = {
+    visible: Object.assign({ y: 0 }, baseTransition.visible),
+    hidden: Object.assign({ y: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeft = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRight = {
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromLeftToRight = {
+    initial: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+};
+const fromRightToLeft = {
+    initial: Object.assign({ x: tokens["space-base"] }, baseTransition.hidden),
+    visible: Object.assign({ x: 0 }, baseTransition.visible),
+    hidden: Object.assign({ x: -tokens["space-base"] }, baseTransition.hidden),
+};
+function toSeconds(ms) {
+    return ms / 1000;
+}
+
+function usePreviousValue(value) {
+    const [previousValue, setPreviousValue] = useState(value);
+    useEffect(() => {
+        setPreviousValue(value);
+    }, [value]);
+    return [previousValue, setPreviousValue];
+}
+
+const transitions = {
+    fromBottom,
+    fromTop,
+    fromLeft,
+    fromRight,
+    popIn,
+    fromLeftToRight,
+    fromRightToLeft,
+    fade,
+};
+function AnimatedPresence(props) {
+    const shouldReduceMotion = useReducedMotion();
+    if (shouldReduceMotion) {
+        return React.createElement(React.Fragment, null, props.children);
+    }
+    return React.createElement(InternalAnimatedPresence, Object.assign({}, props));
+}
+function InternalAnimatedPresence({ transition = "fromTop", initial = false, children, }) {
+    const transitionVariation = transitions[transition];
+    const hasInitialTransition = "initial" in transitionVariation;
+    const childCount = Children.count(children);
+    // Set the initial value to 0 so it staggers the animation on mount when
+    // initial is true.
+    const [lastChildIndex, setLastChildIndex] = usePreviousValue(0);
+    // Whenever the children count changes, update the last index.
+    useEffect(() => {
+        setLastChildIndex(childCount - 1);
+    }, [childCount]);
+    return (React.createElement(AnimatePresence, { initial: initial, mode: "popLayout" }, Children.map(children, (child, i) => child && (React.createElement(motion.div, { layout: true, variants: transitionVariation, initial: hasInitialTransition ? "initial" : "hidden", animate: "visible", exit: "hidden", transition: {
+            duration: TIMING_BASE,
+            delay: generateDelayTime(i),
+        } }, child)))));
+    function generateDelayTime(index) {
+        // Don't add a delay if it's already rendered.
+        if (lastChildIndex > index)
+            return 0;
+        // Stagger the animation starting after the previous last child index.
+        return (index - lastChildIndex) * TIMING_QUICK;
+    }
+}
+
+export { AnimatedPresence as A };

package/dist/AnimatedSwitcher/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AnimatedSwitcher = require('../AnimatedSwitcher-3d45ec5d.js');
+require('react');
+require('framer-motion');
+require('../Icon-405a216c.js');
+require('@jobber/design');
+
+
+
+exports.AnimatedSwitcher = AnimatedSwitcher.AnimatedSwitcher;

package/dist/AnimatedSwitcher/index.mjs

@@ -0,0 +1,5 @@
+export { A as AnimatedSwitcher } from '../AnimatedSwitcher-3aff3d12.js';
+import 'react';
+import 'framer-motion';
+import '../Icon-22723fe6.js';
+import '@jobber/design';

package/dist/AnimatedSwitcher-3aff3d12.js

@@ -0,0 +1,90 @@
+import React, { useState } from 'react';
+import { AnimatePresence, motion } from 'framer-motion';
+import { I as Icon } from './Icon-22723fe6.js';
+
+const DURATION_SIMPLE = 0.1;
+const DURATION_AVERAGE = 0.2;
+const FADE = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const SLIDE_IN_UP = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "10%", opacity: 0 },
+};
+const SLIDE_IN_DOWN = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "-10%", opacity: 0 },
+};
+const SPIN_COUNTER_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: 180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+const SPIN_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: -180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+
+function AnimatedSwitcher({ initialChild, switched, switchTo, type = "slideFromBottom", }) {
+    const [ref, setRef] = useState(null);
+    const isSwitchingBetweenIcons = initialChild.type === Icon && switchTo.type === Icon;
+    const { key, transition, child, duration } = getChildData();
+    return (React.createElement(AnimatePresence, { mode: "wait", initial: false },
+        React.createElement(motion.div, { ref: setRef, key: key, variants: transition, initial: "hidden", animate: "visible", exit: "hidden", transition: { duration }, style: { display: getDisplayValue() } }, child)));
+    function getDisplayValue() {
+        if (ref === null || ref === void 0 ? void 0 : ref.firstElementChild) {
+            return window.getComputedStyle(ref.firstElementChild).display;
+        }
+    }
+    function getChildData() {
+        let data = { key: `${initialChild.type}_1`, child: initialChild };
+        if (switched) {
+            data = { key: `${switchTo.type}_2`, child: switchTo };
+        }
+        return Object.assign(Object.assign({}, data), { transition: getTransitionType(), duration: getTransitionDuration() });
+    }
+    function getTransitionType() {
+        if (isSwitchingBetweenIcons) {
+            if (switched)
+                return SPIN_COUNTER_CLOCK_WISE;
+            return SPIN_CLOCK_WISE;
+        }
+        else if (type === "fade") {
+            return FADE;
+        }
+        else {
+            if (switched)
+                return SLIDE_IN_UP;
+            return SLIDE_IN_DOWN;
+        }
+    }
+    function getTransitionDuration() {
+        switch (type) {
+            case "fade":
+                return DURATION_AVERAGE;
+            default:
+                return DURATION_SIMPLE;
+        }
+    }
+}
+AnimatedSwitcher.Icon = function AnimatedSwitcherIcon({ switchToIcon, switched, initialIcon, }) {
+    return (React.createElement(AnimatedSwitcher, { switched: switched, initialChild: React.createElement(Icon, { name: initialIcon }), switchTo: React.createElement(Icon, { name: switchToIcon }) }));
+};
+
+export { AnimatedSwitcher as A };

package/dist/AnimatedSwitcher-3d45ec5d.js

@@ -0,0 +1,96 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var Icon = require('./Icon-405a216c.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+const DURATION_SIMPLE = 0.1;
+const DURATION_AVERAGE = 0.2;
+const FADE = {
+    visible: { opacity: 1 },
+    hidden: { opacity: 0 },
+};
+const SLIDE_IN_UP = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "10%", opacity: 0 },
+};
+const SLIDE_IN_DOWN = {
+    visible: { y: 0, opacity: 1 },
+    hidden: { y: "-10%", opacity: 0 },
+};
+const SPIN_COUNTER_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: 180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+const SPIN_CLOCK_WISE = {
+    visible: {
+        rotate: 0,
+        scale: 1,
+        transition: { duration: DURATION_AVERAGE, ease: "easeOut" },
+    },
+    hidden: {
+        rotate: -180,
+        scale: 0.6,
+        transition: { duration: DURATION_AVERAGE, ease: "easeIn" },
+    },
+};
+
+function AnimatedSwitcher({ initialChild, switched, switchTo, type = "slideFromBottom", }) {
+    const [ref, setRef] = React.useState(null);
+    const isSwitchingBetweenIcons = initialChild.type === Icon.Icon && switchTo.type === Icon.Icon;
+    const { key, transition, child, duration } = getChildData();
+    return (React__default["default"].createElement(framerMotion.AnimatePresence, { mode: "wait", initial: false },
+        React__default["default"].createElement(framerMotion.motion.div, { ref: setRef, key: key, variants: transition, initial: "hidden", animate: "visible", exit: "hidden", transition: { duration }, style: { display: getDisplayValue() } }, child)));
+    function getDisplayValue() {
+        if (ref === null || ref === void 0 ? void 0 : ref.firstElementChild) {
+            return window.getComputedStyle(ref.firstElementChild).display;
+        }
+    }
+    function getChildData() {
+        let data = { key: `${initialChild.type}_1`, child: initialChild };
+        if (switched) {
+            data = { key: `${switchTo.type}_2`, child: switchTo };
+        }
+        return Object.assign(Object.assign({}, data), { transition: getTransitionType(), duration: getTransitionDuration() });
+    }
+    function getTransitionType() {
+        if (isSwitchingBetweenIcons) {
+            if (switched)
+                return SPIN_COUNTER_CLOCK_WISE;
+            return SPIN_CLOCK_WISE;
+        }
+        else if (type === "fade") {
+            return FADE;
+        }
+        else {
+            if (switched)
+                return SLIDE_IN_UP;
+            return SLIDE_IN_DOWN;
+        }
+    }
+    function getTransitionDuration() {
+        switch (type) {
+            case "fade":
+                return DURATION_AVERAGE;
+            default:
+                return DURATION_SIMPLE;
+        }
+    }
+}
+AnimatedSwitcher.Icon = function AnimatedSwitcherIcon({ switchToIcon, switched, initialIcon, }) {
+    return (React__default["default"].createElement(AnimatedSwitcher, { switched: switched, initialChild: React__default["default"].createElement(Icon.Icon, { name: initialIcon }), switchTo: React__default["default"].createElement(Icon.Icon, { name: switchToIcon }) }));
+};
+
+exports.AnimatedSwitcher = AnimatedSwitcher;

package/dist/Autocomplete/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Autocomplete = require('../Autocomplete-6df9f7c0.js');
+require('../tslib.es6-754e2961.js');
+require('react');
+require('lodash/debounce');
+require('../style-inject.es-9d2f5f4e.js');
+require('classnames');
+require('react-dom');
+require('react-popper');
+require('@jobber/hooks/useOnKeyDown');
+require('@jobber/hooks/useSafeLayoutEffect');
+require('../Text-259af966.js');
+require('../Typography-c45bf216.js');
+require('../Icon-405a216c.js');
+require('@jobber/design');
+require('../Heading-1e8e4bd3.js');
+require('../getAtlantisConfig-0f3e8af2.js');
+require('../InputText-55b6cb65.js');
+require('../FormField-6ff183f8.js');
+require('react-hook-form');
+require('@jobber/hooks/useShowClear');
+require('../Button-b73a5e01.js');
+require('react-router-dom');
+require('../InputValidation-05e839fa.js');
+require('framer-motion');
+require('../Spinner-9d8fc7ff.js');
+
+
+
+exports.Autocomplete = Autocomplete.Autocomplete;

package/dist/Autocomplete/index.mjs

@@ -0,0 +1,25 @@
+export { A as Autocomplete } from '../Autocomplete-6ca7a7e5.js';
+import '../tslib.es6-c563c1dd.js';
+import 'react';
+import 'lodash/debounce';
+import '../style-inject.es-a0e1a0ba.js';
+import 'classnames';
+import 'react-dom';
+import 'react-popper';
+import '@jobber/hooks/useOnKeyDown';
+import '@jobber/hooks/useSafeLayoutEffect';
+import '../Text-c9162504.js';
+import '../Typography-7cc5daf5.js';
+import '../Icon-22723fe6.js';
+import '@jobber/design';
+import '../Heading-93e755cb.js';
+import '../getAtlantisConfig-5b50057c.js';
+import '../InputText-8dbcfe70.js';
+import '../FormField-8118cfc8.js';
+import 'react-hook-form';
+import '@jobber/hooks/useShowClear';
+import '../Button-9ae092b3.js';
+import 'react-router-dom';
+import '../InputValidation-d68fb034.js';
+import 'framer-motion';
+import '../Spinner-5d8359b8.js';