@arquimedes.co/eureka-forms 3.0.66 → 3.0.67

package/dist/FormSteps/EntityValueStep/MaterialEntityValuePickerStep/MaterialEntityValuePickerStep.js

@@ -5,7 +5,7 @@ import SmartSelect from '../../SmartSelectStep/MaterialSmartSelectStep/MaterialS
 import widgetInstance from '../../../Utils/AxiosWidget';
 import FormContext, { IdFormContext } from '../../../Contexts/FormContext';
 import StepFillerContainer from '../../Utils/@StepFiller/StepFiller';
-import { recursivelyCalcConditionSteps, selectDependencies } from '../../StepHooks';
+import { isStepHiddenByCondition, recursivelyCalcConditionSteps, selectDependencies } from '../../StepHooks';
 import { useApiSubscribe, useAppSelector } from '../../../hooks';
 import MaterialEntityValueDialog from './MaterialEntityValueDialog/MaterialEntityValueDialog';
 import InputIcon from '../../../Shared/InputIcon/InputIcon';
@@ -27,8 +27,23 @@ function EntityValuePickerStep({ step, editable }) {
         }))) ?? []);
     }, [subscribe, idForm]);
     const getOptions = useCallback(async (step, dependencyStore, ids) => {
-        return await getEntityValueOptions(step, dependencyStore, ids, fetchFilterIntegration);
-    }, [fetchFilterIntegration]);
+        return await getEntityValueOptions(step, dependencyStore, ids, fetchFilterIntegration, form);
+    }, [fetchFilterIntegration, form]);
+    // The visibility of a filter's step decides whether that filter applies, so the steps its condition
+    // reads must trigger a refetch too — see `isStepHiddenByCondition`.
+    const getOptionalDependencies = useCallback((picker) => {
+        const watched = entityValuePickerWatchedSteps(picker);
+        for (const idWatched of [...watched]) {
+            for (const idCondition of recursivelyCalcConditionSteps(form.steps[idWatched]?.condition)) {
+                if (idCondition === picker.id || watched.includes(idCondition))
+                    continue;
+                if (picker.dependencies?.includes(idCondition))
+                    continue;
+                watched.push(idCondition);
+            }
+        }
+        return watched;
+    }, [form]);
     const [dialogs, setDialogs] = useState();
     const dialogsIdStepDeps = useMemo(() => {
         const ids = [];
@@ -113,7 +128,7 @@ function EntityValuePickerStep({ step, editable }) {
                     } }) })] }));
 }
 export default EntityValuePickerStep;
