@arquimedes.co/eureka-forms 1.9.83-test → 1.9.85-test

package/dist/FormComponents/Step/Step.js

@@ -0,0 +1,108 @@
+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 } from "react/jsx-runtime";
+import Types from '../../constants/FormStepTypes';
+import SelectorStep from './SelectorStep/SelectorStep';
+import SeparatorStep from './SeparatorStep/SeparatorStep';
+import TextInputStep from './TextInputStep/TextInputStep';
+import TitleStep from './TitleStep/TitleStep';
+import ClassifierSelectorStep from './ClassifierSelectorStep/ClassifierSelectorStep';
+import TextAreaStep from './TextAreaStep/TextAreaStep';
+import DatePickerStep from './DatePickerStep/DatePickerStep';
+import FileUploadStep from './FileUploadStep/FileUploadStep';
+import CheckBoxStep from './CheckBoxStep/MaterialCheckBoxStep/MaterialCheckBoxStep';
+import CBRStepMapper from './CBRStepMapper';
+import RatingStep from './RatingStep/RatingStep';
+import AYFStepMapper from './AYFStepMapper';
+import EntityValuePickerStep from './EntityValueStep/EntityValuePickerStep';
+import MapperStep from './MapperStep/MapperStep';
+import CollapsibleStep from './CollapsibleStep/CollapsibleStep';
+function StepComponent(_a) {
+    var _b, _c;
+    var step = _a.step, props = __rest(_a, ["step"]);
+    if (!step) {
+        console.error('Step not found!');
+        return _jsx("div", {});
+    }
+    var customStep = props.customSteps[step.type];
+    var editable = props.globalEditable ? (_b = step.editable) !== null && _b !== void 0 ? _b : true : false;
+    if ((props.postview || !editable) &&
+        (props.partial || step.partial) &&
+        props.originalValues[step.id] === undefined) {
+        return _jsx("div", {});
+    }
+    if (customStep) {
+        return customStep.component(__assign(__assign(__assign({}, props), ((_c = customStep.componentProps) !== null && _c !== void 0 ? _c : {})), { step: step, editable: editable }));
+    }
+    switch (step.type) {
+        case Types.TITLE: {
+            return (_jsx(TitleStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.SELECTOR: {
+            return (_jsx(SelectorStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.CHECKBOX: {
+            return (_jsx(CheckBoxStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.CLASSIFIER_SELECTOR: {
+            return (_jsx(ClassifierSelectorStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.TEXTAREA: {
+            return (_jsx(TextAreaStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.TEXTINPUT: {
+            return (_jsx(TextInputStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.DATEPICKER: {
+            return (_jsx(DatePickerStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.SEPARATOR: {
+            return (_jsx(SeparatorStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.FILEUPLOAD: {
+            return (_jsx(FileUploadStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.RATING: {
+            return (_jsx(RatingStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.COLLAPSIBLE: {
+            return (_jsx(CollapsibleStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.ENTITYVALUEPICKER: {
+            return (_jsx(EntityValuePickerStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        case Types.MAPPER: {
+            return (_jsx(MapperStep, __assign({}, props, { step: step, editable: editable })));
+        }
+        default:
+            break;
+    }
+    if (step.type.startsWith('CBR')) {
+        return (_jsx(CBRStepMapper, __assign({}, props, { step: step, editable: editable })));
+    }
+    else if (step.type.startsWith('AYF')) {
+        return (_jsx(AYFStepMapper, __assign({}, props, { step: step, editable: editable })));
+    }
+    return _jsx("div", {});
+}
+export default StepComponent;

package/dist/FormComponents/Step/StepFunctions.d.ts

@@ -0,0 +1,5 @@
+import { FormSize } from '../../@Types/Form';
+import { ClassifierSelector, EntityValuePicker, FormSelector, FormStep } from '../../@Types/FormStep';
+export declare function calcFillerSize(step: FormSelector | ClassifierSelector | EntityValuePicker, steps: Record<string, FormStep>, values: Record<string, unknown>, size: FormSize): number;
+export declare function recursivelyCheckOpenSize(idStep: string, steps: Record<string, FormStep>, values: Record<string, any>): number;
+export declare const calcStepWidth: (stepSize: 1 | 2 | 3 | 4, size: FormSize) => number;

package/dist/FormComponents/Step/StepFunctions.js

@@ -0,0 +1,65 @@
+import Types, { ClassifierOptionTypes, EntityValueOptionTypes, OptionTypes, } from '../../constants/FormStepTypes';
+export function calcFillerSize(step, steps, values, size) {
+    if (step.maxSize < size.blockNum) {
+        var stepSize = step.maxSize - recursivelyCheckOpenSize(step.id, steps, values);
+        return (size.blockSize * stepSize + size.spacingSize * (stepSize - 1) + 20);
+    }
+    else {
+        return 0;
+    }
+}
+export function recursivelyCheckOpenSize(idStep, steps, values) {
+    var step = steps[idStep];
+    var value = values[idStep];
+    if (step.type === Types.SELECTOR) {
+        var size = step.size;
+        if (value) {
+            var currentOption = step.options.find(function (option) { return option.value === value; });
+            if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === OptionTypes.NESTED) {
+                var optionSize = 0;
+                for (var _i = 0, _a = currentOption.steps; _i < _a.length; _i++) {
+                    var pStepId = _a[_i];
+                    optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
+                }
+                size += optionSize;
+            }
+        }
+        return size;
+    }
+    else if (step.type === Types.CLASSIFIER_SELECTOR) {
+        var size = step.size;
+        if (value) {
+            var currentOption = step.options[value];
+            if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === ClassifierOptionTypes.NESTED) {
+                var optionSize = 0;
+                for (var _b = 0, _c = currentOption.steps; _b < _c.length; _b++) {
+                    var pStepId = _c[_b];
+                    optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
+                }
+                size += optionSize;
+            }
+        }
+        return size;
+    }
+    if (step.type === Types.ENTITYVALUEPICKER) {
+        var size = step.size;
+        if (value) {
+            var currentOption = step.options[value];
+            if ((currentOption === null || currentOption === void 0 ? void 0 : currentOption.type) === EntityValueOptionTypes.NESTED) {
+                var optionSize = 0;
+                for (var _d = 0, _e = currentOption.steps; _d < _e.length; _d++) {
+                    var pStepId = _e[_d];
+                    optionSize += recursivelyCheckOpenSize(pStepId, steps, values);
+                }
+                size += optionSize;
+            }
+        }
+        return size;
+    }
+    else {
+        return 4;
+    }
+}
+export var calcStepWidth = function (stepSize, size) {
+    return size.blockSize * stepSize + size.spacingSize * (stepSize - 1);
+};

package/dist/FormComponents/Step/TextAreaStep/MaterialTextAreaStep/DraftEditor.css

@@ -0,0 +1,96 @@
+.EF-DraftContainer {
+    font: inherit;
+    font-size: 1rem;
+}
+.postview-editor {
+    cursor: default !important;
+}
+.EF-DraftContainer .DraftEditor-root {
+    height: unset;
+}
+
+.EF-DraftContainer .rdw-option-wrapper {
+    border-radius: 7px;
+    border: 1px solid var(--eureka-outline);
+    background-color: transparent;
+}
+
+.EF-DraftContainer .rdw-option-wrapper:active {
+    border: 1px solid var(--eureka-primary);
+}
+.EF-DraftContainer .rdw-option-wrapper:hover {
+    box-shadow: none;
+    border: 1px solid var(--eureka-primary);
+}
+
+.EF-DraftContainer .rdw-option-active {
+    border: 1px solid var(--eureka-primary);
+    box-shadow: none;
+}
+
+.EF-DraftContainer .rdw-editor-toolbar {
+    border-radius: 15px 15px 0 0;
+    border: none;
+    border-bottom: 1px solid var(--eureka-outline);
+    background-color: transparent;
+}
+
+.postview-editor-toolbar {
+    pointer-events: none;
+}
+
+.EF-DraftContainer .rdw-editor-main {
+    cursor: text;
+    padding-top: 12px;
+    padding-bottom: 40px;
+    margin-right: 0px;
+}
+
+.EF-DraftContainer .public-DraftStyleDefault-block {
+    margin: 0px 0;
+    max-width: 100%;
+}
+
+.EF-DraftContainer .rdw-image-imagewrapper {
+    max-width: 100%;
+    /* cursor: pointer; */
+    position: relative;
+}
+
+.EF-DraftContainer .rdw-image-alignment-editor {
+    padding-right: 10px;
+    padding-left: 5px;
+    margin-left: -5px;
+}
+.EF-DraftContainer .rdw-editing-image {
+    border: 1px solid var(--secondary);
+}
+
+.EF-DraftContainer .DraftEditor-root figure {
+    margin: 0px;
+}
+
+.EF-DraftContainer .rdw-image-alignment-option {
+    font-size: 16px !important;
+    width: 20px;
+    height: 20px;
+    margin-left: 2px;
+    border-radius: 2px;
+
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border: 1px solid var(--light-grey);
+}
+
+.EF-DraftContainer .rdw-image-alignment-options-popup {
+    width: fit-content;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.6);
+}
+
+/* Hides empty placeholder */
+.EF-DraftContainer
+    .RichEditor-hidePlaceholder
+    .public-DraftEditorPlaceholder-root {
+    display: none;
+}

package/dist/FormComponents/Step/TextAreaStep/MaterialTextAreaStep/MaterialTextAreaStep.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
+import './DraftEditor.css';
+import { RawDraftContentState } from 'draft-js';
+import { TextAreaStepProps } from '../TextAreaStep';
+export interface Payload {
+    text: string;
+    draft: any;
+}
+declare function TextAreaStep({ step, errors, partial, control, editable, postview, formStyle, maxLength, originalValues, }: TextAreaStepProps): JSX.Element;
+export default TextAreaStep;
+export declare function stringToDraft(text: string): RawDraftContentState;
+export declare const getRawText: (draft?: RawDraftContentState, text?: string) => RawDraftContentState;

package/dist/FormComponents/Step/TextAreaStep/MaterialTextAreaStep/MaterialTextAreaStep.js

@@ -0,0 +1,213 @@
+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 { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import RoundedTextField from '../../../../shared/RoundedTextField/RoundedTextField';
+import styles from './MaterialTextAreaStep.module.css';
+import { Controller } from 'react-hook-form';
+import { Editor } from 'react-draft-wysiwyg'; //Load programatically only if step has editor
+import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
+import './DraftEditor.css';
+import { EditorState } from 'draft-js';
+import React, { useState } from 'react';
+import { ClickAwayListener } from '@material-ui/core';
+function TextAreaStep(_a) {
+    var step = _a.step, errors = _a.errors, partial = _a.partial, control = _a.control, editable = _a.editable, postview = _a.postview, formStyle = _a.formStyle, maxLength = _a.maxLength, originalValues = _a.originalValues;
+    var _b = useState(false), hovering = _b[0], setHovering = _b[1];
+    var _c = useState(false), focus = _c[0], setFocus = _c[1];
+    var calcStyle = function () {
+        var backgroundColor = formStyle.stepBackgroundColor;
+        if (focus) {
+            return {
+                border: '2px solid ' + formStyle.primaryColor,
+                marginTop: -1,
+                marginLeft: -1,
+                marginBottom: 0,
+                backgroundColor: backgroundColor,
+            };
+        }
+        else if (hovering) {
+            return {
+                border: '1px solid ' + formStyle.primaryColor,
+                backgroundColor: backgroundColor,
+            };
+        }
+        else {
+            return {
+                border: '1px solid ' + formStyle.outlineColor,
+                backgroundColor: backgroundColor,
+            };
+        }
+    };
+    var calcDefaultStringValue = function (defaultValue) {
+        var _a;
+        if (typeof defaultValue === 'string') {
+            return defaultValue;
+        }
+        else {
+            return (_a = defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue.text) !== null && _a !== void 0 ? _a : '';
+        }
+    };
+    var canEdit = editable && !postview;
+    if (step.hasTextEditor) {
+        return (_jsxs("div", __assign({ className: styles.textEditorContainer, style: {
+                '--eureka-outline': formStyle.outlineColor,
+                '--eureka-primary': formStyle.primaryColor,
+            } }, { children: [step.label && (_jsxs("div", __assign({ className: styles.textEditorLabel, style: {
+                        color: !!errors[step.id]
+                            ? formStyle.errorColor
+                            : formStyle.textColor,
+                    } }, { children: [step.label, " ", step.required ? ' *' : ''] }))), _jsx(ClickAwayListener, __assign({ mouseEvent: "onMouseDown", onClickAway: function () {
+                        if (canEdit) {
+                            setFocus(false);
+                        }
+                    } }, { children: _jsx("div", __assign({ className: postview
+                            ? styles.postViewContainer +
+                                ' EF-DraftContainer'
+                            : styles.textContainer + ' EF-DraftContainer', "data-testid": step.id, style: calcStyle(), onMouseEnter: function () {
+                            if (canEdit) {
+                                setHovering(true);
+                            }
+                        }, onMouseLeave: function () {
+                            if (canEdit) {
+                                setHovering(false);
+                            }
+                        }, onClick: function () {
+                            if (canEdit) {
+                                setFocus(true);
+                            }
+                        } }, { children: _jsx(Controller, { name: step.id, control: control, defaultValue: EditorState.createEmpty(), rules: step.required
+                                ? {
+                                    validate: function (editorState) {
+                                        return editorState
+                                            .getCurrentContent()
+                                            .hasText();
+                                    },
+                                }
+                                : {}, shouldUnregister: true, render: function (_a) {
+                                var _b;
+                                var field = _a.field;
+                                var editorClassName = styles.editor;
+                                if (!field.value.getCurrentContent().hasText()) {
+                                    if (field.value
+                                        .getCurrentContent()
+                                        .getBlockMap()
+                                        .first()
+                                        .getType() !== 'unstyled') {
+                                        editorClassName +=
+                                            ' RichEditor-hidePlaceholder';
+                                    }
+                                }
+                                if (!canEdit) {
+                                    editorClassName += ' postview-editor';
+                                }
+                                return (_jsx(Editor, { editorRef: field.ref, onFocus: function () {
+                                        setFocus(true);
+                                    }, readOnly: !canEdit, onBlur: field.onBlur, stripPastedStyles: true, editorState: field.value, onEditorStateChange: field.onChange, toolbarClassName: styles.toolbar +
+                                        (!canEdit
+                                            ? ' postview-editor-toolbar'
+                                            : ''), editorClassName: editorClassName, wrapperClassName: styles.wrapper, placeholder: (_b = step.description) !== null && _b !== void 0 ? _b : '', toolbar: {
+                                        options: [
+                                            'inline',
+                                            'list',
+                                            'history',
+                                        ],
+                                        inline: {
+                                            options: [
+                                                'bold',
+                                                'italic',
+                                                'underline',
+                                                'strikethrough',
+                                            ],
+                                        },
+                                        list: {
+                                            options: ['unordered'],
+                                        },
+                                    } }));
+                            } }) })) })), _jsx("div", __assign({ className: styles.errorMsg, style: {
+                        color: formStyle.errorColor,
+                    } }, { children: !!errors[step.id] && 'Este campo es obligatorio' }))] })));
+    }
+    else {
+        return (_jsx("div", __assign({ className: styles.container, style: {
+                paddingBottom: step.required || step.description || !!errors[step.id]
+                    ? '0px'
+                    : '5px',
+            } }, { children: _jsx(Controller, { name: step.id, control: control, defaultValue: calcDefaultStringValue(originalValues[step.id]), rules: {
+                    required: step.required
+                        ? 'Este campo es obligatorio'
+                        : undefined,
+                }, shouldUnregister: true, render: function (_a) {
+                    var _b;
+                    var _c = _a.field, ref = _c.ref, field = __rest(_c, ["ref"]);
+                    return (_jsxs(React.Fragment, { children: [_jsx("div", __assign({ className: styles.erkTextArea }, { children: _jsx(RoundedTextField, __assign({}, field, { "data-testid": step.id, maxLength: maxLength, label: step.label, inputRef: ref, required: step.required, cantEdit: !canEdit, fontWeight: 400, multiline: true, minRows: postview && partial ? undefined : 4, focusColor: formStyle.primaryColor, outlineColor: formStyle.outlineColor, textColor: formStyle.textColor, errorColor: formStyle.errorColor, backgroundColor: formStyle.stepBackgroundColor, helperTextColor: formStyle.descriptionTextColor, helperText: errors[step.id]
+                                        ? errors[step.id].message
+                                        : (_b = step.description) !== null && _b !== void 0 ? _b : (step.required ? ' ' : null), error: !!errors[step.id] })) })), postview && (_jsxs("div", __assign({ className: styles.print }, { children: [_jsxs("div", { children: [step.label, ":"] }), _jsx("p", __assign({ className: styles.printContainer, style: {
+                                            backgroundColor: formStyle.stepBackgroundColor,
+                                            borderColor: formStyle.outlineColor,
+                                        } }, { children: field.value }))] })))] }));
+                } }) })));
+    }
+}
+export default TextAreaStep;
+export function stringToDraft(text) {
+    var draftStructure = {
+        blocks: [],
+        entityMap: {},
+    };
+    text.split('\n').forEach(function (element, index) {
+        draftStructure.blocks.push({
+            key: String(index),
+            text: element,
+            type: 'unstyled',
+            depth: 0,
+            inlineStyleRanges: [],
+            entityRanges: [],
+            data: {},
+        });
+    });
+    return draftStructure;
+}
+export var getRawText = function (draft, text) {
+    if (draft !== undefined) {
+        return draft;
+    }
+    else if (text !== undefined) {
+        return stringToDraft(text);
+    }
+    else {
+        return {
+            blocks: [
+                {
+                    key: 'fudmo',
+                    text: '',
+                    type: 'unstyled',
+                    depth: 0,
+                    inlineStyleRanges: [],
+                    entityRanges: [],
+                    data: {},
+                },
+            ],
+            entityMap: {},
+        };
+    }
+};

package/dist/FormComponents/Step/TextAreaStep/MaterialTextAreaStep/MaterialTextAreaStep.module.css

@@ -0,0 +1,93 @@
+.container,
+.textEditorContainer {
+    width: fit-content;
+    max-width: calc(100% - 20px);
+    display: flex;
+    flex-direction: column;
+    padding: 10px;
+    padding-top: 5px;
+    width: calc(100% - 20px);
+}
+
+.textEditorContainer {
+    max-width: '100%';
+    display: flex;
+    flex-direction: column;
+}
+.postViewContainer {
+    height: fit-content;
+    border-radius: 15px;
+    min-height: 265px;
+    width: 100%;
+    position: relative;
+    margin-bottom: 1px;
+    overflow: hidden;
+}
+.textContainer {
+    height: 100%;
+    border-radius: 15px;
+    height: 265px;
+    width: 100%;
+    position: relative;
+    margin-bottom: 1px;
+    overflow: hidden;
+}
+
+.editor {
+    margin: -5px 10px 0 10px;
+    height: calc(100% - 22px) !important;
+}
+
+.wrapper {
+    height: 100%;
+    border-radius: 15px;
+}
+
+.disabledCurtain {
+    position: absolute;
+    bottom: 0;
+    top: 0;
+    left: 0;
+    right: 0;
+    z-index: 2;
+}
+
+.errorMsg {
+    margin-top: 4px;
+    margin-bottom: 5px;
+    margin-left: 14px;
+    font-size: 0.75rem;
+    height: 0.75rem;
+}
+
+.textEditorLabel {
+    margin-left: 5px;
+    margin-bottom: 2px;
+    font-size: 1rem;
+}
+.print {
+    display: none;
+}
+.printContainer {
+    border-radius: 10px;
+    border: 1px solid black;
+    padding: 6px 12px;
+    width: calc(100% - 2);
+    font-size: 1rem;
+    min-height: 50px;
+    margin: 0px;
+}
+.erkTextArea {
+    position: relative;
+    width: 100%;
+    max-width: 100%;
+}
+
+@media print {
+    .print {
+        display: block;
+    }
+    .erkTextArea {
+        display: none !important;
+    }
+}

package/dist/FormComponents/Step/TextAreaStep/TextAreaStep.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { TextArea } from '../../../@Types/FormStep';
+import { StepProps } from '../Step';
+export interface TextAreaStepProps extends StepProps {
+    /** The TextAreaStep to display */
+    step: TextArea;
+    maxLength?: number;
+}
+declare function TextAreaStep(props: TextAreaStepProps): JSX.Element;
+export default TextAreaStep;

package/dist/FormComponents/Step/TextAreaStep/TextAreaStep.js

@@ -0,0 +1,23 @@
+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);
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormStyleTypes } from '../../../constants/FormStepTypes';
+import MaterialTextAreaStep from './MaterialTextAreaStep/MaterialTextAreaStep';
+function TextAreaStep(props) {
+    switch (props.formStyle.type) {
+        case FormStyleTypes.MATERIAL:
+        default: {
+            return _jsx(MaterialTextAreaStep, __assign({}, props));
+        }
+    }
+}
+export default TextAreaStep;

package/dist/FormComponents/Step/TextInputStep/MaterialTextInputStep/MaterialTextInputStep.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { TextInputStepProps } from '../TextInputStep';
+declare function TextInputStep({ icon, step, form, errors, control, editable, postview, formStyle, widthStats, defaultValue, dependencyStore, setDependencyStore, }: TextInputStepProps): JSX.Element;
+export default TextInputStep;