@arquimedes.co/eureka-forms 3.0.64 → 3.0.65

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

@@ -13,6 +13,8 @@ import { evaluateCondition } from '../../StepFunctions';
 import StepComponent from '../../Step';
 import ErkValueTypes from '../../../constants/ErkValueTypes';
 import { IntegrationsApi } from '../../../Services/IntegrationService';
+import { entityValueDependencyValue } from '../entityValueDependencyValue';
+import { entityValuePickerWatchedSteps } from '../entityValuePickerWatchedSteps';
 function EntityValuePickerStep({ step, editable }) {
     const form = useContext(FormContext);
     const subscribe = useApiSubscribe();
@@ -173,12 +175,9 @@ const getEntityValueOptions = async (step, dependencyStore, { idOrganization, id
                 break;
             }
             case EntityValueDataTypes.STEP: {
-                const currentValue = dependencyStore[filter.idStep]?.value;
-                if (currentValue) {
-                    if (typeof currentValue === 'string')
-                        params.set(filter.idProperty, currentValue);
-                    else
-                        params.set(filter.idProperty, currentValue._id ?? currentValue.id);
+                const currentValue = entityValueDependencyValue(dependencyStore[filter.idStep]);
+                if (currentValue !== undefined) {
+                    params.set(filter.idProperty, currentValue);
                 }
                 else if (filter.required) {
                     return null;
@@ -201,18 +200,8 @@ const getEntityValueOptions = async (step, dependencyStore, { idOrganization, id
     });
     return response.data.filter((option) => step.options[option._id]?.type !== EntityValueOptionTypes.HIDE);
 };
-const getOptionalDependencies = (step) => {
-    const optional = [];
-    for (const filter of step.filters) {
-        switch (filter.type) {
-            case EntityValueDataTypes.STEP: {
-                if (filter.idStep && !filter.required && !step.dependencies?.includes(filter.idStep))
-                    optional.push(filter.idStep);
-                break;
-            }
-            default:
-                break;
-        }
-    }
-    return optional;
-};
+/**
+ * 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/entityValueDependencyValue.d.ts

@@ -0,0 +1,12 @@
+import { StepDependency } from '../../Form/Form';
+/**
+ * Serializes the current value of a dependency step into the string an entity-picker STEP filter
+ * sends as `values.<idProperty>` query param.
+ *
+ * Entity values (and any id-bearing object) resolve to their id. The answer of a Selector or
+ * Classifier step is a `{ label, value }` option: a Selector keeps `value === label`, so its `value`
+ * is the text the entity property stores; a Classifier's `value` is the classifier id, which no
+ * entity property holds, so it resolves to its `label`. Returns undefined when the dependency has
+ * no usable value, so the caller treats the filter as unresolved.
+ */
+export declare function entityValueDependencyValue(dependency: StepDependency | undefined): string | undefined;

package/dist/FormSteps/EntityValueStep/entityValueDependencyValue.js

@@ -0,0 +1,35 @@
+import FormStepTypes from '../../constants/FormStepTypes';
+/**
+ * Serializes the current value of a dependency step into the string an entity-picker STEP filter
+ * sends as `values.<idProperty>` query param.
+ *
+ * Entity values (and any id-bearing object) resolve to their id. The answer of a Selector or
+ * Classifier step is a `{ label, value }` option: a Selector keeps `value === label`, so its `value`
+ * is the text the entity property stores; a Classifier's `value` is the classifier id, which no
+ * entity property holds, so it resolves to its `label`. Returns undefined when the dependency has
+ * no usable value, so the caller treats the filter as unresolved.
+ */
+export function entityValueDependencyValue(dependency) {
+    const currentValue = dependency?.value;
+    if (currentValue === null || currentValue === undefined || currentValue === '')
+        return undefined;
+    if (typeof currentValue === 'string')
+        return currentValue;
+    if (typeof currentValue === 'number' || typeof currentValue === 'boolean')
+        return String(currentValue);
+    if (currentValue instanceof Date)
+        return currentValue.toISOString();
+    if (typeof currentValue !== 'object')
+        return undefined;
+    const record = currentValue;
+    // A Selector's `value` is the stored text; every other step's `value` may be an id, so its `label` wins.
+    const keys = dependency?.type === FormStepTypes.SELECTOR ? ['_id', 'id', 'value', 'label'] : ['_id', 'id', 'label', 'value'];
+    for (const key of keys) {
+        const candidate = record[key];
+        if (typeof candidate === 'string' && candidate !== '')
+            return candidate;
+        if (typeof candidate === 'number')
+            return String(candidate);
+    }
+    return undefined;
+}

package/dist/FormSteps/EntityValueStep/entityValueDependencyValue.test.d.ts

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

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

@@ -0,0 +1,31 @@
+import { describe, expect, test } from 'vitest';
+import FormStepTypes from '../../constants/FormStepTypes';
+import { entityValueDependencyValue } from './entityValueDependencyValue';
+const dep = (type, value) => ({
+    idOriginal: 'dep',
+    dependents: [],
+    type,
+    value,
+});
+describe('entityValueDependencyValue', () => {
+    test('an unanswered dependency is unresolved', () => {
+        expect(entityValueDependencyValue(undefined)).toBeUndefined();
+        expect(entityValueDependencyValue(dep(FormStepTypes.SELECTOR, null))).toBeUndefined();
+        expect(entityValueDependencyValue(dep(FormStepTypes.SELECTOR, ''))).toBeUndefined();
+        expect(entityValueDependencyValue(dep(FormStepTypes.SELECTOR, {}))).toBeUndefined();
+    });
+    test('plain answers are sent as text', () => {
+        expect(entityValueDependencyValue(dep(FormStepTypes.TEXTINPUT, 'Torre 3'))).toBe('Torre 3');
+        expect(entityValueDependencyValue(dep(FormStepTypes.TEXTINPUT, 7))).toBe('7');
+        expect(entityValueDependencyValue(dep(FormStepTypes.DATEPICKER, new Date('2026-01-02T00:00:00.000Z')))).toBe('2026-01-02T00:00:00.000Z');
+    });
+    test('an entity value resolves to its id', () => {
+        expect(entityValueDependencyValue(dep(FormStepTypes.ENTITYVALUEPICKER, { _id: 'ev-1', label: 'Morros' }))).toBe('ev-1');
+        expect(entityValueDependencyValue(dep(FormStepTypes.API_SELECTOR, { id: 'api-1', label: 'X' }))).toBe('api-1');
+    });
+    test('a selector option resolves to its value, a classifier option to its label', () => {
+        expect(entityValueDependencyValue(dep(FormStepTypes.SELECTOR, { label: 'Piso 2', value: 'Piso 2' }))).toBe('Piso 2');
+        expect(entityValueDependencyValue(dep(FormStepTypes.SELECTOR, { label: 'Dos', value: '2' }))).toBe('2');
+        expect(entityValueDependencyValue(dep(FormStepTypes.CLASSIFIER_SELECTOR, { label: 'Piso 2', value: '65f0c1a2b3c4d5e6f7a8b9c0' }))).toBe('Piso 2');
+    });
+});

package/dist/FormSteps/EntityValueStep/entityValuePickerWatchedSteps.d.ts

@@ -0,0 +1,27 @@
+import { EntityValuePicker } from '../../@Types/FormStep';
+/**
+ * The steps an entity picker reads a value from that `step.dependencies` does not already list:
+ * the STEP hops of `step.path` and every STEP filter, required or not.
+ *
+ * `step.dependencies` is recomputed server-side only when the form is saved
+ * (`FormDependencyFunctions.calcStepDependencies`), so it describes the form as it was at the last
+ * save. In the editor's live preview of an unsaved draft — and in any form whose stored
+ * dependencies went stale — a path hop or a filter added since then is missing from it, and the
+ * renderer would never watch the step it points at. The picker refetches its options when a watched
+ * value changes, so a filter the picker does not watch never triggers the fetch that would honour
+ * it: a required one leaves the select stuck with no options at all, an optional one leaves it
+ * showing options the filter should have narrowed.
+ *
+ * The `required` flag is deliberately not consulted: required or not, the filter's value is what
+ * has to trigger the refetch. Steps the last save already registered are skipped because the
+ * renderer watches `step.dependencies` anyway.
+ */
+export declare function entityValuePickerWatchedSteps(step: EntityValuePicker): string[];
+/**
+ * The subset of `entityValuePickerWatchedSteps` whose value the picker cannot do without: every
+ * STEP hop of the path, and the STEP filters flagged `required`. Those are exactly the cases where
+ * `getEntityValueOptions` gives up and answers `null` — its "dependency not met" contract — so
+ * while they hold no value the select has to read as a missing dependency rather than as a failed
+ * load.
+ */
+export declare function entityValuePickerBlockingSteps(step: EntityValuePicker): string[];

package/dist/FormSteps/EntityValueStep/entityValuePickerWatchedSteps.js

@@ -0,0 +1,57 @@
+import { EntityValueDataTypes } from '../../constants/FormStepTypes';
+const push = (step, idStep, into) => {
+    if (!idStep)
+        return;
+    if (step.dependencies?.includes(idStep))
+        return;
+    if (!into.includes(idStep))
+        into.push(idStep);
+};
+/**
+ * The steps an entity picker reads a value from that `step.dependencies` does not already list:
+ * the STEP hops of `step.path` and every STEP filter, required or not.
+ *
+ * `step.dependencies` is recomputed server-side only when the form is saved
+ * (`FormDependencyFunctions.calcStepDependencies`), so it describes the form as it was at the last
+ * save. In the editor's live preview of an unsaved draft — and in any form whose stored
+ * dependencies went stale — a path hop or a filter added since then is missing from it, and the
+ * renderer would never watch the step it points at. The picker refetches its options when a watched
+ * value changes, so a filter the picker does not watch never triggers the fetch that would honour
+ * it: a required one leaves the select stuck with no options at all, an optional one leaves it
+ * showing options the filter should have narrowed.
+ *
+ * The `required` flag is deliberately not consulted: required or not, the filter's value is what
+ * has to trigger the refetch. Steps the last save already registered are skipped because the
+ * renderer watches `step.dependencies` anyway.
+ */
+export function entityValuePickerWatchedSteps(step) {
+    const watched = [];
+    for (const path of step.path) {
+        if (path.type === EntityValueDataTypes.STEP)
+            push(step, path.idStep, watched);
+    }
+    for (const filter of step.filters) {
+        if (filter.type === EntityValueDataTypes.STEP)
+            push(step, filter.idStep, watched);
+    }
+    return watched;
+}
+/**
+ * The subset of `entityValuePickerWatchedSteps` whose value the picker cannot do without: every
+ * STEP hop of the path, and the STEP filters flagged `required`. Those are exactly the cases where
+ * `getEntityValueOptions` gives up and answers `null` — its "dependency not met" contract — so
+ * while they hold no value the select has to read as a missing dependency rather than as a failed
+ * load.
+ */
+export function entityValuePickerBlockingSteps(step) {
+    const blocking = [];
+    for (const path of step.path) {
+        if (path.type === EntityValueDataTypes.STEP)
+            push(step, path.idStep, blocking);
+    }
+    for (const filter of step.filters) {
+        if (filter.type === EntityValueDataTypes.STEP && filter.required)
+            push(step, filter.idStep, blocking);
+    }
+    return blocking;
+}

package/dist/FormSteps/EntityValueStep/entityValuePickerWatchedSteps.test.d.ts

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

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

@@ -0,0 +1,81 @@
+import { describe, expect, test } from 'vitest';
+import FormStepTypes, { EntityValueDataTypes } from '../../constants/FormStepTypes';
+import { entityValuePickerBlockingSteps, entityValuePickerWatchedSteps } from './entityValuePickerWatchedSteps';
+const picker = (picker) => ({
+    id: 'picker',
+    idSection: 'section',
+    type: FormStepTypes.ENTITYVALUEPICKER,
+    idEntity: 'entity',
+    path: [],
+    filters: [],
+    options: {},
+    ...picker,
+});
+const stepFilter = (idStep, required) => ({
+    idProperty: 'prop-' + idStep,
+    type: EntityValueDataTypes.STEP,
+    idStep,
+    any: false,
+    required,
+});
+const stepPath = (idStep) => ({
+    idEntity: 'parent',
+    type: EntityValueDataTypes.STEP,
+    idStep,
+    any: false,
+});
+describe('entityValuePickerWatchedSteps', () => {
+    test('watches a STEP filter the saved dependencies do not list, required or not', () => {
+        const step = picker({ filters: [stepFilter('required', true), stepFilter('optional', false)] });
+        expect(entityValuePickerWatchedSteps(step)).toEqual(['required', 'optional']);
+    });
+    test('skips the steps the last save already registered', () => {
+        const step = picker({
+            dependencies: ['required'],
+            filters: [stepFilter('required', true), stepFilter('optional', false)],
+        });
+        expect(entityValuePickerWatchedSteps(step)).toEqual(['optional']);
+    });
+    test('watches the STEP hops of an unsaved path', () => {
+        const step = picker({
+            dependencies: ['saved'],
+            path: [stepPath('saved'), stepPath('added'), { idEntity: 'e', type: EntityValueDataTypes.VALUE }],
+        });
+        expect(entityValuePickerWatchedSteps(step)).toEqual(['added']);
+    });
+    test('ignores filters that read no step, and a path hop with no step picked yet', () => {
+        const step = picker({
+            path: [{ idEntity: 'e', type: EntityValueDataTypes.STEP, any: true }],
+            filters: [
+                { idProperty: 'a', type: EntityValueDataTypes.VALUE, value: 'x' },
+                { idProperty: 'b', type: EntityValueDataTypes.CURRENT_AGENT },
+                { idProperty: 'c', type: EntityValueDataTypes.INTEGRATION, idIntegration: 'i', values: {} },
+            ],
+        });
+        expect(entityValuePickerWatchedSteps(step)).toEqual([]);
+    });
+    test('never repeats a step read twice', () => {
+        const step = picker({
+            path: [stepPath('shared')],
+            filters: [stepFilter('shared', true)],
+        });
+        expect(entityValuePickerWatchedSteps(step)).toEqual(['shared']);
+    });
+});
+describe('entityValuePickerBlockingSteps', () => {
+    test('only the path hops and the required filters block the fetch', () => {
+        const step = picker({
+            path: [stepPath('hop')],
+            filters: [stepFilter('required', true), stepFilter('optional', false)],
+        });
+        expect(entityValuePickerBlockingSteps(step)).toEqual(['hop', 'required']);
+    });
+    test('a saved dependency is already watched deeply, so it is not repeated', () => {
+        const step = picker({
+            dependencies: ['hop', 'required'],
+            path: [stepPath('hop')],
+            filters: [stepFilter('required', true)],
+        });
+        expect(entityValuePickerBlockingSteps(step)).toEqual([]);
+    });
+});

package/dist/FormSteps/StepHooks.js

@@ -8,6 +8,7 @@ import { useController } from 'react-hook-form';
 import ConditionTypes from '../constants/ConditionTypes';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, } from '../constants/FormStepTypes';
 import { SizeChangeContext } from './Utils/@StepFiller/StepFillerContext';
+import { entityValuePickerBlockingSteps } from './EntityValueStep/entityValuePickerWatchedSteps';
 const selectIsDependency = createSelector([
     (state) => state.site.dependencies,
     (_state, step) => step,
@@ -67,11 +68,20 @@ export const selectStepDependencies = createSelector([
 });
 const calcDeepDependencies = (idStep, form, deps = []) => {
     const step = form.steps[idStep];
-    if (step?.dependencies) {
-        for (const dep of step.dependencies) {
-            if (!deps.includes(dep)) {
-                deps.push(...calcDeepDependencies(dep, form, deps), dep);
-            }
+    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);
         }
     }
     return deps;

package/package.json

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