@arquimedes.co/eureka-forms 3.0.65 → 3.0.66

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

@@ -67,6 +67,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

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