@bach.software/vue-dynamic-form 0.2.0 → 0.3.0

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

@@ -15,6 +15,19 @@ export type FieldMetadata<ExtendedFieldTypes extends string = string, ExtendedPr
      * The maximal occurrence of a value.
      */
     maxOccurs?: number;
+    /**
+     * Controls whether the array automatically pre-fills empty placeholder items up to `minOccurs`
+     * when the form is first rendered and the array is still empty.
+     *
+     * Defaults to `true` — omitting this property has the same effect as setting it to `true`.
+     * Set it explicitly to `false` to suppress auto-filling, which is useful when you want the
+     * user to explicitly add the first item themselves even though `minOccurs` is 1 or higher.
+     *
+     * @example
+     * // Will NOT auto-add an initial item, even though minOccurs is 1:
+     * { name: 'emails', type: 'text', maxOccurs: 5, minOccurs: 1, autoAddMinOccurs: false }
+     */
+    autoAddMinOccurs?: boolean;
     /**
      * Simple restrictions to the data, these are available in XSD and can be applied easily.
      * For more advance validation use the validation property.
@@ -158,14 +171,23 @@ export type FieldMetadata<ExtendedFieldTypes extends string = string, ExtendedPr
      * is re-computed every time the value changes. If you don't use it, a change in value will not re-trigger the reactivity of the computed.
      * @returns A transformed FieldMetadata
      */
-    computedProps?: ((thisField: ComputedPropsType<FieldMetadata<ExtendedFieldTypes, ExtendedProperties>>, fieldValue: Ref<unknown>) => void)[];
+    computedProps?: ((thisField: ComputedPropsFieldType<ExtendedFieldTypes, ExtendedProperties>, fieldValue: Ref<unknown>, childFields: Ref<ReadOnlyFieldType<ExtendedFieldTypes, ExtendedProperties>[]>) => void)[];
     /**
      * Normally the computedProps are not re-calculate if a child value changes. If you need this functionality, you can enable this by
      * setting this property to true.
      */
     computeOnChildValueChange?: boolean;
 } & ExtendedProperties;
-export type ComputedPropsType<T> = Omit<T, 'name' | 'path' | 'children' | 'choice' | 'attributes' | 'fieldOptions' | 'computedProps' | 'maxOccurs'> & 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' | 'isComplexType' | 'computeOnChildValueChange'> & Readonly<{
+    name: string;
+    path: string;
+    parent: FieldMetadata<ExtendedFieldTypes, ExtendedProperties>;
+}>;
+export type ReadOnlyFieldType<ExtendedFieldTypes extends string = string, ExtendedProperties extends object = object> = Readonly<Omit<FieldMetadata<ExtendedFieldTypes, ExtendedProperties>, 'name' | 'path' | 'children' | 'choice'> & {
     name: string;
     path: string;
+    children: ReadOnlyFieldType<ExtendedFieldTypes, ExtendedProperties>[];
+    choice: ReadOnlyFieldType<ExtendedFieldTypes, ExtendedProperties>[];
 }>;
+export type ComputedPropsFieldOf<T extends FieldMetadata<any, any>> = T extends FieldMetadata<infer FT, infer EP> ? ComputedPropsFieldType<FT, EP> : never;
+export type ReadOnlyFieldOf<T extends FieldMetadata<any, any>> = T extends FieldMetadata<infer FT, infer EP> ? ReadOnlyFieldType<FT, EP> : never;

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

@@ -1,3 +1,9 @@
 import type { FieldMetadata } from '../types/FieldMetadata.js';
 import type { RequireOnly } from '../types/RequireOnly.js';
-export type InternalFieldMetadata<Metadata extends FieldMetadata> = RequireOnly<Metadata, 'name' | 'type' | 'minOccurs' | 'maxOccurs'>;
+export type InternalFieldMetadata<Metadata extends FieldMetadata> = RequireOnly<Metadata, 'name' | 'type' | 'minOccurs' | 'maxOccurs'> & {
+    /**
+     * Internal hash computed by the system to track meaningful changes to the computed field.
+     * Do not set this manually — it is overwritten after every computedProps run.
+     */
+    _hash?: string;
+};

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

@@ -1,5 +1,6 @@
 export interface MetadataConfiguration {
     fieldTypes: readonly string[];
     extendedProperties: object;
+    slotProperties: object;
     valueTypes: Record<string, any>;
 }

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

@@ -0,0 +1 @@
+import '../../core/validation';

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

@@ -0,0 +1,16 @@
+import type { GetMetadataType } from '../../types/GetMetadataType';
+export type TestMetadata = GetMetadataType<typeof _metadata>;
+declare const _metadata: {
+    fieldTypes: readonly ("default" | "text")[];
+    extendedProperties: {
+        visited?: boolean;
+        visitOrder?: number;
+    };
+    slotProperties: object;
+    valueTypes: {
+        text: string;
+    } & {
+        default: string;
+    };
+};
+export {};

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

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

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

@@ -0,0 +1,7 @@
+import type { FieldMetadata } from '../types/FieldMetadata';
+/**
+ * Creates a deterministic hash of all mutable field properties (those that computedProps can change).
+ * Excludes structural/immutable properties: name, path, children, choice, attributes,
+ * fieldOptions, computedProps, maxOccurs, parent, and _hash itself.
+ */
+export declare function hashField(field: FieldMetadata): string;

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

@@ -0,0 +1,10 @@
+import type { FieldMetadata } from '../types/FieldMetadata';
+/**
+ * Recursively walks a `FieldMetadata` tree (visiting `children` and `choice`) and applies
+ * `callbackFunc` to every node, returning the transformed tree.
+ *
+ * The callback receives a shallow clone of each node, so mutations inside the callback do not
+ * affect the original metadata. `children` and `choice` on the returned node are replaced with
+ * the recursively-mapped results after the callback runs.
+ */
+export declare function mapEachMetadataItem<ExtendedFieldTypes extends string = string, ExtendedProperties extends object = object>(metadata: FieldMetadata<ExtendedFieldTypes, ExtendedProperties>, callbackFunc: (item: FieldMetadata<ExtendedFieldTypes, ExtendedProperties>) => FieldMetadata<ExtendedFieldTypes, ExtendedProperties>): FieldMetadata<ExtendedFieldTypes, ExtendedProperties>;