@arquimedes.co/eureka-forms 3.0.33-test → 3.0.33

package/dist/FormSteps/StepHooks.d.ts

@@ -7,65 +7,27 @@ import { FormStep } from '../@Types/FormStep';
 import { FieldError, RefCallBack, UseControllerProps, useController } from 'react-hook-form';
 import { Condition } from '../@Types/Condition';
 import { CBRFormStep } from '../@Types/CBRFormStep';
-export declare const selectOriginalValue: ((state: RootState, step: GBaseStep) => any) & {
+export declare const selectOriginalValue: ((state: RootState, step: GBaseStep) => any) & import("reselect").OutputSelectorFields<(args_0: ValuesStore, args_1: GBaseStep) => any, {
+    clearCache: () => void;
+}> & {
     clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: ValuesStore, resultFuncArgs_1: GBaseStep) => any;
-    memoizedResultFunc: ((resultFuncArgs_0: ValuesStore, resultFuncArgs_1: GBaseStep) => any) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => any;
-    dependencies: [(state: RootState) => ValuesStore, (_state: RootState, step: GBaseStep) => GBaseStep];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    memoize: typeof import("reselect").weakMapMemoize;
-    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 export interface StepDependency {
     originalValue: any;
     isDependency: boolean;
-    handleStepDep: (value: any) => void;
+    handleStepDep: (value: any | undefined) => void;
 }
 export declare const useStepDependency: (step: GBaseStep, defaultValue?: any) => StepDependency;
-export declare const selectStepDependencies: ((state: RootState, _step: GBaseStep, form: Form) => {
+export declare const selectStepDependencies: ((state: RootState, step: GBaseStep, form: Form) => {
+    invalids: string[];
+    emptyDep: boolean;
+}) & import("reselect").OutputSelectorFields<(args_0: DependencyStore, args_1: GBaseStep, args_2: Form) => {
     invalids: string[];
     emptyDep: boolean;
-}) & {
+}, {
+    clearCache: () => void;
+}> & {
     clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: DependencyStore, resultFuncArgs_1: GBaseStep, resultFuncArgs_2: Form) => {
-        invalids: string[];
-        emptyDep: boolean;
-    };
-    memoizedResultFunc: ((resultFuncArgs_0: DependencyStore, resultFuncArgs_1: GBaseStep, resultFuncArgs_2: Form) => {
-        invalids: string[];
-        emptyDep: boolean;
-    }) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => {
-        invalids: string[];
-        emptyDep: boolean;
-    };
-    dependencies: [(state: RootState) => DependencyStore, (_state: RootState, step: GBaseStep) => GBaseStep, (_state: RootState, _step: GBaseStep, form: Form) => Form];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    memoize: typeof import("reselect").weakMapMemoize;
-    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 export interface UseFormStepOptions<ValueType> {
     defaultValue: ValueType;
@@ -83,26 +45,10 @@ export interface FormStepFunctions<ValueType = unknown> {
     field: Omit<ReturnType<typeof useController>['field'], 'ref' | 'value' | 'onChange'>;
 }
 export declare const useFormStep: <ValueType = unknown>(step: GBaseStep, { rules, debounce, sizeChange, defaultValue }: UseFormStepOptions<ValueType>) => FormStepFunctions<ValueType>;
-export declare const selectDependencies: ((state: RootState, idDeps: string[] | undefined) => DependencyStore) & {
+export declare const selectDependencies: ((state: RootState, idDeps: string[] | undefined) => DependencyStore) & import("reselect").OutputSelectorFields<(args_0: DependencyStore, args_1: string[]) => DependencyStore, {
+    clearCache: () => void;
+}> & {
     clearCache: () => void;
-    resultsCount: () => number;
-    resetResultsCount: () => void;
-} & {
-    resultFunc: (resultFuncArgs_0: DependencyStore, resultFuncArgs_1: string[]) => DependencyStore;
-    memoizedResultFunc: ((resultFuncArgs_0: DependencyStore, resultFuncArgs_1: string[]) => DependencyStore) & {
-        clearCache: () => void;
-        resultsCount: () => number;
-        resetResultsCount: () => void;
-    };
-    lastResult: () => DependencyStore;
-    dependencies: [(state: RootState) => DependencyStore, (_state: RootState, idDeps: string[] | undefined) => string[]];
-    recomputations: () => number;
-    resetRecomputations: () => void;
-    dependencyRecomputations: () => number;
-    resetDependencyRecomputations: () => void;
-} & {
-    memoize: typeof import("reselect").weakMapMemoize;
-    argsMemoize: typeof import("reselect").weakMapMemoize;
 };
 export declare const useCondition: (condition?: Condition) => boolean;
 export declare const calcStepDeps: (step: FormStep | CBRFormStep) => string[];

package/dist/FormSteps/StepHooks.js

@@ -1,96 +1,137 @@
+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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import { useAppSelector, useAppDispatch } from '../hooks';
-import { clearDependency, setStepDependency } from '../States/SiteSlice';
+import { clearDependency, setStepDependency, } from '../States/SiteSlice';
 import { createSelector } from '@reduxjs/toolkit';
 import { calcDefaultValue, evaluateCondition } from './StepFunctions';
-import { useController } from 'react-hook-form';
+import { useController, } from 'react-hook-form';
+import { SizeChangeContext } from './Utils/@StepFiller/StepFiller';
 import ConditionTypes from '../constants/ConditionTypes';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, } from '../constants/FormStepTypes';
-import { SizeChangeContext } from './Utils/@StepFiller/StepFillerContext';
-const selectIsDependency = createSelector([
-    (state) => state.site.dependencies,
-    (_state, step) => step,
-], (dependencies, step) => {
+var selectIsDependency = createSelector([
+    function (state) { return state.site.dependencies; },
+    function (state, step) { return step; },
+], function (dependencies, step) {
     return dependencies[step.id] !== undefined;
 });
-export const selectOriginalValue = createSelector([(state) => state.site.values, (_state, step) => step], (values, step) => values.sections[step?.idSection]?.[step?.id]);
-export const useStepDependency = (step, defaultValue) => {
-    const isDependency = useAppSelector((state) => selectIsDependency(state, step));
-    const originalValue = useAppSelector((state) => selectOriginalValue(state, step));
-    const dispatch = useAppDispatch();
-    useEffect(() => {
+export var selectOriginalValue = createSelector([
+    function (state) { return state.site.values; },
+    function (state, step) { return step; },
+], function (values, step) { var _a; return (_a = values.sections[step.idSection]) === null || _a === void 0 ? void 0 : _a[step.id]; });
+export var useStepDependency = function (step, defaultValue) {
+    var _a;
+    var isDependency = useAppSelector(function (state) {
+        return selectIsDependency(state, step);
+    });
+    var originalValue = useAppSelector(function (state) {
+        return selectOriginalValue(state, step);
+    });
+    var dispatch = useAppDispatch();
+    useEffect(function () {
         if (isDependency && !originalValue && defaultValue) {
             dispatch(setStepDependency({
-                step,
+                step: step,
                 value: defaultValue,
             }));
         }
-        return () => {
+        return function () {
             dispatch(clearDependency(step));
         };
     }, [isDependency]);
-    const handleStepDep = useCallback((value) => {
+    var handleStepDep = useCallback(function (value) {
         if (!isDependency)
             return;
         dispatch(setStepDependency({
-            step,
-            value: value ?? null,
+            step: step,
+            value: value !== null && value !== void 0 ? value : null,
         }));
     }, [step.id, step.type, isDependency]);
     return {
-        handleStepDep,
-        isDependency,
-        originalValue: originalValue ?? defaultValue ?? calcDefaultValue(step),
+        handleStepDep: handleStepDep,
+        isDependency: isDependency,
+        originalValue: (_a = originalValue !== null && originalValue !== void 0 ? originalValue : defaultValue) !== null && _a !== void 0 ? _a : calcDefaultValue(step),
     };
 };
-export const selectStepDependencies = createSelector([
-    (state) => state.site.dependencies,
-    (_state, step) => step,
-    (_state, _step, form) => form,
-], (dependencies, step, form) => {
-    const invalids = [];
-    let emptyDep = false;
+export var selectStepDependencies = createSelector([
+    function (state) { return state.site.dependencies; },
+    function (state, step) { return step; },
+    function (state, step, form) { return form; },
+], function (dependencies, step, form) {
+    var invalids = [];
+    var emptyDep = false;
     /** Show deep error changes even if not in dependencies */
-    for (const idDep of calcDeepDependencies(step.id, form)) {
-        const dependency = dependencies[idDep];
-        if (dependency?.value === null && form.steps[idDep]) {
+    for (var _i = 0, _a = calcDeepDependencies(step.id, form); _i < _a.length; _i++) {
+        var idDep = _a[_i];
+        var dependency = dependencies[idDep];
+        if ((dependency === null || dependency === void 0 ? void 0 : dependency.value) === null && form.steps[idDep]) {
             invalids.push(idDep);
         }
-        if (dependency?.empty)
+        if (dependency === null || dependency === void 0 ? void 0 : dependency.empty)
             emptyDep = true;
     }
-    return { invalids, emptyDep };
+    return { invalids: invalids, emptyDep: emptyDep };
 });
-const calcDeepDependencies = (idStep, form, deps = []) => {
-    const step = form.steps[idStep];
-    if (step?.dependencies) {
-        for (const dep of step.dependencies) {
+var calcDeepDependencies = function (idStep, form, deps) {
+    if (deps === void 0) { deps = []; }
+    var step = form.steps[idStep];
+    if (step === null || step === void 0 ? void 0 : step.dependencies) {
+        for (var _i = 0, _a = step.dependencies; _i < _a.length; _i++) {
+            var dep = _a[_i];
             if (!deps.includes(dep)) {
-                deps.push(...calcDeepDependencies(dep, form, deps), dep);
+                deps.push.apply(deps, __spreadArray(__spreadArray([], calcDeepDependencies(dep, form, deps), false), [dep], false));
             }
         }
     }
     return deps;
 };
-export const useFormStep = (step, { rules, debounce, sizeChange, defaultValue }) => {
-    const [timer, setTimer] = useState();
-    const { isDependency, handleStepDep, originalValue } = useStepDependency(step, defaultValue);
-    const { field: { ref, value, onChange: fieldOnChange, ...field }, fieldState: { error }, } = useController({
+export var useFormStep = function (step, _a) {
+    var rules = _a.rules, debounce = _a.debounce, sizeChange = _a.sizeChange, defaultValue = _a.defaultValue;
+    var _b = useState(), timer = _b[0], setTimer = _b[1];
+    var _c = useStepDependency(step, defaultValue), isDependency = _c.isDependency, handleStepDep = _c.handleStepDep, originalValue = _c.originalValue;
+    var _d = useController({
         name: step.id,
-        rules,
+        rules: rules,
         shouldUnregister: true,
         defaultValue: originalValue,
-    });
-    const handleSizeChange = useContext(SizeChangeContext);
-    const onChange = useCallback((value) => {
+    }), _e = _d.field, ref = _e.ref, value = _e.value, fieldOnChange = _e.onChange, field = __rest(_e, ["ref", "value", "onChange"]), error = _d.fieldState.error;
+    var handleSizeChange = useContext(SizeChangeContext);
+    var onChange = useCallback(function (value) {
         if (isDependency) {
             if (debounce) {
-                try {
+                if (timer) {
                     clearTimeout(timer);
-                    // eslint-disable-next-line no-empty, @typescript-eslint/no-unused-vars
                 }
-                catch (e) { }
-                setTimer(setTimeout(() => {
+                setTimer(setTimeout(function () {
                     handleStepDep(value);
                     setTimer(undefined);
                 }, 1000));
@@ -101,73 +142,96 @@ export const useFormStep = (step, { rules, debounce, sizeChange, defaultValue })
         }
         fieldOnChange(value);
         if (sizeChange)
-            handleSizeChange?.();
-    }, [handleStepDep, isDependency, fieldOnChange]);
+            handleSizeChange === null || handleSizeChange === void 0 ? void 0 : handleSizeChange();
+    }, [
+        handleStepDep,
+        isDependency,
+        fieldOnChange,
+        timer,
+        debounce,
+        sizeChange,
+        handleSizeChange,
+    ]);
     return {
-        ref,
-        value,
-        onChange,
-        error,
-        field,
+        ref: ref,
+        value: value,
+        onChange: onChange,
+        error: error,
+        field: field,
     };
 };
-const EMPTY_ARRAY = [];
-export const selectDependencies = createSelector([
-    (state) => state.site.dependencies,
-    (_state, idDeps) => idDeps ?? EMPTY_ARRAY,
-], (dependencies, idDeps) => idDeps.reduce((acc, idDep) => ({
-    ...acc,
-    [idDep]: dependencies[idDep],
-}), {}));
-export const useCondition = (condition) => {
-    const ids = useMemo(() => recursivelyCalcConditionSteps(condition), []);
-    const dependencies = useAppSelector((state) => selectDependencies(state, ids));
-    return useMemo(() => {
+var EMPTY_ARRAY = [];
+export var selectDependencies = createSelector([
+    function (state) { return state.site.dependencies; },
+    function (state, idDeps) {
+        return idDeps !== null && idDeps !== void 0 ? idDeps : EMPTY_ARRAY;
+    },
+], function (dependencies, idDeps) {
+    return idDeps.reduce(function (acc, idDep) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[idDep] = dependencies[idDep], _a)));
+    }, {});
+});
+export var useCondition = function (condition) {
+    var ids = useMemo(function () { return recursivelyCalcConditionSteps(condition); }, []);
+    var dependencies = useAppSelector(function (state) {
+        return selectDependencies(state, ids);
+    });
+    return useMemo(function () {
         return !condition || evaluateCondition(condition, dependencies);
-    }, ids.map((id) => dependencies[id].value));
+    }, ids.map(function (id) { return dependencies[id].value; }));
 };
-export const calcStepDeps = (step) => {
-    const dependencies = [...(step.dependencies ?? [])];
+export var calcStepDeps = function (step) {
+    var _a;
+    var dependencies = __spreadArray([], ((_a = step.dependencies) !== null && _a !== void 0 ? _a : []), true);
     if (step.condition) {
-        dependencies.push(...recursivelyCalcConditionSteps(step.condition));
+        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(step.condition));
     }
     switch (step.type) {
         case FormStepTypes.CLASSIFIER_SELECTOR:
             {
-                for (const option of Object.values(step.options)) {
-                    if (option.type !== ClassifierOptionTypes.HIDE && option.condition) {
-                        dependencies.push(...recursivelyCalcConditionSteps(option.condition));
+                for (var _i = 0, _b = Object.values(step.options); _i < _b.length; _i++) {
+                    var option = _b[_i];
+                    if (option.type !== ClassifierOptionTypes.HIDE &&
+                        option.condition) {
+                        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(option.condition));
                     }
                 }
             }
             break;
         case FormStepTypes.ENTITYVALUEPICKER:
             {
-                for (const option of Object.values(step.options)) {
-                    if (option.type !== EntityValueOptionTypes.HIDE && option.condition) {
-                        dependencies.push(...recursivelyCalcConditionSteps(option.condition));
+                for (var _c = 0, _d = Object.values(step.options); _c < _d.length; _c++) {
+                    var option = _d[_c];
+                    if (option.type !== EntityValueOptionTypes.HIDE &&
+                        option.condition) {
+                        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(option.condition));
                     }
                 }
                 if (step.dialogs)
-                    for (const dialog of Object.values(step.dialogs)) {
-                        dependencies.push(...recursivelyCalcConditionSteps(dialog.condition));
+                    for (var _e = 0, _f = Object.values(step.dialogs); _e < _f.length; _e++) {
+                        var dialog = _f[_e];
+                        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(dialog.condition));
                     }
             }
             break;
         case FormStepTypes.API_SELECTOR:
             {
-                for (const option of Object.values(step.options)) {
-                    if (option.type !== ApiSelectorOptionTypes.HIDE && option.condition) {
-                        dependencies.push(...recursivelyCalcConditionSteps(option.condition));
+                for (var _g = 0, _h = Object.values(step.options); _g < _h.length; _g++) {
+                    var option = _h[_g];
+                    if (option.type !== ApiSelectorOptionTypes.HIDE &&
+                        option.condition) {
+                        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(option.condition));
                     }
                 }
             }
             break;
         case FormStepTypes.SELECTOR:
             {
-                for (const option of Object.values(step.options)) {
+                for (var _j = 0, _k = Object.values(step.options); _j < _k.length; _j++) {
+                    var option = _k[_j];
                     if (option.condition) {
-                        dependencies.push(...recursivelyCalcConditionSteps(option.condition));
+                        dependencies.push.apply(dependencies, recursivelyCalcConditionSteps(option.condition));
                     }
                 }
             }
@@ -177,12 +241,14 @@ export const calcStepDeps = (step) => {
     }
     return dependencies;
 };
-export const recursivelyCalcConditionSteps = (condition) => {
+export var recursivelyCalcConditionSteps = function (condition) {
     if (!condition)
         return [];
     switch (condition.type) {
         case ConditionTypes.EXPRESSION: {
-            return condition.conditions.map((condition) => recursivelyCalcConditionSteps(condition)).flat();
+            return condition.conditions
+                .map(function (condition) { return recursivelyCalcConditionSteps(condition); })
+                .flat();
         }
         case ConditionTypes.FORM_STEP: {
             return [condition.idStep];

package/dist/FormSteps/TextAreaStep/MaterialTextAreaStep/DraftEditor.css

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

package/dist/FormSteps/TextAreaStep/MaterialTextAreaStep/MaterialTextAreaEditorStep.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import 'react-draft-wysiwyg/dist/react-draft-wysiwyg.css';
 import './DraftEditor.css';
 import { TextAreaStepProps } from '../TextAreaStep';