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

package/dist/InputText-8dbcfe70.js

@@ -0,0 +1,96 @@
+import React, { forwardRef, useRef, useImperativeHandle } from 'react';
+import { useSafeLayoutEffect } from '@jobber/hooks/useSafeLayoutEffect';
+import { F as FormField } from './FormField-8118cfc8.js';
+
+function InputTextInternal(props, ref) {
+    const inputRef = useRef(null);
+    const actionsRef = useRef(null);
+    const rowRange = getRowRange();
+    useImperativeHandle(ref, () => ({
+        insert: (text) => {
+            insertText(text);
+        },
+        blur: () => {
+            const input = inputRef.current;
+            if (input) {
+                input.blur();
+            }
+        },
+        focus: () => {
+            const input = inputRef.current;
+            if (input) {
+                input.focus();
+            }
+        },
+        scrollIntoView: arg => {
+            const input = inputRef.current;
+            if (input) {
+                input.scrollIntoView(arg);
+            }
+        },
+    }));
+    useSafeLayoutEffect(() => {
+        if (inputRef && inputRef.current instanceof HTMLTextAreaElement) {
+            resize(inputRef.current);
+        }
+    }, [inputRef.current]);
+    return (React.createElement(FormField, Object.assign({}, props, { type: props.multiline ? "textarea" : "text", inputRef: inputRef, actionsRef: actionsRef, onChange: handleChange, rows: rowRange.min })));
+    function handleChange(newValue) {
+        props.onChange && props.onChange(newValue);
+        if (inputRef && inputRef.current instanceof HTMLTextAreaElement) {
+            resize(inputRef.current);
+        }
+    }
+    function getRowRange() {
+        if (props.rows === undefined) {
+            return { min: 3, max: 3 };
+        }
+        else if (typeof props.rows === "object") {
+            return { min: props.rows.min, max: props.rows.max };
+        }
+        else {
+            return { min: props.rows, max: props.rows };
+        }
+    }
+    function resize(textArea) {
+        if (rowRange.min === rowRange.max)
+            return;
+        textArea.style.height = "auto";
+        textArea.style.height = textAreaHeight(textArea) + "px";
+    }
+    function textAreaHeight(textArea) {
+        const { lineHeight, borderBottomWidth, borderTopWidth, paddingBottom, paddingTop, } = window.getComputedStyle(textArea);
+        const maxHeight = rowRange.max * parseFloat(lineHeight) +
+            parseFloat(borderTopWidth) +
+            parseFloat(borderBottomWidth) +
+            parseFloat(paddingTop) +
+            parseFloat(paddingBottom);
+        const scrollHeight = textArea.scrollHeight +
+            parseFloat(borderTopWidth) +
+            parseFloat(borderBottomWidth);
+        return Math.min(scrollHeight, maxHeight);
+    }
+    function insertText(text) {
+        var _a;
+        const input = inputRef.current;
+        if (input) {
+            insertAtCursor(input, text);
+            const newValue = input.value;
+            (_a = actionsRef.current) === null || _a === void 0 ? void 0 : _a.setValue(newValue);
+            props.onChange && props.onChange(newValue);
+        }
+    }
+}
+const InputText = forwardRef(InputTextInternal);
+function insertAtCursor(input, newText) {
+    const start = input.selectionStart || 0;
+    const end = input.selectionEnd || 0;
+    const text = input.value;
+    const before = text.substring(0, start);
+    const after = text.substring(end, text.length);
+    input.value = before + newText + after;
+    input.selectionStart = input.selectionEnd = start + newText.length;
+    input.focus();
+}
+
+export { InputText as I };

package/dist/InputTime/index.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var InputTime = require('../InputTime-ce24b2bf.js');
+require('../tslib.es6-754e2961.js');
+require('react');
+require('@std-proposal/temporal');
+require('lodash/debounce');
+require('../FormField-6ff183f8.js');
+require('react-hook-form');
+require('../style-inject.es-9d2f5f4e.js');
+require('classnames');
+require('@jobber/hooks/useShowClear');
+require('../Button-b73a5e01.js');
+require('react-router-dom');
+require('../Icon-405a216c.js');
+require('@jobber/design');
+require('../Typography-c45bf216.js');
+require('../Text-259af966.js');
+require('../InputValidation-05e839fa.js');
+require('framer-motion');
+require('../Spinner-9d8fc7ff.js');
+
+
+
+exports.InputTime = InputTime.InputTime;

