@arquimedes.co/eureka-forms 3.0.31 → 3.0.32

package/dist/Shared/RoundedDatePicker/RoundedDatePicker.stories.js

@@ -0,0 +1,223 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useArgs } from '@storybook/preview-api';
+import RoundedDatePicker from './RoundedDatePicker';
+import { within, screen } from '@storybook/testing-library';
+import { userEvent } from '@storybook/testing-library';
+var meta = {
+    component: RoundedDatePicker,
+    tags: ['autodocs'],
+    args: {
+        focusColor: '#3d5a7f',
+        secondaryColor: '#98c1d9',
+        helperTextColor: '#989898',
+        outlineColor: '#0000003b',
+        backgroundColor: '#ffffff',
+        textColor: '#293241',
+        contrastColor: '#ee6c4d',
+        accentColor: '#293241',
+        errorColor: '#cc2936',
+        fontSize: '1rem',
+        fontWeight: '300',
+        cantEdit: false,
+    },
+    parameters: {
+        date: new Date('07-21-2021'),
+    },
+};
+export default meta;
+export var Empty = {
+    args: {
+        value: null,
+    },
+};
+export var Default = {
+    args: {
+        label: 'Label',
+        value: new Date('07-21-2021'),
+    },
+};
+export var ValueAndLabel = {
+    args: {
+        label: 'Label',
+        value: null,
+    },
+    render: function Component(args) {
+        var _a = useArgs(), setArgs = _a[1];
+        var onValueChange = function (value) {
+            var _a;
+            (_a = args.onChange) === null || _a === void 0 ? void 0 : _a.call(args, value);
+            setArgs({ value: value });
+        };
+        return (_jsx(RoundedDatePicker, __assign({}, args, { ref: args.ref, onChange: onValueChange })));
+    },
+};
+export var Full = {
+    args: {
+        label: 'Label',
+        value: null,
+        helperText: 'Helper text',
+    },
+};
+export var FullDateTime = {
+    args: {
+        label: 'Label',
+        value: null,
+        helperText: 'Helper text',
+        pickTime: true,
+    },
+};
+export var Error = {
+    args: {
+        label: 'Label',
+        value: null,
+        helperText: 'Helper text',
+        error: true,
+    },
+};
+export var Menu = {
+    args: {
+        label: 'Label',
+        value: null,
+    },
+    play: function (_a) {
+        var canvasElement = _a.canvasElement;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var canvas, selector;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        canvas = within(canvasElement);
+                        selector = canvas.getByTestId('date-picker');
+                        return [4 /*yield*/, userEvent.click(selector)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    },
+};
+export var DateTimeDateMenu = {
+    args: {
+        label: 'Label',
+        value: null,
+        pickTime: true,
+    },
+    play: function (_a) {
+        var canvasElement = _a.canvasElement;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var canvas, selector;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        canvas = within(canvasElement);
+                        selector = canvas.getByTestId('date-picker');
+                        return [4 /*yield*/, userEvent.click(selector)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    },
+};
+export var DateTimeTimeMenu = {
+    args: {
+        label: 'Label',
+        value: null,
+        pickTime: true,
+    },
+    play: function (_a) {
+        var canvasElement = _a.canvasElement;
+        return __awaiter(void 0, void 0, void 0, function () {
+            var canvas, selector, time;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        canvas = within(canvasElement);
+                        selector = canvas.getByTestId('date-picker');
+                        return [4 /*yield*/, userEvent.click(selector)];
+                    case 1:
+                        _b.sent();
+                        time = screen.getByText('12', {
+                            selector: 'h3',
+                        });
+                        return [4 /*yield*/, userEvent.click(time)];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    },
+};
+export var ErrorColor = {
+    args: {
+        label: 'Label',
+        value: null,
+        helperText: 'Helper text',
+        error: true,
+        errorColor: 'blue',
+    },
+};
+export var DifferentColors = {
+    args: {
+        label: 'Label',
+        value: null,
+        helperText: 'Helper text',
+        helperTextColor: 'green',
+        outlineColor: 'purple',
+        backgroundColor: 'red',
+        textColor: 'blue',
+    },
+    render: function Component(args) {
+        return _jsx(RoundedDatePicker, __assign({}, args, { ref: args.ref }));
+    },
+};

package/dist/Shared/RoundedPhoneInput/RoundedPhoneInput.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { TextFieldProps } from '@material-ui/core/TextField';
+interface StyleProps {
+    /** The color of the text */
+    textColor?: string;
+    /** The color of the outline when selected and hovered on */
+    focusColor?: string;
+    /** The color of the error to display */
+    errorColor?: string;
+    /** The color of the outline when it is not selected */
+    outlineColor?: string;
+    /** The backgroundColor of the input */
+    backgroundColor?: string;
+    /** The borderRadius of the input */
+    borderRadius?: number;
+    /** If input is readOnly */
+    readOnly?: boolean;
+    /** The padding of the input */
+    padding?: string;
+    /** The size of the font to display the input in */
+    fontSize?: number | string;
+    /** The weight of the font of the value and the placeholder */
+    fontWeight?: number | string;
+    /** Cant edit */
+    cantEdit?: boolean;
+    /** The color of the helper text when not error */
+    helperTextColor?: string;
+    /** The max length of the string */
+    maxLength?: number;
+}
+interface RoundedPhoneInputProps extends StyleProps {
+    /** The value of the phoneinput */
+    value?: string;
+    onChange: (value: string) => void;
+    inputRef?: any;
+}
+/**
+ * Generic phoneinput with apps designs. Is class due to the use in the react-hook-forms library
+ */
+declare class RoundedPhoneInput extends React.Component<RoundedPhoneInputProps & Omit<TextFieldProps, 'onChange'>> {
+    render(): JSX.Element;
+}
+export default RoundedPhoneInput;

package/dist/Shared/RoundedPhoneInput/RoundedPhoneInput.js

@@ -0,0 +1,226 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useMemo } from 'react';
+import { makeStyles } from '@material-ui/core/styles';
+import TextField from '@material-ui/core/TextField';
+import { InputAdornment, MenuItem, Select } from '@material-ui/core';
+import parse from 'libphonenumber-js/max';
+import { defaultCountries, FlagImage, parseCountry, usePhoneInput, } from 'react-international-phone';
+import { useAppSelector } from '../../hooks';
+import isoCountries from 'i18n-iso-countries';
+import es from 'i18n-iso-countries/langs/es.json';
+isoCountries.registerLocale(es);
+var useTextfieldStyles = function (props) {
+    return makeStyles(function () { return ({
+        root: {
+            borderRadius: props.borderRadius,
+            '& input': {
+                cursor: props.cantEdit ? 'default' : 'text',
+                padding: props.padding,
+                fontWeight: props.fontWeight,
+                color: props.textColor,
+                fontSize: props.fontSize,
+                '&::placeholder': {
+                    fontSize: props.fontSize,
+                },
+                backgroundColor: props.backgroundColor,
+                borderRadius: props.borderRadius,
+            },
+            '& label': {
+                marginTop: '-4px',
+                fontSize: props.fontSize,
+                color: props.textColor + '8a',
+                whiteSpace: 'nowrap',
+                overflow: 'hidden',
+                textOverflow: 'ellipsis',
+                maxWidth: 'calc(100% - 22px)',
+            },
+            '& label.EF-MuiInputLabel-shrink': {
+                marginTop: '0px',
+                maxWidth: 'calc(100% - 5px)',
+            },
+            '& input + fieldset': {
+                borderRadius: props.borderRadius,
+            },
+            '& .EF-MuiInput-underline:after': {
+                borderBottomColor: props.outlineColor,
+            },
+            '& .EF-MuiOutlinedInput-root': {
+                borderRadius: props.borderRadius,
+                '&.Mui-focused fieldset': {
+                    borderColor: props.focusColor,
+                    borderWidth: props.readOnly ? 1 : 2,
+                },
+                '& .EF-MuiOutlinedInput-notchedOutline': {
+                    borderColor: props.outlineColor,
+                    '& legend': {
+                        fontSize: 'calc(' + props.fontSize + ' * 0.75)',
+                    },
+                },
+            },
+            '& .EF-MuiOutlinedInput-root:hover .EF-MuiOutlinedInput-notchedOutline': {
+                borderColor: props.cantEdit
+                    ? props.outlineColor
+                    : props.focusColor,
+            },
+            '& label.Mui-focused': {
+                color: props.focusColor,
+            },
+            '& .Mui-error': {
+                color: props.errorColor,
+            },
+            '& .EF-MuiOutlinedInput-adornedEnd': {
+                paddingRight: '7px',
+            },
+            '& .EF-MuiFormHelperText-root': {
+                color: props.helperTextColor,
+                position: 'relative',
+                marginRight: props.maxLength ? 40 : 14,
+            },
+            '& .EF-MuiFormHelperText-root.Mui-error': {
+                color: props.errorColor,
+            },
+            '& .EF-MuiInputAdornment-root': {
+                paddingTop: 2,
+                marginRight: 0,
+                '& .EF-MuiSelect-select': {
+                    backgroundColor: props.backgroundColor,
+                },
+                '& input': {
+                    padding: 0,
+                    margin: 0,
+                },
+                '& .EF-MuiInput-underline:before': {
+                    borderBottom: 'none !important',
+                },
+                '& .EF-MuiInput-underline:after': {
+                    borderBottom: 'none',
+                },
+            },
+        },
+    }); });
+};
+var useCountrySelectStyles = makeStyles(function () { return ({
+    root: {
+        padding: 0,
+        input: {
+            padding: 0,
+        },
+    },
+}); });
+function CustomPhoneInput(_a) {
+    var _b = _a.focusColor, focusColor = _b === void 0 ? '#3d5a7f' : _b, _c = _a.helperTextColor, helperTextColor = _c === void 0 ? '#989898' : _c, _d = _a.outlineColor, outlineColor = _d === void 0 ? '#0000003b' : _d, _e = _a.backgroundColor, backgroundColor = _e === void 0 ? 'white' : _e, _f = _a.textColor, textColor = _f === void 0 ? '#293241' : _f, _g = _a.readOnly, readOnly = _g === void 0 ? false : _g, _h = _a.borderRadius, borderRadius = _h === void 0 ? 10 : _h, _j = _a.padding, padding = _j === void 0 ? '6px 12px 6px 6px' : _j, _k = _a.fontSize, fontSize = _k === void 0 ? '1rem' : _k, _l = _a.errorColor, errorColor = _l === void 0 ? '#cc2936' : _l, _m = _a.fontWeight, fontWeight = _m === void 0 ? '300' : _m, _o = _a.cantEdit, cantEdit = _o === void 0 ? false : _o, value = _a.value, onChange = _a.onChange, inputRef = _a.inputRef, others = __rest(_a, ["focusColor", "helperTextColor", "outlineColor", "backgroundColor", "textColor", "readOnly", "borderRadius", "padding", "fontSize", "errorColor", "fontWeight", "cantEdit", "value", "onChange", "inputRef"]);
+    var classes = useTextfieldStyles({
+        padding: padding,
+        textColor: textColor,
+        errorColor: errorColor,
+        focusColor: focusColor,
+        outlineColor: outlineColor,
+        helperTextColor: helperTextColor,
+        backgroundColor: backgroundColor,
+        borderRadius: borderRadius,
+        readOnly: readOnly,
+        fontSize: fontSize,
+        fontWeight: fontWeight,
+        cantEdit: cantEdit,
+    })();
+    var defaultCountry = useAppSelector(function (state) { return state.global.countryCode; });
+    var countrySelectClasses = useCountrySelectStyles();
+    var _p = usePhoneInput({
+        value: '+' + value,
+        inputRef: inputRef,
+        defaultCountry: defaultCountry.toLowerCase(),
+        disableDialCodePrefill: true,
+        disableDialCodeAndPrefix: true,
+        onChange: function (data) { return onChange(data.phone.replace('+', '')); },
+    }), inputValue = _p.inputValue, handlePhoneValueChange = _p.handlePhoneValueChange, phoneRef = _p.inputRef, country = _p.country, setCountry = _p.setCountry;
+    var countries = useMemo(function () {
+        return defaultCountries
+            .map(function (c) {
+            var _a;
+            var country = parseCountry(c);
+            return {
+                country: country,
+                name: (_a = isoCountries.getName(country.iso2.toUpperCase(), 'es')) !== null && _a !== void 0 ? _a : country.name,
+            };
+        })
+            .sort(function (a, b) { return a.name.localeCompare(b.name); });
+    }, []);
+    return (_jsx(TextField, __assign({ classes: classes }, others, { variant: "outlined", size: "small", fullWidth: true, value: inputValue, onChange: handlePhoneValueChange, type: "tel", onPaste: function (e) {
+            var value = e.clipboardData.getData('Text');
+            if (!value.startsWith('+')) {
+                var phone = parse('+' + value);
+                if (phone === null || phone === void 0 ? void 0 : phone.isValid()) {
+                    e.preventDefault();
+                    if (phone.country)
+                        setCountry(phone.country.toLowerCase());
+                    onChange(phone.number);
+                }
+            }
+        }, inputRef: phoneRef, InputProps: {
+            readOnly: readOnly,
+            autoComplete: 'tel',
+            disabled: cantEdit,
+            startAdornment: (_jsx(InputAdornment, __assign({ position: "start", style: {
+                    borderBottom: 'none',
+                } }, { children: _jsx(Select, __assign({ classes: countrySelectClasses, value: country.iso2, onChange: function (e) {
+                        return setCountry(e.target.value);
+                    }, inputProps: { disabled: cantEdit }, renderValue: function (value) { return (_jsx(FlagImage, { iso2: value, style: { display: 'flex' }, width: 20 })); } }, { children: countries.map(function (_a) {
+                        var country = _a.country, name = _a.name;
+                        return (_jsxs(MenuItem, __assign({ value: country.iso2 }, { children: [_jsx(FlagImage, { iso2: country.iso2, size: 20 }), _jsx("span", __assign({ style: {
+                                        marginLeft: '8px',
+                                        marginRight: '8px',
+                                    } }, { children: name })), _jsxs("span", __assign({ style: { color: 'grey' } }, { children: ["+", country.dialCode] }))] }), country.iso2));
+                    }) })) }))),
+        } })));
+}
+/**
+ * Generic phoneinput with apps designs. Is class due to the use in the react-hook-forms library
+ */
+var RoundedPhoneInput = /** @class */ (function (_super) {
+    __extends(RoundedPhoneInput, _super);
+    function RoundedPhoneInput() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RoundedPhoneInput.prototype.render = function () {
+        return _jsx(CustomPhoneInput, __assign({}, this.props));
+    };
+    return RoundedPhoneInput;
+}(React.Component));
+export default RoundedPhoneInput;

package/dist/Shared/RoundedSelect/RoundedSelect.d.ts

@@ -0,0 +1,68 @@
+import React from 'react';
+import { SelectProps } from '@material-ui/core/Select';
+export interface SelectorStyleProps {
+    /** The color of the outline when selected and hovered on */
+    focusColor?: string;
+    /** The color of the outline when it is not selected */
+    outlineColor?: string;
+    /** The color of the background  */
+    backgroundColor?: string;
+    /** The color of the error to display */
+    errorColor?: string;
+    /** If the style should change on hover */
+    cantEdit?: boolean;
+    /** The hight of the container */
+    height?: string;
+    /** The color of the text in the form */
+    color?: string;
+    /** The fontsize of the content */
+    fontSize?: string;
+    /** The weight of the font of the value and the placeholder */
+    fontWeight?: any;
+    /** If input is readOnly */
+    readOnly?: boolean;
+    /** The color of the helper text when not error */
+    helperTextColor?: string;
+    /** The borderRadius of the input */
+    borderRadius?: number;
+    /** The padding to the left of the input */
+    paddingLeft?: number;
+    /** The padding to the right of the input */
+    paddingRight?: number;
+    /** If custom icon exists and should be displayed */
+    showIcon?: boolean;
+}
+interface RoundedSelectProps extends Omit<SelectProps, 'color'>, SelectorStyleProps {
+    /** children to display in the options */
+    children?: any;
+    /** Currently selected value */
+    value: any;
+    /** function called when value changes */
+    handleUpdate?: (event: React.ChangeEvent<{
+        name?: string | undefined;
+        value: any;
+    }>, child?: React.ReactNode) => void;
+    /** String to place in the label */
+    label?: string;
+    /** Minimum width in px of the component */
+    minWidth?: number;
+    /** The color of the outline when selected and hovered on */
+    focusColor?: string;
+    /** If outline should be error color */
+    highlightError?: boolean;
+    /** The helper Text to display */
+    helperText?: string;
+    /** the margin around the selector */
+    containerMargin?: string;
+    /** The icon to display */
+    iconComponent?: any;
+    /** the components ref */
+    ref?: any;
+}
+/**
+ * Generic textfield with apps designs. Is class due to the use in the react-hook-forms library
+ */
+declare class RoundedSelect extends React.Component<RoundedSelectProps> {
+    render(): JSX.Element;
+}
+export default RoundedSelect;