@blueprint-ts/core 4.1.0-beta.1 → 4.1.0-beta.3

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

@@ -0,0 +1,162 @@
+import { type WritableComputedRef } from 'vue';
+import { type PersistenceDriver } from '../../persistenceDrivers/types/PersistenceDriver';
+import { PropertyAwareArray } from './PropertyAwareArray';
+import { type ValidationRules } from './validation';
+type ErrorMessages = string[];
+interface ErrorObject {
+    [key: string]: FieldErrors;
+}
+type ErrorArray = Array<ErrorObject>;
+type FieldErrors = ErrorMessages | ErrorObject | ErrorArray;
+type FieldProperty<T> = {
+    model: WritableComputedRef<T>;
+    errors: ErrorMessages;
+    dirty: boolean;
+    touched: boolean;
+};
+type PropertyAwareToRaw<T> = T extends Array<infer U> ? Array<PropertyAwareToRaw<U>> : T extends {
+    model: {
+        value: infer V;
+    };
+} ? V : T extends object ? {
+    [K in keyof T]: PropertyAwareToRaw<T[K]>;
+} : T;
+type ArrayItem<T> = T extends Array<infer Item> ? Item : never;
+type FormProperties<FormBody extends object> = {
+    [K in keyof FormBody]: FormBody[K] extends PropertyAwareArray<infer Item> ? Array<Item extends object ? {
+        [P in keyof Item]: FieldProperty<Item[P]>;
+    } : {
+        value: FieldProperty<Item>;
+    }> : FieldProperty<FormBody[K]>;
+};
+export declare function propertyAwareToRaw<T>(propertyAwareObject: T): PropertyAwareToRaw<T>;
+/**
+ * A generic base class for forms.
+ *
+ * @template RequestBody - The final payload shape (what is sent to the server).
+ * @template FormBody - The raw form data shape (before mutators are applied).
+ *
+ * (We assume that for every key in RequestBody there is a corresponding key in FormBody.)
+ */
+export declare abstract class BaseForm<RequestBody extends object, FormBody extends object> {
+    protected options?: {
+        persist?: boolean;
+        persistSuffix?: string;
+    } | undefined;
+    protected readonly state: FormBody;
+    private readonly dirty;
+    private readonly touched;
+    private readonly original;
+    private readonly _model;
+    private _errors;
+    private _hasErrors;
+    protected append: string[];
+    protected ignore: string[];
+    protected errorMap: {
+        [serverKey: string]: string | string[];
+    };
+    protected rules: ValidationRules<FormBody>;
+    private fieldDependencies;
+    /**
+     * Returns the persistence driver to use.
+     * The default is a NonPersistentDriver.
+     * Child classes can override this method to return a different driver.
+     */
+    protected getPersistenceDriver(_suffix: string | undefined): PersistenceDriver;
+    /**
+     * Helper: recursively computes the dirty state for a value based on the original.
+     * For plain arrays we compare the entire array (a single flag), not each element.
+     */
+    private computeDirtyState;
+    private initDirtyTouched;
+    private replacePropertyAwareArray;
+    private persistState;
+    private markFieldUpdated;
+    private updateField;
+    /**
+     * Build a map of field dependencies based on the rules
+     * This identifies which fields need to be revalidated when another field changes
+     */
+    private buildFieldDependencies;
+    /**
+     * Validate fields that depend on the changed field
+     */
+    private validateDependentFields;
+    protected constructor(defaults: FormBody, options?: {
+        persist?: boolean;
+        persistSuffix?: string;
+    } | undefined);
+    protected defineRules(): ValidationRules<FormBody>;
+    private clearErrors;
+    private getOrCreateErrorArray;
+    private getOrCreateErrorObject;
+    private getFieldErrors;
+    private getOrCreateFieldErrors;
+    private getArrayItemErrors;
+    private getArrayItemFieldErrors;
+    private getArrayItemErrorMessages;
+    private setArrayDirty;
+    /**
+     * Collapse nested array dirty states into a single boolean/object for array entries.
+     */
+    private normalizeItemDirtyState;
+    private getArrayItemDirty;
+    private getArrayItemDirtyValue;
+    /**
+     * Map server-side errors (including dot-notation paths) into the form error bag.
+     */
+    fillErrors<ErrorInterface extends Record<string, FieldErrors>>(errorsData: ErrorInterface): void;
+    /**
+     * Mark a field as touched, which indicates user interaction
+     * Optionally triggers validation
+     * @param field The field to mark as touched
+     */
+    touch(field: keyof FormBody): void;
+    /**
+     * Check if a field has been touched (user interacted with it)
+     * @param field The field to check
+     * @returns boolean indicating if the field has been touched
+     */
+    isTouched(field: keyof FormBody): boolean;
+    protected validateField(field: keyof FormBody, context?: {
+        isDirty?: boolean;
+        isSubmitting?: boolean;
+        isDependentChange?: boolean;
+        isTouched?: boolean;
+    }): void;
+    validate(isSubmitting?: boolean): boolean;
+    fillState(data: Partial<FormBody>): void;
+    private getValueGetter;
+    private getNoArgGetter;
+    private transformValue;
+    /**
+     * Build the request payload, applying field/composite/appended getters when present.
+     */
+    buildPayload(): RequestBody;
+    reset(): void;
+    protected addToArrayProperty<K extends keyof FormBody>(property: K, newElement: ArrayItem<FormBody[K]>): void;
+    protected removeArrayItem<K extends keyof FormBody>(arrayIndex: K, filter: (item: ArrayItem<FormBody[K]>) => boolean): void;
+    protected resetArrayCounter(arrayIndex: keyof FormBody, counterIndex: string): void;
+    get properties(): FormProperties<FormBody>;
+    /**
+     * Checks if the form or a specific field is dirty
+     * @param field Optional field name to check, if not provided checks the entire form
+     * @returns boolean indicating if the form or specified field is dirty
+     */
+    isDirty(field?: keyof FormBody): boolean;
+    /**
+     * Returns whether the form has validation errors
+     * @returns boolean indicating if the form has errors
+     */
+    hasErrors(): boolean;
+    /**
+     * Updates both the state and original value for a given property,
+     * keeping the field in a clean (not dirty) state.
+     * Supports all field types including PropertyAwareArray.
+     *
+     * @param key The property key to update
+     * @param value The new value to set
+     */
+    syncValue<K extends keyof FormBody>(key: K, value: FormBody[K]): void;
+}
+export {};