package/dist/InputTime/index.mjs

@@ -0,0 +1,19 @@
+export { I as InputTime } from '../InputTime-13522852.js';
+import '../tslib.es6-c563c1dd.js';
+import 'react';
+import '@std-proposal/temporal';
+import 'lodash/debounce';
+import '../FormField-8118cfc8.js';
+import 'react-hook-form';
+import '../style-inject.es-a0e1a0ba.js';
+import 'classnames';
+import '@jobber/hooks/useShowClear';
+import '../Button-9ae092b3.js';
+import 'react-router-dom';
+import '../Icon-22723fe6.js';
+import '@jobber/design';
+import '../Typography-7cc5daf5.js';
+import '../Text-c9162504.js';
+import '../InputValidation-d68fb034.js';
+import 'framer-motion';
+import '../Spinner-5d8359b8.js';

package/dist/InputTime-13522852.js

@@ -0,0 +1,187 @@
+import { _ as __rest } from './tslib.es6-c563c1dd.js';
+import React, { useRef, useState, useCallback, useEffect } from 'react';
+import { CivilTime } from '@std-proposal/temporal';
+import debounce from 'lodash/debounce';
+import { F as FormField } from './FormField-8118cfc8.js';
+
+function civilTimeToHTMLTime(civilTime) {
+    if (civilTime == undefined) {
+        return "";
+    }
+    const timeString = civilTime.toString();
+    return timeString.slice(0, 5);
+}
+function htmlTimeToCivilTime(timeString) {
+    try {
+        return CivilTime.fromString(timeString + ":00.000000000");
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+
+const DEBOUNCE_TIME = 300;
+function useTimePredict({ value, handleChange }) {
+    const IS_12_HOUR_FORMAT = useRef(Intl.DateTimeFormat(navigator.language, {
+        hour: "numeric",
+    }).resolvedOptions().hour12);
+    const [typedTime, setTypedTime] = useState("");
+    const predictTime = useCallback(debounce(() => {
+        if (value)
+            return;
+        handleChange(predictHours(typedTime, IS_12_HOUR_FORMAT.current));
+    }, DEBOUNCE_TIME), [typedTime, value, handleChange]);
+    /**
+     * Predict the hour when user types a number
+     */
+    useEffect(() => {
+        /**
+         * Don't try to predict if the user types 0 as the user would almost always
+         * type another number after 0.
+         */
+        if (typedTime && typedTime !== "0") {
+            predictTime();
+            if ((IS_12_HOUR_FORMAT && typedTime !== "1") || typedTime.length === 2) {
+                // Immediately predict the hour
+                predictTime.flush();
+            }
+        }
+        return predictTime.cancel;
+    }, [typedTime]);
+    /**
+     * Reset typed time when the value changed
+     */
+    useEffect(() => {
+        setTypedTime("");
+    }, [value]);
+    return {
+        setTypedTime,
+    };
+}
+function predictHours(time, is12HourFormat = false) {
+    const today = new Date();
+    const currentHour = today.getHours();
+    const parsedTime = parseInt(time, 10);
+    let predictedTime;
+    if (is12HourFormat) {
+        predictedTime = predict12Hours(parsedTime, currentHour);
+    }
+    else {
+        predictedTime = predict24Hours(time, parsedTime, currentHour);
+    }
+    return formatHour(predictedTime);
+}
+function predict12Hours(parsedTime, currentHour) {
+    /**
+     * We need to predict what the user wants when they type 1 since it could be
+     * 10, 11, 12, or 1.
+     *
+     * If the current hour is over 12PM, we can skip this and go to the next logic.
+     */
+    if (parsedTime === 1 && currentHour < 12) {
+        if (currentHour < 10) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 1-5 predicts that the user want that exact hour on the afternoon.
+     */
+    if (parsedTime <= 5) {
+        return parsedTime + 12;
+    }
+    /**
+     * Typing 13-15 predicts that the user want the 2nd number as the minute interval.
+     */
+    if (parsedTime > 12 && parsedTime <= 15) {
+        const timeArray = parsedTime.toString().split("").map(Number); // 13 -> [1, 3]
+        const convertToHoursAndMinutes = timeArray.map((time, i) => {
+            if (i === 0)
+                return time + 12; // 1 -> 13 as 1PM
+            if (i === 1)
+                return time * 10; // 3 -> 30 as 30 minutes
+        });
+        return Number(convertToHoursAndMinutes.join("")); // [13, 30] -> 1330
+    }
+    /**
+     * Anything after 5 will be predicted to be set as AM.
+     */
+    return parsedTime;
+}
+function predict24Hours(time, parsedTime, currentHour) {
+    /**
+     * Typing 1 could be predicted from 10 to 19.
+     * Typing 01 skips this logic and sets the time to 01:00.
+     */
+    if (parsedTime === 1 && time !== "01") {
+        if (currentHour < 10 || currentHour > 19) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 2 could be predicted from 20 to 24.
+     * Typing 02 skips this logic and sets the time to 02:00.
+     */
+    if (parsedTime === 2 && time !== "02") {
+        if (currentHour < 20) {
+            return 20;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 24 or 00 is set to midnight. This ensures the time doesn't get set
+     * to 24 as that would be invalid.
+     */
+    if (parsedTime === 24 || time === "00") {
+        return 0;
+    }
+    return parsedTime;
+}
+function formatHour(time) {
+    if (time > 99) {
+        const splitTime = time.toString().split("");
+        if (splitTime.length === 3)
+            splitTime.unshift("0"); // 130 -> 0130
+        splitTime.splice(2, 0, ":"); // 0130 -> 01:30
+        return splitTime.join("");
+    }
+    if (time < 10) {
+        return `0${time}:00`;
+    }
+    return `${time}:00`;
+}
+
+function InputTime(_a) {
+    var { defaultValue, value, onChange } = _a, params = __rest(_a, ["defaultValue", "value", "onChange"]);
+    const ref = useRef(null);
+    const { setTypedTime } = useTimePredict({ value, handleChange });
+    const fieldProps = Object.assign(Object.assign(Object.assign({ onChange: handleChange }, (defaultValue && { defaultValue: civilTimeToHTMLTime(defaultValue) })), (!defaultValue && { value: civilTimeToHTMLTime(value) })), params);
+    return (React.createElement(FormField, Object.assign({ inputRef: ref, type: "time" }, fieldProps, { onBlur: handleBlur, onKeyUp: e => {
+            var _a;
+            (_a = fieldProps.onKeyUp) === null || _a === void 0 ? void 0 : _a.call(fieldProps, e);
+            !isNaN(parseInt(e.key, 10)) && setTypedTime(prev => prev + e.key);
+        } })));
+    function handleChange(newValue) {
+        onChange === null || onChange === void 0 ? void 0 : onChange(htmlTimeToCivilTime(newValue));
+    }
+    function handleBlur() {
+        var _a;
+        (_a = params.onBlur) === null || _a === void 0 ? void 0 : _a.call(params);
+        // Time inputs doesn't clear the typed value when it's invalid. This should
+        // force it to reset the input value when the typed value is invalid.
+        if (ref.current) {
+            if (!ref.current.checkValidity()) {
+                ref.current.value = "";
+            }
+        }
+    }
+}
+
+export { InputTime as I };

package/dist/InputTime-ce24b2bf.js

@@ -0,0 +1,194 @@
+'use strict';
+
+var tslib_es6 = require('./tslib.es6-754e2961.js');
+var React = require('react');
+var temporal = require('@std-proposal/temporal');
+var debounce = require('lodash/debounce');
+var FormField = require('./FormField-6ff183f8.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var debounce__default = /*#__PURE__*/_interopDefaultLegacy(debounce);
+
+function civilTimeToHTMLTime(civilTime) {
+    if (civilTime == undefined) {
+        return "";
+    }
+    const timeString = civilTime.toString();
+    return timeString.slice(0, 5);
+}
+function htmlTimeToCivilTime(timeString) {
+    try {
+        return temporal.CivilTime.fromString(timeString + ":00.000000000");
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+
+const DEBOUNCE_TIME = 300;
+function useTimePredict({ value, handleChange }) {
+    const IS_12_HOUR_FORMAT = React.useRef(Intl.DateTimeFormat(navigator.language, {
+        hour: "numeric",
+    }).resolvedOptions().hour12);
+    const [typedTime, setTypedTime] = React.useState("");
+    const predictTime = React.useCallback(debounce__default["default"](() => {
+        if (value)
+            return;
+        handleChange(predictHours(typedTime, IS_12_HOUR_FORMAT.current));
+    }, DEBOUNCE_TIME), [typedTime, value, handleChange]);
+    /**
+     * Predict the hour when user types a number
+     */
+    React.useEffect(() => {
+        /**
+         * Don't try to predict if the user types 0 as the user would almost always
+         * type another number after 0.
+         */
+        if (typedTime && typedTime !== "0") {
+            predictTime();
+            if ((IS_12_HOUR_FORMAT && typedTime !== "1") || typedTime.length === 2) {
+                // Immediately predict the hour
+                predictTime.flush();
+            }
+        }
+        return predictTime.cancel;
+    }, [typedTime]);
+    /**
+     * Reset typed time when the value changed
+     */
+    React.useEffect(() => {
+        setTypedTime("");
+    }, [value]);
+    return {
+        setTypedTime,
+    };
+}
+function predictHours(time, is12HourFormat = false) {
+    const today = new Date();
+    const currentHour = today.getHours();
+    const parsedTime = parseInt(time, 10);
+    let predictedTime;
+    if (is12HourFormat) {
+        predictedTime = predict12Hours(parsedTime, currentHour);
+    }
+    else {
+        predictedTime = predict24Hours(time, parsedTime, currentHour);
+    }
+    return formatHour(predictedTime);
+}
+function predict12Hours(parsedTime, currentHour) {
+    /**
+     * We need to predict what the user wants when they type 1 since it could be
+     * 10, 11, 12, or 1.
+     *
+     * If the current hour is over 12PM, we can skip this and go to the next logic.
+     */
+    if (parsedTime === 1 && currentHour < 12) {
+        if (currentHour < 10) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 1-5 predicts that the user want that exact hour on the afternoon.
+     */
+    if (parsedTime <= 5) {
+        return parsedTime + 12;
+    }
+    /**
+     * Typing 13-15 predicts that the user want the 2nd number as the minute interval.
+     */
+    if (parsedTime > 12 && parsedTime <= 15) {
+        const timeArray = parsedTime.toString().split("").map(Number); // 13 -> [1, 3]
+        const convertToHoursAndMinutes = timeArray.map((time, i) => {
+            if (i === 0)
+                return time + 12; // 1 -> 13 as 1PM
+            if (i === 1)
+                return time * 10; // 3 -> 30 as 30 minutes
+        });
+        return Number(convertToHoursAndMinutes.join("")); // [13, 30] -> 1330
+    }
+    /**
+     * Anything after 5 will be predicted to be set as AM.
+     */
+    return parsedTime;
+}
+function predict24Hours(time, parsedTime, currentHour) {
+    /**
+     * Typing 1 could be predicted from 10 to 19.
+     * Typing 01 skips this logic and sets the time to 01:00.
+     */
+    if (parsedTime === 1 && time !== "01") {
+        if (currentHour < 10 || currentHour > 19) {
+            return 10;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 2 could be predicted from 20 to 24.
+     * Typing 02 skips this logic and sets the time to 02:00.
+     */
+    if (parsedTime === 2 && time !== "02") {
+        if (currentHour < 20) {
+            return 20;
+        }
+        else {
+            return currentHour + 1;
+        }
+    }
+    /**
+     * Typing 24 or 00 is set to midnight. This ensures the time doesn't get set
+     * to 24 as that would be invalid.
+     */
+    if (parsedTime === 24 || time === "00") {
+        return 0;
+    }
+    return parsedTime;
+}
+function formatHour(time) {
+    if (time > 99) {
+        const splitTime = time.toString().split("");
+        if (splitTime.length === 3)
+            splitTime.unshift("0"); // 130 -> 0130
+        splitTime.splice(2, 0, ":"); // 0130 -> 01:30
+        return splitTime.join("");
+    }
+    if (time < 10) {
+        return `0${time}:00`;
+    }
+    return `${time}:00`;
+}
+
+function InputTime(_a) {
+    var { defaultValue, value, onChange } = _a, params = tslib_es6.__rest(_a, ["defaultValue", "value", "onChange"]);
+    const ref = React.useRef(null);
+    const { setTypedTime } = useTimePredict({ value, handleChange });
+    const fieldProps = Object.assign(Object.assign(Object.assign({ onChange: handleChange }, (defaultValue && { defaultValue: civilTimeToHTMLTime(defaultValue) })), (!defaultValue && { value: civilTimeToHTMLTime(value) })), params);
+    return (React__default["default"].createElement(FormField.FormField, Object.assign({ inputRef: ref, type: "time" }, fieldProps, { onBlur: handleBlur, onKeyUp: e => {
+            var _a;
+            (_a = fieldProps.onKeyUp) === null || _a === void 0 ? void 0 : _a.call(fieldProps, e);
+            !isNaN(parseInt(e.key, 10)) && setTypedTime(prev => prev + e.key);
+        } })));
+    function handleChange(newValue) {
+        onChange === null || onChange === void 0 ? void 0 : onChange(htmlTimeToCivilTime(newValue));
+    }
+    function handleBlur() {
+        var _a;
+        (_a = params.onBlur) === null || _a === void 0 ? void 0 : _a.call(params);
+        // Time inputs doesn't clear the typed value when it's invalid. This should
+        // force it to reset the input value when the typed value is invalid.
+        if (ref.current) {
+            if (!ref.current.checkValidity()) {
+                ref.current.value = "";
+            }
+        }
+    }
+}
+
+exports.InputTime = InputTime;

package/dist/InputValidation/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var InputValidation = require('../InputValidation-05e839fa.js');
+require('react');
+require('framer-motion');
+require('../style-inject.es-9d2f5f4e.js');
+require('../Text-259af966.js');
+require('../Typography-c45bf216.js');
+require('classnames');
+require('../Icon-405a216c.js');
+require('@jobber/design');
+
+
+
+exports.InputValidation = InputValidation.InputValidation;

package/dist/InputValidation/index.mjs

@@ -0,0 +1,9 @@
+export { I as InputValidation } from '../InputValidation-d68fb034.js';
+import 'react';
+import 'framer-motion';
+import '../style-inject.es-a0e1a0ba.js';
+import '../Text-c9162504.js';
+import '../Typography-7cc5daf5.js';
+import 'classnames';
+import '../Icon-22723fe6.js';
+import '@jobber/design';

package/dist/InputValidation-05e839fa.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var React = require('react');
+var framerMotion = require('framer-motion');
+var styleInject_es = require('./style-inject.es-9d2f5f4e.js');
+var Text = require('./Text-259af966.js');
+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);
+
+var css_248z = ".sc-bFJieXBA- {\n  margin-top: calc(16px / 4);\n  margin-top: var(--space-smaller);\n}\n\n.xybhC5Y6mk4- {\n  display: -ms-flexbox;\n  display: flex;\n  -ms-flex-align: center;\n      align-items: center;\n  padding: calc(16px / 4);\n  padding: var(--space-smaller);\n  padding-left: 0;\n}\n\n.xybhC5Y6mk4- > svg {\n  margin-right: calc(16px / 4);\n  margin-right: var(--space-smaller);\n  -ms-flex-negative: 0;\n      flex-shrink: 0;\n  -ms-flex-item-align: start;\n      align-self: flex-start;\n}\n\n.xybhC5Y6mk4-:focus {\n  box-shadow: 0px 0px 0px calc(16px / 8) rgba(255, 255, 255, 1),\n    0px 0px 0px calc(16px / 4) rgb(147, 161, 169);\n  box-shadow: var(--shadow-focus);\n  outline: none;\n}\n";
+var styles = {"hasValidationMessage":"sc-bFJieXBA-","message":"xybhC5Y6mk4-"};
+styleInject_es.styleInject(css_248z);
+
+function InputValidation({ message }) {
+    const messages = [message];
+    const variants = {
+        slideOut: { y: "5%", opacity: 0 },
+        slideIn: { y: 0, opacity: 1 },
+    };
+    return (React__default["default"].createElement(React__default["default"].Fragment, null, messages && messages.length > 0 && (React__default["default"].createElement(framerMotion.AnimatePresence, { mode: "wait" }, messages.map(msg => (React__default["default"].createElement(framerMotion.motion.div, { key: `validation-${msg}`, variants: variants, initial: "slideOut", animate: "slideIn", exit: "slideOut", transition: { duration: 0.2 } },
+        React__default["default"].createElement("div", { className: styles.message, "aria-live": "assertive", role: "alert", tabIndex: 0 },
+            React__default["default"].createElement(Icon.Icon, { name: "alert", size: "small", color: "critical" }),
+            React__default["default"].createElement(Text.Text, { size: "small", variation: "error" }, msg)))))))));
+}
+
+exports.InputValidation = InputValidation;

package/dist/InputValidation-d68fb034.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import { AnimatePresence, motion } from 'framer-motion';
+import { s as styleInject } from './style-inject.es-a0e1a0ba.js';
+import { T as Text } from './Text-c9162504.js';
+import { I as Icon } from './Icon-22723fe6.js';
+
+var css_248z = ".sc-bFJieXBA- {\n  margin-top: calc(16px / 4);\n  margin-top: var(--space-smaller);\n}\n\n.xybhC5Y6mk4- {\n  display: -ms-flexbox;\n  display: flex;\n  -ms-flex-align: center;\n      align-items: center;\n  padding: calc(16px / 4);\n  padding: var(--space-smaller);\n  padding-left: 0;\n}\n\n.xybhC5Y6mk4- > svg {\n  margin-right: calc(16px / 4);\n  margin-right: var(--space-smaller);\n  -ms-flex-negative: 0;\n      flex-shrink: 0;\n  -ms-flex-item-align: start;\n      align-self: flex-start;\n}\n\n.xybhC5Y6mk4-:focus {\n  box-shadow: 0px 0px 0px calc(16px / 8) rgba(255, 255, 255, 1),\n    0px 0px 0px calc(16px / 4) rgb(147, 161, 169);\n  box-shadow: var(--shadow-focus);\n  outline: none;\n}\n";
+var styles = {"hasValidationMessage":"sc-bFJieXBA-","message":"xybhC5Y6mk4-"};
+styleInject(css_248z);
+
+function InputValidation({ message }) {
+    const messages = [message];
+    const variants = {
+        slideOut: { y: "5%", opacity: 0 },
+        slideIn: { y: 0, opacity: 1 },
+    };
+    return (React.createElement(React.Fragment, null, messages && messages.length > 0 && (React.createElement(AnimatePresence, { mode: "wait" }, messages.map(msg => (React.createElement(motion.div, { key: `validation-${msg}`, variants: variants, initial: "slideOut", animate: "slideIn", exit: "slideOut", transition: { duration: 0.2 } },
+        React.createElement("div", { className: styles.message, "aria-live": "assertive", role: "alert", tabIndex: 0 },
+            React.createElement(Icon, { name: "alert", size: "small", color: "critical" }),
+            React.createElement(Text, { size: "small", variation: "error" }, msg)))))))));
+}
+
+export { InputValidation as I };