@bach.software/vue-dynamic-form 0.7.0 → 0.8.0

package/dist/src/components/__tests__/DynamicFormItem.test-helpers.d.ts

@@ -9,6 +9,12 @@ export declare function renderCount(wrapper: ReturnType<typeof mount>, path: str
 export declare function setupState(wrapper: ReturnType<typeof mount>, path: string): Record<string, any> | undefined;
 /** Reads the number of times `combinedValidation` was recomputed for a given field. Returns -1 if the field is not found. */
 export declare function constructValidationCount(wrapper: ReturnType<typeof mount>, path: string): number;
+/**
+ * Reads the current `combinedValidation` rules array reference for a given field, for
+ * reference-identity assertions. `vm.$.setupState` is `proxyRefs(...)`, which already unwraps
+ * the ref on access, so no trailing `.value` is needed here.
+ */
+export declare function combinedValidationRules(wrapper: ReturnType<typeof mount>, path: string): unknown;
 /** Reads the number of times `computedField` was recomputed for a given field. Returns -1 if the field is not found. */
 export declare function fieldComputeCount(wrapper: ReturnType<typeof mount>, path: string): number;
 /** Reads the number of times the `field` computed (bound to `props.fieldMetadata`) was recomputed. Returns -1 if the field is not found. */
@@ -17,5 +23,7 @@ export declare function fieldChangedCount(wrapper: ReturnType<typeof mount>, pat
 export declare function valueChangedCount(wrapper: ReturnType<typeof mount>, path: string): number;
 /** Reads the number of times the notify value change fired for a given field. Returns -1 if the field is not found. */
 export declare function notifyValueUpdateCount(wrapper: ReturnType<typeof mount>, path: string): number;
+/** Reads the number of times the non-input subtree silent-validate watcher actually ran (not suppressed) for a given field. Returns -1 if the field is not found. */
+export declare function subtreeValidateCount(wrapper: ReturnType<typeof mount>, path: string): number;
 /** Returns the current vee-validate form values from the TestForm wrapper. */
 export declare function formValues(wrapper: ReturnType<typeof mount>): Record<string, any>;

package/dist/src/components/__tests__/DynamicFormItemArray.test-helpers.d.ts

@@ -7,3 +7,5 @@ import type { mount } from '@vue/test-utils';
 export declare function setupState(wrapper: ReturnType<typeof mount>, path: string): Record<string, any> | undefined;
 /** Reads how many times the array's `combinedValidation` computed has run. Returns -1 if the array is not found. */
 export declare function arrayConstructValidationCount(wrapper: ReturnType<typeof mount>, path: string): number;
+/** Reads the array's own `meta.valid`, kept live by the silent validate in the values watcher. Returns undefined if the array is not found. */
+export declare function arrayMetaValid(wrapper: ReturnType<typeof mount>, path: string): boolean | undefined;

package/dist/src/components/__tests__/DynamicFormItemChoice.test-helpers.d.ts

@@ -62,6 +62,15 @@ export declare function canAddChoiceOccurrence(wrapper: ReturnType<typeof mount>
 export declare function usedChoiceOccurrences(wrapper: ReturnType<typeof mount>, choicePath: string): number | undefined;
 /** Reads the number of rules currently present in `combinedValidation` for the choice at `path`. */
 export declare function combinedValidationCount(wrapper: ReturnType<typeof mount>, path: string): number;
+/**
+ * Reads a branch's own raw form value directly off the choice's `branchValueRefs`, resolving
+ * `branchKey` to its internal numeric index via the choice's own metadata. Unlike the fixture's
+ * rendered input, this reads the value even when the branch isn't mounted (e.g. before any
+ * `addChoiceOccurrence` call).
+ */
+export declare function branchValue(wrapper: ReturnType<typeof mount>, choicePath: string, branchKey: string): unknown;
+/** Reads the `effectiveValuesCount` computed (feeding `xsd_choiceMinOccurs`) for the choice at `path`. */
+export declare function effectiveValuesCount(wrapper: ReturnType<typeof mount>, path: string): number | undefined;
 /** Reads the `maxOccursTotalBreach` computed (the offending branch's cap, or undefined) for the choice at `path`. */
 export declare function maxOccursTotalBreach(wrapper: ReturnType<typeof mount>, path: string): number | undefined;
 /**

package/dist/src/examples/__tests__/TestFormTemplate.testcases.d.ts

@@ -471,6 +471,62 @@ export declare const restrictionsSampleValues: {
         customValidation: string;
     };
 };
+export declare const liveValidityTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    initialValues: GenericObject;
+    keepValuesOnUnmount: boolean | undefined;
+    settings: DynamicFormSettings | undefined;
+    initialEdit: boolean | undefined;
+    hideFieldsWithoutValue: boolean | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const liveValiditySampleValues: {
+    contact: {
+        email: string;
+    };
+};
 export declare const arrayOccurrenceTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     initialValues: {
         type: PropType<GenericObject>;
@@ -801,6 +857,64 @@ export declare const explicitChoiceSampleValues: {
         };
     };
 };
+export declare const presenceValueTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    initialValues: GenericObject;
+    keepValuesOnUnmount: boolean | undefined;
+    settings: DynamicFormSettings | undefined;
+    initialEdit: boolean | undefined;
+    hideFieldsWithoutValue: boolean | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const presenceValueSampleValues: {
+    checkoutSection: {
+        checkout: {
+            express: boolean;
+        };
+    };
+};
 export declare const preserveOnSwitchTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     initialValues: {
         type: PropType<GenericObject>;
@@ -861,6 +975,66 @@ export declare const preserveOnSwitchSampleValues: {
         };
     };
 };
+export declare const choiceSelectionResetTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    initialValues: GenericObject;
+    keepValuesOnUnmount: boolean | undefined;
+    settings: DynamicFormSettings | undefined;
+    initialEdit: boolean | undefined;
+    hideFieldsWithoutValue: boolean | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const choiceSelectionResetSampleValues: {
+    resetSection: {
+        contact: {
+            email: {
+                address: string;
+            };
+        };
+    };
+};
 export declare const explicitRepeatableChoiceTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     initialValues: {
         type: PropType<GenericObject>;
@@ -1179,6 +1353,65 @@ export declare const computedPropsSampleValues: {
         childA: string;
     };
 };
+export declare const dynamicRulesTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    initialValues: {
+        type: PropType<GenericObject>;
+        default: undefined;
+    };
+    initialEdit: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    hideFieldsWithoutValue: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+    settings: {
+        type: PropType<DynamicFormSettings | undefined>;
+        default: undefined;
+    };
+    keepValuesOnUnmount: {
+        type: PropType<boolean | undefined>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    initialValues: GenericObject;
+    keepValuesOnUnmount: boolean | undefined;
+    settings: DynamicFormSettings | undefined;
+    initialEdit: boolean | undefined;
+    hideFieldsWithoutValue: boolean | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export declare const dynamicRulesSampleValues: {
+    dynamicRules: {
+        country: string;
+        postalCode: string;
+        businessOrder: boolean;
+        vatNumber: string;
+    };
+};
 export declare const attributesTestCase: import("vue").Raw<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     initialValues: {
         type: PropType<GenericObject>;

package/dist/src/index.d.ts

@@ -16,6 +16,7 @@ export * from './types/MetadataConfiguration';
 export * from './types/RequireOnly';
 export * from './types/ValidationMessage';
 export * from './utils/checkTreeHasValue';
+export * from './utils/isPathInSection';
 export * from './utils/mapEachMetadataItem';
 export * from './utils/removeNullValues';
 export * from './utils/setInPath';

package/dist/src/types/FieldMetadata.d.ts

@@ -219,6 +219,37 @@ export type FieldMetadata<ExtendedFieldTypes extends string = string, ExtendedPr
      * `computedProps` cannot flip it mid-form.
      */
     wizard?: boolean | WizardConfig;
+    /**
+     * The value stored in the form when the user selects this choice branch.
+     *
+     * Normally a branch has fields, and filling those in is what marks the branch as selected.
+     * A branch without any fields has nothing to fill in, so without help its value stays
+     * `undefined`: validation thinks nothing was selected, and the selection is lost when the
+     * form values are submitted or loaded back in. Set `presenceValue` to fix that: the moment
+     * the user picks the branch, this value is written as the branch's value, so the selection
+     * validates and survives a save/reload round-trip.
+     *
+     * Any JSON-serializable value works (`true`, `'selected'`, `{}`, ...), except `null` and the
+     * empty string: those read as selected but still fail the branch's own required check, so the
+     * selection would show an error. When the form loads existing values, the branch shows as
+     * selected whenever its value is not `undefined`.
+     *
+     * Selecting the branch is a session action: `resetForm()` clears a marker written by a click
+     * this session and deselects the branch, while a marker that was part of the loaded values is
+     * restored and keeps the branch selected.
+     *
+     * Only useful on a non-repeatable (`maxOccurs: 1`) branch without `children`, inside a
+     * `choice` with `explicitChoiceSelection: true`. On other branches it is ignored, because
+     * their values already show that they were selected (a repeated branch has its occurrences,
+     * a branch with children has its filled-in fields). Using it on a branch with `children`
+     * logs a development warning.
+     *
+     * Two things to keep in mind:
+     * - Prefer a non-empty value: if you clean up the submitted values with `removeNullValues`,
+     *   an empty `{}` or `[]` marker is removed and the selection is lost.
+     * - This is static metadata only; `computedProps` cannot set or change it at runtime.
+     */
+    presenceValue?: unknown;
     /**
      * Attributes are additional metadata that can be attached to a field.
      * These attributes can be used to provide extra information about the field,
@@ -300,7 +331,7 @@ export interface WizardGotoStepOptions {
     allowForwardJump?: boolean;
     validateOnJump?: boolean;
 }
-export type ComputedPropsFieldType<ExtendedFieldTypes extends string = string, ExtendedProperties extends object = object> = Omit<FieldMetadata<ExtendedFieldTypes, ExtendedProperties>, 'name' | 'path' | 'parent' | 'children' | 'choice' | 'attributes' | 'fieldOptions' | 'computedProps' | 'maxOccurs' | 'maxOccursTotal' | 'isComplexType' | 'computeOnChildValueChange' | 'explicitChoiceSelection' | 'preserveOnSwitch' | 'displayOrder' | 'preserveOrder' | 'wizard'> & Readonly<{
+export type ComputedPropsFieldType<ExtendedFieldTypes extends string = string, ExtendedProperties extends object = object> = Omit<FieldMetadata<ExtendedFieldTypes, ExtendedProperties>, 'name' | 'path' | 'parent' | 'children' | 'choice' | 'attributes' | 'fieldOptions' | 'computedProps' | 'maxOccurs' | 'maxOccursTotal' | 'isComplexType' | 'computeOnChildValueChange' | 'explicitChoiceSelection' | 'preserveOnSwitch' | 'displayOrder' | 'preserveOrder' | 'wizard' | 'presenceValue'> & Readonly<{
     name: string;
     path: string;
     parent: FieldMetadata<ExtendedFieldTypes, ExtendedProperties>;

package/dist/src/utils/__tests__/deepEqual.test.d.ts

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

package/dist/src/utils/__tests__/hashField.test.d.ts

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

package/dist/src/utils/__tests__/isPathInSection.test.d.ts

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

package/dist/src/utils/buildRestrictionValidations.d.ts

@@ -0,0 +1,11 @@
+import type { GenericValidateFunction } from 'vee-validate';
+import type { DynamicFormSettings } from '../types/DynamicFormSettings';
+import type { FieldMetadata } from '../types/FieldMetadata';
+/**
+ * Builds the XSD restriction rules plus any custom validation declared directly on a field,
+ * shared by every place that registers a vee-validate field for that metadata (a plain field, or
+ * a choice-hosting field whose own restriction/validation is folded into its nested choice).
+ * Required/minOccurs is intentionally not part of this: it is a separate concern each caller
+ * decides for itself.
+ */
+export declare function buildRestrictionValidations(restriction: FieldMetadata['restriction'] | undefined, validation: FieldMetadata['validation'], messages: DynamicFormSettings['messages'] | undefined): GenericValidateFunction[];

package/dist/src/utils/deepEqual.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compares two values by content instead of by reference. Primitives, plain objects, arrays and
+ * Dates are compared recursively; everything else (functions, class instances, Maps, ...) only
+ * counts as equal when it is the exact same reference.
+ *
+ * Mirrors the value scope of `deepCloneValue`. Useful to detect "rebuilt but identical" objects,
+ * such as metadata that computedProps functions recreate on every run.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;

package/dist/src/utils/isPathInSection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks whether a field path falls at or under a section path.
+ * Matches the section itself, `section.child`, and `section[0]`, but not
+ * unrelated paths that happen to share a prefix string (e.g. `addressLine` vs `address`).
+ *
+ * @param path - Dot-notated field path (e.g. `'address.street'` or `'contacts[0].email'`)
+ * @param sectionPath - Dot-notated path prefix (e.g. `'address'` or `'contacts[0]'`)
+ */
+export declare function isPathInSection(path: string, sectionPath: string): boolean;

package/dist/src/utils/removeNullValues.d.ts

@@ -1,5 +1,9 @@
 /**
  * Removes all null value's from object properties and array's.
+ *
+ * Note: an empty-object or empty-array `presenceValue` marker on a choice branch is stripped
+ * back to `undefined` by this cleanup, same as any other empty object/array; use a non-empty
+ * marker if the branch's selection must survive this round-trip.
  * @param element any value
  */
 export declare function removeNullValues<T>(element: T): T | undefined;