-const getEntityValueOptions = async (step, dependencyStore, { idOrganization, idCurrentAgent, }, fetchFilterIntegration) => {
+const getEntityValueOptions = async (step, dependencyStore, { idOrganization, idCurrentAgent, }, fetchFilterIntegration, form) => {
     if (!idOrganization)
         return null;
     let urlPath = '';
@@ -179,7 +194,8 @@ const getEntityValueOptions = async (step, dependencyStore, { idOrganization, id
                 if (currentValue !== undefined) {
                     params.set(filter.idProperty, currentValue);
                 }
-                else if (filter.required) {
+                else if (filter.required && !isStepHiddenByCondition(filter.idStep, form, dependencyStore)) {
+                    // A required filter blocks only while its step can still be answered.
                     return null;
                 }
                 break;
@@ -200,8 +216,3 @@ const getEntityValueOptions = async (step, dependencyStore, { idOrganization, id
     });
     return response.data.filter((option) => step.options[option._id]?.type !== EntityValueOptionTypes.HIDE);
 };
-/**
- * The steps the picker must watch on top of `step.dependencies`. See
- * `entityValuePickerWatchedSteps` for why the saved dependencies are not enough.
- */
-const getOptionalDependencies = (step) => entityValuePickerWatchedSteps(step);

package/dist/FormSteps/StepHooks.d.ts

@@ -34,6 +34,13 @@ export interface StepDependency {
     handleStepDep: (value: any) => void;
 }
 export declare const useStepDependency: (step: GBaseStep, defaultValue?: any) => StepDependency;
+/**
+ * Whether `idStep` is currently kept off the form by its own visibility condition. A step that is not
+ * shown cannot be answered, so nothing may wait for it: a required entity filter pointing at it does
+ * not apply, and it never reads as a missing dependency. When the condition cannot be decided yet (a
+ * step it reads is not in the store) the step counts as shown, keeping the conservative behaviour.
+ */
+export declare const isStepHiddenByCondition: (idStep: string, form: Form, dependencies: DependencyStore) => boolean;
 export declare const selectStepDependencies: ((state: RootState, _step: GBaseStep, form: Form) => {
     invalids: string[];
     emptyDep: boolean;

package/dist/FormSteps/StepHooks.js

@@ -48,6 +48,20 @@ export const useStepDependency = (step, defaultValue) => {
         originalValue: originalValue ?? defaultValue ?? calcDefaultValue(step),
     };
 };
+/**
+ * Whether `idStep` is currently kept off the form by its own visibility condition. A step that is not
+ * shown cannot be answered, so nothing may wait for it: a required entity filter pointing at it does
+ * not apply, and it never reads as a missing dependency. When the condition cannot be decided yet (a
+ * step it reads is not in the store) the step counts as shown, keeping the conservative behaviour.
+ */
+export const isStepHiddenByCondition = (idStep, form, dependencies) => {
+    const target = form.steps[idStep];
+    if (!target?.condition)
+        return false;
+    if (recursivelyCalcConditionSteps(target.condition).some((id) => dependencies[id] === undefined))
+        return false;
+    return !evaluateCondition(target.condition, dependencies);
+};
 export const selectStepDependencies = createSelector([
     (state) => state.site.dependencies,
     (_state, step) => step,
@@ -57,6 +71,8 @@ export const selectStepDependencies = createSelector([
     let emptyDep = false;
     /** Show deep error changes even if not in dependencies */
     for (const idDep of calcDeepDependencies(step.id, form)) {
+        if (isStepHiddenByCondition(idDep, form, dependencies))
+            continue;
         const dependency = dependencies[idDep];
         if (dependency?.value === null && form.steps[idDep]) {
             invalids.push(idDep);

package/dist/FormSteps/isStepHiddenByCondition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/FormSteps/isStepHiddenByCondition.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { isStepHiddenByCondition } from './StepHooks';
+// A Selector shown only while the Proyecto picker holds a specific value — the shape the editor saves.
+const PROYECTO = 'ENTITYVALUEPICKER-proyecto';
+const condition = {
+    type: 'EXPRESSION',
+    expression: 'AND',
+    conditions: [
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EXISTS' },
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EQUAL', values: ['kai'] },
+    ],
+};
+const form = {
+    steps: {
+        [PROYECTO]: { id: PROYECTO, type: 'ENTITYVALUEPICKER' },
+        'SELECTOR-piso': { id: 'SELECTOR-piso', type: 'SELECTOR', condition },
+        'SELECTOR-libre': { id: 'SELECTOR-libre', type: 'SELECTOR' },
+    },
+};
+const dependency = (value) => ({
+    idOriginal: PROYECTO,
+    dependents: [],
+    value,
+    type: 'ENTITYVALUEPICKER',
+});
+describe('isStepHiddenByCondition', () => {
+    test('a step without condition is never hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-libre', form, {})).toBe(false);
+    });
+    test('a step whose condition evaluates false is hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'otro' }) })).toBe(true);
+    });
+    test('a step whose condition evaluates true is shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'kai' }) })).toBe(false);
+    });
+    test('an undecidable condition (its step is not in the store) counts as shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, {})).toBe(false);
+    });
+    test('a step unknown to the form counts as shown', () => {
+        expect(isStepHiddenByCondition('MAPPER-x-espacio', form, {})).toBe(false);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arquimedes.co/eureka-forms",
   "repository": "git://github.com/Arquimede5/Eureka-Forms.git",
-  "version": "3.0.66",
+  "version": "3.0.67",
   "scripts": {
     "watch": "node node_modules/@typescript/native/bin/tsc --noEmit --watch --project tsconfig.app.json",
     "start": "vite",