@blueprint-ts/core 4.1.0-beta.6 → 5.0.0

package/dist/vue/forms/BaseForm.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { reactive, computed, toRaw, watch } from 'vue';
 import { camelCase, upperFirst, cloneDeep, debounce, isEqual } from 'lodash-es';
 import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
@@ -57,7 +48,6 @@ function restoreSerializedPropertyAwareValue(value) {
     return value;
 }
 export function propertyAwareToRaw(propertyAwareObject) {
-    var _a;
     if (Array.isArray(propertyAwareObject)) {
         return propertyAwareObject.map((item) => propertyAwareToRaw(item));
     }
@@ -71,7 +61,7 @@ export function propertyAwareToRaw(propertyAwareObject) {
             continue;
         }
         const value = record[key];
-        const modelValue = isRecord(value) ? (_a = value.model) === null || _a === void 0 ? void 0 : _a.value : undefined;
+        const modelValue = isRecord(value) ? value.model?.value : undefined;
         if (modelValue !== undefined) {
             result[key] = modelValue;
             continue;
@@ -100,7 +90,7 @@ function deepMergeArrays(target, source) {
             return t;
         }
         if (t && typeof t === 'object' && s && typeof s === 'object') {
-            return shallowMerge(Object.assign({}, t), s);
+            return shallowMerge({ ...t }, s);
         }
         return s;
     });
