@arquimedes.co/eureka-forms 3.0.65 → 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/EntityValueStep/entityValuePickerWatchedSteps.js

@@ -2,6 +2,13 @@ import { EntityValueDataTypes } from '../../constants/FormStepTypes';
 const push = (step, idStep, into) => {
     if (!idStep)
         return;
+    /**
+     * A draft can point a filter or a path hop at the picker that holds it (the editor lists the
+     * step among the pickable ones before the form is saved and the backend rejects it). A step is
+     * never its own dependency, and watching itself would close a cycle in the dependency walk.
+     */
+    if (idStep === step.id)
+        return;
     if (step.dependencies?.includes(idStep))
         return;
     if (!into.includes(idStep))

package/dist/FormSteps/EntityValueStep/entityValuePickerWatchedSteps.test.js

@@ -61,6 +61,13 @@ describe('entityValuePickerWatchedSteps', () => {
         });
         expect(entityValuePickerWatchedSteps(step)).toEqual(['shared']);
     });
+    test('ignores a draft filter or path hop pointing back at the picker itself', () => {
+        const step = picker({
+            path: [stepPath('picker'), stepPath('hop')],
+            filters: [stepFilter('picker', true), stepFilter('picker', false), stepFilter('other', false)],
+        });
+        expect(entityValuePickerWatchedSteps(step)).toEqual(['hop', 'other']);
+    });
 });
 describe('entityValuePickerBlockingSteps', () => {
     test('only the path hops and the required filters block the fetch', () => {
@@ -78,4 +85,11 @@ describe('entityValuePickerBlockingSteps', () => {
         });
         expect(entityValuePickerBlockingSteps(step)).toEqual([]);
     });
+    test('ignores a draft filter or path hop pointing back at the picker itself', () => {
+        const step = picker({
+            path: [stepPath('picker')],
+            filters: [stepFilter('picker', true)],
+        });
+        expect(entityValuePickerBlockingSteps(step)).toEqual([]);
+    });
 });

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;
@@ -67,6 +74,20 @@ export declare const selectStepDependencies: ((state: RootState, _step: GBaseSte
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+/**
+ * The steps `idStep` depends on, transitively: every dependency's own dependencies come before it,
+ * and every id is answered exactly once. `idStep` itself is never listed — a step is not a
+ * dependency of itself, even when a draft points it back at itself.
+ *
+ * A saved form is a DAG: the backend recomputes and validates `step.dependencies` on save. The
+ * editor's live preview renders unsaved drafts though, where a filter or a path hop can still point
+ * at the step that holds it, or close a cycle with another step. The walk must therefore terminate
+ * on any graph, cyclic included: a step is marked visited before it is walked and is never walked
+ * or listed twice, so every edge is followed at most once.
+ *
+ * Exported for the unit test; it is internal to this module and not part of the package's surface.
+ */
+export declare const calcDeepDependencies: (idStep: string, form: Form) => string[];
 export interface UseFormStepOptions<ValueType> {
     defaultValue: ValueType;
     /** If true, will not trigger onChange until the user has finished typing */

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);
@@ -66,24 +82,45 @@ export const selectStepDependencies = createSelector([
     }
     return { invalids, emptyDep };
 });
-const calcDeepDependencies = (idStep, form, deps = []) => {
-    const step = form.steps[idStep];
-    if (!step)
-        return deps;
-    /**
-     * An entity picker also gives up (its options resolve to null) while a path hop or a required
-     * STEP filter holds no value. Those are in `step.dependencies` once the form has been saved,
-     * but not in an unsaved draft, so they are added here to read as a missing dependency instead
-     * of as a failed load.
-     */
-    const idDeps = step.type === FormStepTypes.ENTITYVALUEPICKER
-        ? [...(step.dependencies ?? []), ...entityValuePickerBlockingSteps(step)]
-        : step.dependencies;
-    for (const dep of idDeps ?? []) {
-        if (!deps.includes(dep)) {
-            deps.push(...calcDeepDependencies(dep, form, deps), dep);
+/**
+ * The steps `idStep` depends on, transitively: every dependency's own dependencies come before it,
+ * and every id is answered exactly once. `idStep` itself is never listed — a step is not a
+ * dependency of itself, even when a draft points it back at itself.
+ *
+ * A saved form is a DAG: the backend recomputes and validates `step.dependencies` on save. The
+ * editor's live preview renders unsaved drafts though, where a filter or a path hop can still point
+ * at the step that holds it, or close a cycle with another step. The walk must therefore terminate
+ * on any graph, cyclic included: a step is marked visited before it is walked and is never walked
+ * or listed twice, so every edge is followed at most once.
+ *
+ * Exported for the unit test; it is internal to this module and not part of the package's surface.
+ */
+export const calcDeepDependencies = (idStep, form) => {
+    const deps = [];
+    /** `idStep` starts out visited so a cycle back to it stops there and never lists it. */
+    const visited = new Set([idStep]);
+    const walk = (id) => {
+        const step = form.steps[id];
+        if (!step)
+            return;
+        /**
+         * An entity picker also gives up (its options resolve to null) while a path hop or a
+         * required STEP filter holds no value. Those are in `step.dependencies` once the form has
+         * been saved, but not in an unsaved draft, so they are added here to read as a missing
+         * dependency instead of as a failed load.
+         */
+        const idDeps = step.type === FormStepTypes.ENTITYVALUEPICKER
+            ? [...(step.dependencies ?? []), ...entityValuePickerBlockingSteps(step)]
+            : step.dependencies;
+        for (const dep of idDeps ?? []) {
+            if (visited.has(dep))
+                continue;
+            visited.add(dep);
+            walk(dep);
+            deps.push(dep);
         }
-    }
+    };
+    walk(idStep);
     return deps;
 };
 export const useFormStep = (step, { rules, debounce, sizeChange, defaultValue }) => {

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

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

package/dist/FormSteps/StepHooks.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest';
+import FormStepTypes, { EntityValueDataTypes } from '../constants/FormStepTypes';
+import { calcDeepDependencies } from './StepHooks';
+const form = (steps) => ({
+    steps: Object.entries(steps).reduce((acc, [id, step]) => ({
+        ...acc,
+        [id]: { id, idSection: 'section', type: FormStepTypes.TEXTINPUT, ...step },
+    }), {}),
+});
+const picker = (step) => ({
+    type: FormStepTypes.ENTITYVALUEPICKER,
+    idEntity: 'entity',
+    path: [],
+    filters: [],
+    options: {},
+    ...step,
+});
+const stepFilter = (idStep, required) => ({
+    idProperty: 'prop-' + idStep,
+    type: EntityValueDataTypes.STEP,
+    idStep,
+    any: false,
+    required,
+});
+describe('calcDeepDependencies', () => {
+    test('walks a linear chain deepest first, listing each id once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: {},
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('lists a dependency shared by two branches once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b', 'c'] },
+            b: { dependencies: ['d'] },
+            c: { dependencies: ['d'] },
+            d: {},
+        }));
+        expect(deps).toEqual(['d', 'b', 'c']);
+    });
+    test('terminates on an A -> B -> A cycle without listing the step itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['a'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    test('terminates on a cycle reached deeper in the walk', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('terminates on a step that depends on itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    /**
+     * A draft an entity picker points back at itself with a required STEP filter: the filter is not
+     * in the saved `dependencies` yet, so it only reaches the walk through
+     * `entityValuePickerBlockingSteps`.
+     */
+    test('terminates on a self reference through a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('picker', true)] }),
+        }));
+        expect(deps).toEqual(['picker']);
+    });
+    test('terminates on a cycle closed by a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('other', true)] }),
+            other: { dependencies: ['picker'] },
+        }));
+        expect(deps).toEqual(['other', 'picker']);
+    });
+    test('keeps a dependency whose step the draft has already deleted', () => {
+        const deps = calcDeepDependencies('a', form({ a: { dependencies: ['gone'] } }));
+        expect(deps).toEqual(['gone']);
+    });
+    test('answers nothing for a step the form does not hold', () => {
+        expect(calcDeepDependencies('missing', form({}))).toEqual([]);
+    });
+});

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.65",
+  "version": "3.0.67",
   "scripts": {
     "watch": "node node_modules/@typescript/native/bin/tsc --noEmit --watch --project tsconfig.app.json",
     "start": "vite",