@@ -150,6 +140,27 @@ function restorePropertyAwareStructure(defaults, value) {
  * (We assume that for every key in RequestBody there is a corresponding key in FormBody.)
  */
 export class BaseForm {
+    options;
+    state;
+    dirty;
+    touched;
+    original;
+    _model;
+    _errors = reactive({});
+    _asyncErrors = reactive({});
+    _hasErrors;
+    append = [];
+    ignore = [];
+    errorMap = {};
+    rules = {};
+    validationGroups = {};
+    fieldDependencies = new Map();
+    arrayWrapperCache = new Map();
+    arrayItemWrapperCache = new Map();
+    asyncValidationDebouncers = new Map();
+    pendingAsyncValidationContexts = new Map();
+    asyncValidationTokens = reactive({});
+    persistKey;
     /**
      * Returns the persistence driver to use.
      * The default is a NonPersistentDriver.
@@ -159,6 +170,12 @@ export class BaseForm {
     getPersistenceDriver(_suffix) {
         return new NonPersistentDriver();
     }
+    getActivePersistenceDriver() {
+        if (this.options?.persist !== true) {
+            return undefined;
+        }
+        return this.getPersistenceDriver(this.options.persistSuffix);
+    }
     getPersistenceRestorePolicy() {
         return new StrictPersistenceRestorePolicy();
     }
@@ -169,9 +186,9 @@ export class BaseForm {
         if (!this.shouldLogPersistenceDebug()) {
             return;
         }
-        const suffixLabel = event.persistSuffix ? ` (${event.persistSuffix})` : '';
+        const context = event.persistSuffix ? `${event.formName}, ${event.persistSuffix}` : event.formName;
         const details = event.details ? ` ${JSON.stringify(event.details)}` : '';
-        console.debug(`[BaseForm persistence] ${event.formName}${suffixLabel}: ${event.action} (${event.reason})${details}`);
+        console.debug(`[BaseForm persistence] ${event.persistKey} (${context}): ${event.action} (${event.reason})${details}`);
     }
     /**
      * Helper: recursively computes the dirty state for a value based on the original.
@@ -231,12 +248,14 @@ export class BaseForm {
         this.state[key] = new PropertyAwareArray(values);
     }
     persistState(driver) {
-        var _a, _b;
-        if (((_a = this.options) === null || _a === void 0 ? void 0 : _a.persist) === false) {
+        if (this.options?.persist !== true) {
             return;
         }
-        const persistDriver = driver !== null && driver !== void 0 ? driver : this.getPersistenceDriver((_b = this.options) === null || _b === void 0 ? void 0 : _b.persistSuffix);
-        persistDriver.set(this.constructor.name, {
+        const persistDriver = driver ?? this.getActivePersistenceDriver();
+        if (!persistDriver) {
+            return;
+        }
+        persistDriver.set(this.resolvePersistKey(), {
             state: toRaw(this.state),
             original: toRaw(this.original),
             dirty: toRaw(this.dirty),
@@ -259,24 +278,23 @@ export class BaseForm {
      * This identifies which fields need to be revalidated when another field changes
      */
     buildFieldDependencies() {
-        var _a, _b, _c, _d;
         for (const field in this.rules) {
             if (Object.prototype.hasOwnProperty.call(this.rules, field)) {
-                const fieldRules = ((_a = this.rules[field]) === null || _a === void 0 ? void 0 : _a.rules) || [];
+                const fieldRules = this.rules[field]?.rules || [];
                 for (const rule of fieldRules) {
                     for (const dependencyField of rule.dependsOn) {
                         if (!this.fieldDependencies.has(dependencyField)) {
                             this.fieldDependencies.set(dependencyField, new Set());
                         }
-                        (_b = this.fieldDependencies.get(dependencyField)) === null || _b === void 0 ? void 0 : _b.add(field);
+                        this.fieldDependencies.get(dependencyField)?.add(field);
                     }
-                    const bidirectionalFields = (_c = rule.getBidirectionalFields) === null || _c === void 0 ? void 0 : _c.call(rule);
+                    const bidirectionalFields = rule.getBidirectionalFields?.();
                     if (bidirectionalFields && bidirectionalFields.length > 0) {
                         for (const bidirectionalField of bidirectionalFields) {
                             if (!this.fieldDependencies.has(field)) {
                                 this.fieldDependencies.set(field, new Set());
                             }
-                            (_d = this.fieldDependencies.get(field)) === null || _d === void 0 ? void 0 : _d.add(bidirectionalField);
+                            this.fieldDependencies.get(field)?.add(bidirectionalField);
                         }
                     }
                 }
@@ -306,35 +324,24 @@ export class BaseForm {
         }
     }
     constructor(defaults, options) {
-        var _a;
         this.options = options;
-        this._errors = reactive({});
-        this._asyncErrors = reactive({});
-        this.append = [];
-        this.ignore = [];
-        this.errorMap = {};
-        this.rules = {};
-        this.validationGroups = {};
-        this.fieldDependencies = new Map();
-        this.arrayWrapperCache = new Map();
-        this.arrayItemWrapperCache = new Map();
-        this.asyncValidationDebouncers = new Map();
-        this.pendingAsyncValidationContexts = new Map();
-        this.asyncValidationTokens = reactive({});
-        const persist = (options === null || options === void 0 ? void 0 : options.persist) !== false;
+        const persist = options?.persist === true;
+        this.persistKey = persist ? this.requirePersistKey(options) : options?.persistKey;
         let initialData;
-        const driver = this.getPersistenceDriver(options === null || options === void 0 ? void 0 : options.persistSuffix);
-        if (persist) {
-            const persisted = (_a = driver.get(this.constructor.name)) !== null && _a !== void 0 ? _a : null;
+        const driver = persist ? this.getPersistenceDriver(options?.persistSuffix) : undefined;
+        if (persist && driver) {
+            const persisted = driver.get(this.resolvePersistKey()) ?? null;
             const restoreDecision = this.getPersistenceRestorePolicy().resolve({
                 formName: this.constructor.name,
-                persistSuffix: options === null || options === void 0 ? void 0 : options.persistSuffix,
+                persistKey: this.resolvePersistKey(),
+                persistSuffix: options?.persistSuffix,
                 defaults,
                 persisted
             });
             this.logPersistenceDebug({
                 formName: this.constructor.name,
-                persistSuffix: options === null || options === void 0 ? void 0 : options.persistSuffix,
+                persistKey: this.resolvePersistKey(),
+                persistSuffix: options?.persistSuffix,
                 action: restoreDecision.action,
                 reason: restoreDecision.reason,
                 details: restoreDecision.details
@@ -352,7 +359,7 @@ export class BaseForm {
                 this.dirty = init.dirty;
                 this.touched = init.touched;
                 if (restoreDecision.action === 'discard') {
-                    driver.remove(this.constructor.name);
+                    driver.remove(this.resolvePersistKey());
                 }
             }
         }
@@ -400,11 +407,23 @@ export class BaseForm {
             }
         }
         this._hasErrors = computed(() => Object.keys(this.flattenErrors()).length > 0);
-        if (persist) {
+        if (persist && driver) {
             watch(() => this.state, () => this.persistState(driver), { deep: true, immediate: true });
         }
         this.validate();
     }
+    requirePersistKey(options) {
+        if (!options?.persistKey) {
+            throw new Error('BaseForm persistence requires a stable persistKey option.');
+        }
+        return options.persistKey;
+    }
+    resolvePersistKey() {
+        if (!this.persistKey) {
+            throw new Error('BaseForm persistence requires a stable persistKey option.');
+        }
+        return this.persistKey;
+    }
     defineRules() {
         return {};
     }
@@ -429,35 +448,32 @@ export class BaseForm {
     }
     hasAsyncRules(field) {
         const fieldConfig = this.rules[field];
-        if (!(fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.rules) || fieldConfig.rules.length === 0) {
+        if (!fieldConfig?.rules || fieldConfig.rules.length === 0) {
             return false;
         }
         return fieldConfig.rules.some((rule) => rule.validateAsync !== BaseRule.prototype.validateAsync);
     }
     bumpAsyncValidationToken(field) {
-        var _a;
         const fieldKey = String(field);
-        const nextToken = ((_a = this.asyncValidationTokens[fieldKey]) !== null && _a !== void 0 ? _a : 0) + 1;
+        const nextToken = (this.asyncValidationTokens[fieldKey] ?? 0) + 1;
         this.asyncValidationTokens[fieldKey] = nextToken;
         return nextToken;
     }
     cancelPendingAsyncValidations() {
-        var _a;
         for (const debouncer of this.asyncValidationDebouncers.values()) {
             debouncer.cancel();
         }
         this.pendingAsyncValidationContexts.clear();
         for (const fieldKey of Object.keys(this.asyncValidationTokens)) {
-            this.asyncValidationTokens[fieldKey] = ((_a = this.asyncValidationTokens[fieldKey]) !== null && _a !== void 0 ? _a : 0) + 1;
+            this.asyncValidationTokens[fieldKey] = (this.asyncValidationTokens[fieldKey] ?? 0) + 1;
         }
     }
     scheduleAsyncValidation(field, context) {
-        var _a, _b, _c;
         if (!this.hasAsyncRules(field)) {
             return;
         }
         const token = this.bumpAsyncValidationToken(field);
-        const debounceMs = (_c = (_b = (_a = this.rules[field]) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.asyncDebounceMs) !== null && _c !== void 0 ? _c : 0;
+        const debounceMs = this.rules[field]?.options?.asyncDebounceMs ?? 0;
         this.pendingAsyncValidationContexts.set(field, { token, context });
         if (debounceMs <= 0) {
             void this.executeScheduledAsyncValidation(field).catch(() => undefined);
@@ -472,14 +488,16 @@ export class BaseForm {
         }
         debouncer();
     }
-    executeScheduledAsyncValidation(field) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pending = this.pendingAsyncValidationContexts.get(field);
-            if (pending === undefined) {
-                return;
-            }
-            yield this.runFieldAsyncValidation(field, Object.assign(Object.assign({}, pending.context), { skipSyncValidation: true, skipAsyncValidation: true }), pending.token);
-        });
+    async executeScheduledAsyncValidation(field) {
+        const pending = this.pendingAsyncValidationContexts.get(field);
+        if (pending === undefined) {
+            return;
+        }
+        await this.runFieldAsyncValidation(field, {
+            ...pending.context,
+            skipSyncValidation: true,
+            skipAsyncValidation: true
+        }, pending.token);
     }
     flattenErrorValue(value, path, flattened) {
         if (value === undefined) {
@@ -538,15 +556,13 @@ export class BaseForm {
         return merged;
     }
     flattenErrors() {
-        var _a;
         const flattened = this.flattenErrorsFromBag(this._errors);
         for (const [key, messages] of Object.entries(this.flattenErrorsFromBag(this._asyncErrors))) {
-            flattened[key] = this.mergeErrorMessages((_a = flattened[key]) !== null && _a !== void 0 ? _a : [], messages);
+            flattened[key] = this.mergeErrorMessages(flattened[key] ?? [], messages);
         }
         return flattened;
     }
     applyErrors(errorsData, useErrorMap, targetBag = this._errors) {
-        var _a, _b, _c;
         for (const serverKey in errorsData) {
             if (!Object.prototype.hasOwnProperty.call(errorsData, serverKey)) {
                 continue;
@@ -557,7 +573,7 @@ export class BaseForm {
             }
             let targetKeys = [serverKey];
             if (useErrorMap) {
-                const mapping = (_a = this.errorMap) === null || _a === void 0 ? void 0 : _a[serverKey];
+                const mapping = this.errorMap?.[serverKey];
                 if (mapping) {
                     targetKeys = Array.isArray(mapping) ? mapping : [mapping];
                 }
@@ -565,8 +581,8 @@ export class BaseForm {
             for (const targetKey of targetKeys) {
                 const parts = targetKey.split('.');
                 if (parts.length > 1) {
-                    const topKey = (_b = parts[0]) !== null && _b !== void 0 ? _b : '';
-                    const indexPart = (_c = parts[1]) !== null && _c !== void 0 ? _c : '';
+                    const topKey = parts[0] ?? '';
+                    const indexPart = parts[1] ?? '';
                     const index = Number.parseInt(indexPart, 10);
                     if (!topKey) {
                         targetBag[targetKey] = errorMessage;
@@ -957,11 +973,10 @@ export class BaseForm {
                         const index = this.resolveArrayItemIndex(field, item);
                         return index < 0 ? [] : this.getArrayItemFieldErrors(String(field), index, [innerKey, ...path].join('.'));
                     }, (path) => {
-                        var _a;
                         const index = this.resolveArrayItemIndex(field, item);
                         return index < 0
                             ? false
-                            : this.getNestedDirtyValue((_a = this.dirty[field]) === null || _a === void 0 ? void 0 : _a[index], [innerKey, ...path]);
+                            : this.getNestedDirtyValue(this.dirty[field]?.[index], [innerKey, ...path]);
                     }, () => this.touched[field] || false);
                     continue;
                 }
@@ -1011,11 +1026,10 @@ export class BaseForm {
      * @param field The field to mark as touched
      */
     touch(field) {
-        var _a, _b, _c;
         this.touched[field] = true;
         const fieldConfig = this.rules[field];
         if (fieldConfig) {
-            const mode = (_b = (_a = fieldConfig.options) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : ValidationMode.DEFAULT;
+            const mode = fieldConfig.options?.mode ?? ValidationMode.DEFAULT;
             if (mode & ValidationMode.ON_TOUCH) {
                 this.validateField(field, {
                     isSubmitting: false,
@@ -1023,7 +1037,7 @@ export class BaseForm {
                 });
             }
         }
-        if (((_c = this.options) === null || _c === void 0 ? void 0 : _c.persist) !== false) {
+        if (this.options?.persist === true) {
             this.persistState();
         }
     }
@@ -1036,16 +1050,15 @@ export class BaseForm {
         return !!this.touched[field];
     }
     validateField(field, context = {}) {
-        var _a, _b;
         const emptyErrors = [];
         const errorKey = String(field);
         this._errors[errorKey] = emptyErrors;
         const value = this.state[field];
         const fieldConfig = this.rules[field];
-        if (!(fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.rules) || fieldConfig.rules.length === 0) {
+        if (!fieldConfig?.rules || fieldConfig.rules.length === 0) {
             return; // No rules to validate
         }
-        const mode = (_b = (_a = fieldConfig.options) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : ValidationMode.DEFAULT;
+        const mode = fieldConfig.options?.mode ?? ValidationMode.DEFAULT;
         const isDirty = context.isDirty !== undefined ? context.isDirty : this.isDirty(field);
         const isTouched = context.isTouched !== undefined ? context.isTouched : this.isTouched(field);
         const shouldValidate = (context.isSubmitting && mode & ValidationMode.ON_SUBMIT) ||
@@ -1066,7 +1079,6 @@ export class BaseForm {
         }
     }
     validate(isSubmitting = false, options = {}) {
-        var _a;
         let isValid = true;
         this.clearSyncErrors();
         for (const field in this.rules) {
@@ -1075,7 +1087,7 @@ export class BaseForm {
                     isSubmitting,
                     isDependentChange: false,
                     isTouched: this.isTouched(field),
-                    skipAsyncValidation: (_a = options.skipAsyncValidation) !== null && _a !== void 0 ? _a : false
+                    skipAsyncValidation: options.skipAsyncValidation ?? false
                 });
                 const fieldErrors = this._errors[String(field)];
                 if (isErrorMessages(fieldErrors) && fieldErrors.length > 0) {
@@ -1086,7 +1098,6 @@ export class BaseForm {
         return isValid;
     }
     validateGroup(group, isSubmitting = false, options = {}) {
-        var _a;
         const fields = this.getValidationGroupFields(group);
         if (fields.length === 0) {
             return true;
@@ -1097,81 +1108,78 @@ export class BaseForm {
                 isSubmitting,
                 isDependentChange: false,
                 isTouched: this.isTouched(field),
-                skipAsyncValidation: (_a = options.skipAsyncValidation) !== null && _a !== void 0 ? _a : false
+                skipAsyncValidation: options.skipAsyncValidation ?? false
             });
         }
         return !this.hasErrorsInGroup(group);
     }
-    runFieldAsyncValidation(field_1) {
-        return __awaiter(this, arguments, void 0, function* (field, context = {}, expectedToken) {
-            var _a;
-            if (!context.skipSyncValidation) {
-                this.validateField(field, Object.assign(Object.assign({}, context), { skipAsyncValidation: true }));
-            }
-            const fieldConfig = this.rules[field];
-            if (!(fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.rules) || fieldConfig.rules.length === 0) {
-                return !Object.keys(this.flattenErrors()).some((errorKey) => this.matchesValidationGroupPath(errorKey, String(field)));
-            }
-            const asyncPaths = fieldConfig.rules.flatMap((rule) => rule.getAsyncValidationPaths(field, this.state));
-            const payload = this.buildPayload();
-            const nextAsyncErrors = {};
-            for (const rule of fieldConfig.rules) {
-                const errors = yield rule.validateAsync(this.state[field], this.state, {
-                    field: String(field),
-                    payload,
-                    isSubmitting: (_a = context.isSubmitting) !== null && _a !== void 0 ? _a : false
-                });
-                if (errors && Object.keys(errors).length > 0) {
-                    this.applyErrors(errors, false, nextAsyncErrors);
-                }
-            }
-            if (expectedToken !== undefined && this.asyncValidationTokens[String(field)] !== expectedToken) {
-                return !Object.keys(this.flattenErrors()).some((errorKey) => this.matchesValidationGroupPath(errorKey, String(field)));
-            }
-            this.clearErrorBagPaths(this._asyncErrors, asyncPaths);
-            for (const [key, messages] of Object.entries(this.flattenErrorsFromBag(nextAsyncErrors))) {
-                this.applyErrors({ [key]: messages }, false, this._asyncErrors);
+    async runFieldAsyncValidation(field, context = {}, expectedToken) {
+        if (!context.skipSyncValidation) {
+            this.validateField(field, {
+                ...context,
+                skipAsyncValidation: true
+            });
+        }
+        const fieldConfig = this.rules[field];
+        if (!fieldConfig?.rules || fieldConfig.rules.length === 0) {
+            return !Object.keys(this.flattenErrors()).some((errorKey) => this.matchesValidationGroupPath(errorKey, String(field)));
+        }
+        const asyncPaths = fieldConfig.rules.flatMap((rule) => rule.getAsyncValidationPaths(field, this.state));
+        const payload = this.buildPayload();
+        const nextAsyncErrors = {};
+        for (const rule of fieldConfig.rules) {
+            const errors = await rule.validateAsync(this.state[field], this.state, {
+                field: String(field),
+                payload,
+                isSubmitting: context.isSubmitting ?? false
+            });
+            if (errors && Object.keys(errors).length > 0) {
+                this.applyErrors(errors, false, nextAsyncErrors);
             }
+        }
+        if (expectedToken !== undefined && this.asyncValidationTokens[String(field)] !== expectedToken) {
             return !Object.keys(this.flattenErrors()).some((errorKey) => this.matchesValidationGroupPath(errorKey, String(field)));
-        });
-    }
-    validateFieldAsync(field_1) {
-        return __awaiter(this, arguments, void 0, function* (field, context = {}) {
-            const token = this.bumpAsyncValidationToken(field);
-            return yield this.runFieldAsyncValidation(field, Object.assign(Object.assign({}, context), { skipAsyncValidation: true }), token);
-        });
+        }
+        this.clearErrorBagPaths(this._asyncErrors, asyncPaths);
+        for (const [key, messages] of Object.entries(this.flattenErrorsFromBag(nextAsyncErrors))) {
+            this.applyErrors({ [key]: messages }, false, this._asyncErrors);
+        }
+        return !Object.keys(this.flattenErrors()).some((errorKey) => this.matchesValidationGroupPath(errorKey, String(field)));
     }
-    validateAsync() {
-        return __awaiter(this, arguments, void 0, function* (isSubmitting = false) {
-            const isSyncValid = this.validate(isSubmitting, { skipAsyncValidation: true });
-            for (const field in this.rules) {
-                if (Object.prototype.hasOwnProperty.call(this.rules, field)) {
-                    yield this.validateFieldAsync(field, {
-                        isSubmitting,
-                        isTouched: this.isTouched(field),
-                        skipSyncValidation: true
-                    });
-                }
-            }
-            return isSyncValid && !this.hasErrors();
-        });
+    async validateFieldAsync(field, context = {}) {
+        const token = this.bumpAsyncValidationToken(field);
+        return await this.runFieldAsyncValidation(field, {
+            ...context,
+            skipAsyncValidation: true
+        }, token);
     }
-    validateGroupAsync(group_1) {
-        return __awaiter(this, arguments, void 0, function* (group, isSubmitting = false) {
-            const fields = this.getValidationGroupFields(group);
-            if (fields.length === 0) {
-                return true;
-            }
-            const isSyncValid = this.validateGroup(group, isSubmitting, { skipAsyncValidation: true });
-            for (const field of fields) {
-                yield this.validateFieldAsync(field, {
+    async validateAsync(isSubmitting = false) {
+        const isSyncValid = this.validate(isSubmitting, { skipAsyncValidation: true });
+        for (const field in this.rules) {
+            if (Object.prototype.hasOwnProperty.call(this.rules, field)) {
+                await this.validateFieldAsync(field, {
                     isSubmitting,
                     isTouched: this.isTouched(field),
                     skipSyncValidation: true
                 });
             }
-            return isSyncValid && !this.hasErrorsInGroup(group);
-        });
+        }
+        return isSyncValid && !this.hasErrors();
+    }
+    async validateGroupAsync(group, isSubmitting = false) {
+        const fields = this.getValidationGroupFields(group);
+        if (fields.length === 0) {
+            return true;
+        }
+        const isSyncValid = this.validateGroup(group, isSubmitting, { skipAsyncValidation: true });
+        for (const field of fields) {
+            await this.validateFieldAsync(field, {
+                isSubmitting,
+                isTouched: this.isTouched(field),
+                skipSyncValidation: true
+            });
+        }
+        return isSyncValid && !this.hasErrorsInGroup(group);
     }
     touchGroup(group) {
         for (const field of this.getValidationGroupFields(group)) {
@@ -1179,8 +1187,7 @@ export class BaseForm {
         }
     }
     fillState(data) {
-        var _a;
-        const driver = this.getPersistenceDriver((_a = this.options) === null || _a === void 0 ? void 0 : _a.persistSuffix);
+        const driver = this.getActivePersistenceDriver();
         for (const key of Object.keys(data)) {
             if (!Object.prototype.hasOwnProperty.call(data, key) || !(key in this.state)) {
                 continue;
@@ -1208,7 +1215,7 @@ export class BaseForm {
                 continue;
             }
             if (isRecord(newVal) && isRecord(currentVal)) {
-                this.state[key] = shallowMerge(Object.assign({}, currentVal), newVal);
+                this.state[key] = shallowMerge({ ...currentVal }, newVal);
                 this.dirty[key] = this.computeDirtyState(this.state[key], this.original[key]);
                 this.touched[key] = true;
                 continue;
@@ -1332,8 +1339,7 @@ export class BaseForm {
         return payload;
     }
     reset() {
-        var _a;
-        const driver = this.getPersistenceDriver((_a = this.options) === null || _a === void 0 ? void 0 : _a.persistSuffix);
+        const driver = this.getActivePersistenceDriver();
         for (const key in this.state) {
             if (this.state[key] instanceof PropertyAwareArray) {
                 const originalValue = this.original[key];
@@ -1364,8 +1370,7 @@ export class BaseForm {
         this.validate();
     }
     addToArrayProperty(property, newElement) {
-        var _a;
-        const driver = this.getPersistenceDriver((_a = this.options) === null || _a === void 0 ? void 0 : _a.persistSuffix);
+        const driver = this.getActivePersistenceDriver();
         const arr = this.state[property];
         if (arr instanceof PropertyAwareArray) {
             arr.push(newElement);
@@ -1515,8 +1520,7 @@ export class BaseForm {
      * @param value The new value to set
      */
     syncValue(key, value) {
-        var _a, _b;
-        const driver = this.getPersistenceDriver((_a = this.options) === null || _a === void 0 ? void 0 : _a.persistSuffix);
+        const driver = this.getActivePersistenceDriver();
         const currentVal = this.state[key];
         if (currentVal instanceof PropertyAwareArray) {
             const arr = this.state[key];
@@ -1557,7 +1561,7 @@ export class BaseForm {
             this.dirty[key] = false;
             this.touched[key] = true;
         }
-        if (((_b = this.options) === null || _b === void 0 ? void 0 : _b.persist) !== false) {
+        if (this.options?.persist === true) {
             this.persistState(driver);
         }
         this.validateField(key);

package/dist/vue/forms/PropertyAwareArray.js

@@ -11,7 +11,6 @@ export class PropertyAwareArray extends Array {
     constructor(items = []) {
         // Call Array constructor with array length
         super();
-        void this.__propertyAwareArrayBrand;
         // Add items to the array
         if (items && items.length) {
             items.forEach((item) => this.push(item));

package/dist/vue/forms/PropertyAwareObject.js

@@ -6,13 +6,15 @@
 export const PROPERTY_AWARE_OBJECT_MARKER = '__propertyAwareObject';
 export class PropertyAwareObject {
     constructor(values) {
-        void this.__propertyAwareObjectBrand;
         Object.assign(this, values);
     }
     static from(values) {
         return new PropertyAwareObject(values);
     }
     toJSON() {
-        return Object.assign({ [PROPERTY_AWARE_OBJECT_MARKER]: true }, this);
+        return {
+            [PROPERTY_AWARE_OBJECT_MARKER]: true,
+            ...this
+        };
     }
 }

package/dist/vue/forms/index.d.ts

@@ -1,4 +1,4 @@
-import { BaseForm, propertyAwareToRaw } from './BaseForm';
+import { BaseForm, propertyAwareToRaw, type BaseFormOptions } from './BaseForm';
 import { type PersistedForm } from './types/PersistedForm';
 import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver';
 import { MemoryPersistenceDriver } from '../../persistenceDrivers/MemoryPersistenceDriver';
@@ -10,4 +10,4 @@ import { PropertyAwareObject } from './PropertyAwareObject';
 import { StrictPersistenceRestorePolicy } from './persistence';
 import type { PersistenceDebugEvent, PersistenceRestoreContext, PersistenceRestorePolicy, PersistenceRestoreResult } from './persistence';
 export { BaseForm, propertyAwareToRaw, PropertyAwareArray, PropertyAwareObject, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver, MemoryPersistenceDriver, StrictPersistenceRestorePolicy };
-export type { PersistedForm, PersistenceDriver, PropertyAwareField, PropertyAware, PersistenceDebugEvent, PersistenceRestoreContext, PersistenceRestorePolicy, PersistenceRestoreResult };
+export type { PersistedForm, PersistenceDriver, PropertyAwareField, PropertyAware, PersistenceDebugEvent, PersistenceRestoreContext, PersistenceRestorePolicy, PersistenceRestoreResult, BaseFormOptions };

package/dist/vue/forms/persistence/types.d.ts

@@ -1,6 +1,7 @@
 import { type PersistedForm } from '../types/PersistedForm';
 export interface PersistenceRestoreContext<FormBody extends object> {
     formName: string;
+    persistKey: string;
     persistSuffix?: string | undefined;
     defaults: FormBody;
     persisted: PersistedForm<FormBody> | null;
@@ -13,6 +14,7 @@ export interface PersistenceRestoreResult<FormBody extends object> {
 }
 export interface PersistenceDebugEvent<FormBody extends object> {
     formName: string;
+    persistKey: string;
     persistSuffix?: string | undefined;
     action: PersistenceRestoreResult<FormBody>['action'];
     reason: string;