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

package/dist/requests/BaseRequest.d.ts

@@ -9,6 +9,7 @@ import { type RequestDriverContract } from './contracts/RequestDriverContract';
 import { type RequestLoaderFactoryContract } from './contracts/RequestLoaderFactoryContract';
 import { type BaseRequestContract, type EventHandlerCallback } from './contracts/BaseRequestContract';
 import { type HeadersContract } from './contracts/HeadersContract';
+import { type ResponseHandlerContract } from './drivers/contracts/ResponseHandlerContract';
 import { type ResponseContract } from './contracts/ResponseContract';
 import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions';
 export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErrorBody, ResponseBodyInterface = undefined, ResponseClass extends ResponseContract<ResponseBodyInterface> = BaseResponse<ResponseBodyInterface>, RequestBodyInterface = undefined, RequestParamsInterface extends object = object> implements BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface> {
@@ -18,6 +19,7 @@ export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErro
     protected requestLoader: RequestLoaderContract<RequestLoaderLoadingType> | undefined;
     protected abortSignal: AbortSignal | undefined;
     protected concurrencyOptions: RequestConcurrencyOptions | undefined;
+    protected additionalHeaders: HeadersContract;
     protected events: {
         [key in RequestEvents]?: EventHandlerCallback[];
     };
@@ -40,12 +42,19 @@ export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErro
     withParams(params: RequestParamsInterface): this;
     getParams(): RequestParamsInterface | undefined;
     setBody(requestBody: RequestBodyInterface): this;
+    setHeaders(headers: HeadersContract): this;
     getBody(): RequestBodyInterface | undefined;
     requestHeaders(): HeadersContract;
     buildUrl(): URL;
     on<T>(event: RequestEvents, handler: EventHandlerCallback<T>): this;
     protected dispatch<T>(event: RequestEvents, value: T): void;
     send(): Promise<ResponseClass>;
+    send(options: {
+        resolveBody?: true;
+    }): Promise<ResponseClass>;
+    send(options: {
+        resolveBody: false;
+    }): Promise<ResponseHandlerContract>;
     isLoading(): RequestLoaderLoadingType;
     abstract getResponse(): ResponseClass;
     getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface | undefined> | undefined;

package/dist/requests/BaseRequest.js

@@ -23,6 +23,7 @@ export class BaseRequest {
         this.requestLoader = undefined;
         this.abortSignal = undefined;
         this.concurrencyOptions = undefined;
+        this.additionalHeaders = {};
         /* @ts-expect-error Ignore generics */
         this.events = {};
         if (BaseRequest.requestLoaderFactory !== undefined) {
@@ -64,6 +65,10 @@ export class BaseRequest {
         this.requestBody = requestBody;
         return this;
     }
+    setHeaders(headers) {
+        this.additionalHeaders = Object.assign(Object.assign({}, this.additionalHeaders), headers);
+        return this;
+    }
     getBody() {
         return this.requestBody;
     }
@@ -90,8 +95,10 @@ export class BaseRequest {
         this.events[event].forEach((handler) => handler(value));
     }
     send() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
             var _a, _b, _c, _d, _e, _f;
+            const responseSkeleton = this.getResponse();
+            const acceptHeader = responseSkeleton.getAcceptHeader();
             const concurrencyMode = (_b = (_a = this.concurrencyOptions) === null || _a === void 0 ? void 0 : _a.mode) !== null && _b !== void 0 ? _b : RequestConcurrencyMode.ALLOW;
             const concurrencyKey = (_d = (_c = this.concurrencyOptions) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : this.requestId;
             const useReplace = concurrencyMode === RequestConcurrencyMode.REPLACE || concurrencyMode === RequestConcurrencyMode.REPLACE_LATEST;
@@ -109,17 +116,20 @@ export class BaseRequest {
             }
             this.dispatch(RequestEvents.LOADING, true);
             (_e = this.requestLoader) === null || _e === void 0 ? void 0 : _e.setLoading(true);
-            const responseSkeleton = this.getResponse();
             const requestBody = this.requestBody === undefined ? undefined : (_f = this.getRequestBodyFactory()) === null || _f === void 0 ? void 0 : _f.make(this.requestBody);
             const requestConfig = this.buildRequestConfig(requestBody, concurrencyKey, sequence, useLatest);
-            return this.resolveRequestDriver()
-                .send(this.buildUrl(), this.method(), Object.assign({ Accept: responseSkeleton.getAcceptHeader() }, this.requestHeaders()), requestBody, requestConfig)
-                .then((responseHandler) => __awaiter(this, void 0, void 0, function* () {
+            const responseHandler = yield this.resolveRequestDriver()
+                .send(this.buildUrl(), this.method(), Object.assign(Object.assign({ Accept: acceptHeader }, this.requestHeaders()), this.additionalHeaders), requestBody, requestConfig)
+                .then((driverResponseHandler) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
                 if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
                     throw new StaleResponseException();
                 }
-                yield responseSkeleton.setResponse(responseHandler);
-                return responseSkeleton;
+                if (((_a = driverResponseHandler.getStatusCode()) !== null && _a !== void 0 ? _a : 0) >= 400) {
+                    const handler = new ErrorHandler(driverResponseHandler);
+                    yield handler.handle();
+                }
+                return driverResponseHandler;
             }))
                 .catch((error) => __awaiter(this, void 0, void 0, function* () {
                 if (useLatest && !this.isLatestSequence(concurrencyKey, sequence)) {
@@ -144,6 +154,11 @@ export class BaseRequest {
                 }
                 this.decrementConcurrencyInFlight(concurrencyKey);
             });
+            if (options.resolveBody === false) {
+                return responseHandler;
+            }
+            yield responseSkeleton.setResponse(responseHandler);
+            return responseSkeleton;
         });
     }
     isLoading() {

package/dist/requests/contracts/BaseRequestContract.d.ts

@@ -3,7 +3,11 @@ import { RequestEvents } from '../RequestEvents.enum';
 import { type BodyFactoryContract } from './BodyFactoryContract';
 import { type HeadersContract } from './HeadersContract';
 import { type RequestConcurrencyOptions } from '../types/RequestConcurrencyOptions';
+import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract';
 export type EventHandlerCallback<T> = (value: T) => void;
+export interface SendRequestOptions {
+    resolveBody?: boolean;
+}
 export interface BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterface, ResponseClass, RequestParamsInterface extends object> {
     method(): RequestMethodEnum;
     url(): URL | string;
@@ -15,6 +19,12 @@ export interface BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterf
     buildUrl(): URL;
     on<T>(event: RequestEvents, handler: EventHandlerCallback<T>): this;
     send(): Promise<ResponseClass>;
+    send(options: {
+        resolveBody?: true;
+    }): Promise<ResponseClass>;
+    send(options: {
+        resolveBody: false;
+    }): Promise<ResponseHandlerContract>;
     isLoading(): RequestLoaderLoadingType;
     getRequestBodyFactory(): BodyFactoryContract<RequestBodyInterface> | undefined;
     getResponse(): ResponseClass;

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

@@ -1,20 +1,27 @@
-import { type WritableComputedRef } from 'vue';
 import { type PersistenceDriver } from '../../persistenceDrivers/types/PersistenceDriver';
-import { PropertyAwareArray } from './PropertyAwareArray';
-import { type ValidationRules } from './validation';
+import { PropertyAwareArray, type PropertyAwareField } from './PropertyAwareArray';
+import { PropertyAwareObject } from './PropertyAwareObject';
+import { type PersistenceDebugEvent, type PersistenceRestorePolicy } from './persistence/types';
+import { type ValidationGroups, 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 FieldProperty<T> = PropertyAwareField<T>;
+type NestedPropertyAwareValue<T> = T extends PropertyAwareArray<infer Item> ? ArrayProperty<Item> : T extends PropertyAwareObject<infer Shape> ? ObjectProperty<Shape> : FieldProperty<T>;
+type ArrayProperty<T> = Array<T extends object ? {
+    [P in keyof T]: NestedPropertyAwareValue<T[P]>;
+} : {
+    value: FieldProperty<T>;
+}>;
+type ObjectProperty<T extends object> = {
+    [K in keyof T]: NestedPropertyAwareValue<T[K]>;
 };
-type PropertyAwareToRaw<T> = T extends Array<infer U> ? Array<PropertyAwareToRaw<U>> : T extends {
+type PropertyAwareToRaw<T> = T extends Array<infer U> ? Array<PropertyAwareToRaw<U>> : T extends PropertyAwareObject<infer Shape> ? {
+    [K in keyof Shape]: PropertyAwareToRaw<Shape[K]>;
+} : T extends {
     model: {
         value: infer V;
     };
@@ -23,12 +30,18 @@ type PropertyAwareToRaw<T> = T extends Array<infer U> ? Array<PropertyAwareToRaw
 } : 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]>;
+    [K in keyof FormBody]: FormBody[K] extends PropertyAwareArray<infer Item> ? ArrayProperty<Item> : FormBody[K] extends PropertyAwareObject<infer Shape> ? ObjectProperty<Shape> : FieldProperty<FormBody[K]>;
 };
+interface ValidationContext {
+    isDirty?: boolean;
+    isSubmitting?: boolean;
+    isDependentChange?: boolean;
+    isTouched?: boolean;
+}
+interface AsyncValidationContext extends ValidationContext {
+    skipSyncValidation?: boolean;
+    skipAsyncValidation?: boolean;
+}
 export declare function propertyAwareToRaw<T>(propertyAwareObject: T): PropertyAwareToRaw<T>;
 /**
  * A generic base class for forms.
@@ -49,6 +62,7 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
     private readonly original;
     private readonly _model;
     private _errors;
+    private _asyncErrors;
     private _hasErrors;
     protected append: string[];
     protected ignore: string[];
@@ -56,13 +70,22 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
         [serverKey: string]: string | string[];
     };
     protected rules: ValidationRules<FormBody>;
+    protected validationGroups: ValidationGroups<FormBody>;
     private fieldDependencies;
+    private readonly arrayWrapperCache;
+    private readonly arrayItemWrapperCache;
+    private readonly asyncValidationDebouncers;
+    private readonly pendingAsyncValidationContexts;
+    private readonly asyncValidationTokens;
     /**
      * 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;
+    protected getPersistenceRestorePolicy(): PersistenceRestorePolicy<FormBody>;
+    protected shouldLogPersistenceDebug(): boolean;
+    protected logPersistenceDebug(event: PersistenceDebugEvent<FormBody>): void;
     /**
      * 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.
@@ -87,7 +110,29 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
         persistSuffix?: string;
     } | undefined);
     protected defineRules(): ValidationRules<FormBody>;
+    protected defineValidationGroups(): ValidationGroups<FormBody>;
+    private clearErrorBag;
+    private clearSyncErrors;
+    private clearAsyncErrors;
     private clearErrors;
+    private hasAsyncRules;
+    private bumpAsyncValidationToken;
+    private cancelPendingAsyncValidations;
+    private scheduleAsyncValidation;
+    private executeScheduledAsyncValidation;
+    private flattenErrorValue;
+    private flattenErrorsFromBag;
+    private mergeErrorMessages;
+    private flattenErrors;
+    private applyErrors;
+    private getValidationGroupPaths;
+    private matchesValidationGroupPath;
+    private errorKeyBelongsToGroup;
+    private getValidationGroupFields;
+    private clearGroupErrors;
+    private collectSiblingNestedErrors;
+    private validateFieldPreservingNestedErrors;
+    private clearErrorBagPaths;
     private getOrCreateErrorArray;
     private getOrCreateErrorObject;
     private getFieldErrors;
@@ -95,6 +140,9 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
     private getArrayItemErrors;
     private getArrayItemFieldErrors;
     private getArrayItemErrorMessages;
+    private getObjectFieldErrors;
+    private getArrayItemErrorsFromBag;
+    private getArrayItemErrorMessagesFromBag;
     private setArrayDirty;
     /**
      * Collapse nested array dirty states into a single boolean/object for array entries.
@@ -102,6 +150,16 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
     private normalizeItemDirtyState;
     private getArrayItemDirty;
     private getArrayItemDirtyValue;
+    private getNestedErrorMessagesFromValue;
+    private setNestedError;
+    private getNestedDirtyValue;
+    private createFieldProperty;
+    private resolveArrayItemIndex;
+    private getArrayItemValueByPath;
+    private setArrayItemValueByPath;
+    private createObjectWrapperFromShape;
+    private getOrCreateArrayItemWrapper;
+    private getOrCreateArrayWrappers;
     /**
      * Map server-side errors (including dot-notation paths) into the form error bag.
      */
@@ -118,13 +176,18 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
      * @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;
+    protected validateField(field: keyof FormBody, context?: AsyncValidationContext): void;
+    validate(isSubmitting?: boolean, options?: {
+        skipAsyncValidation?: boolean;
+    }): boolean;
+    validateGroup(group: string, isSubmitting?: boolean, options?: {
+        skipAsyncValidation?: boolean;
+    }): boolean;
+    private runFieldAsyncValidation;
+    validateFieldAsync(field: keyof FormBody, context?: AsyncValidationContext): Promise<boolean>;
+    validateAsync(isSubmitting?: boolean): Promise<boolean>;
+    validateGroupAsync(group: string, isSubmitting?: boolean): Promise<boolean>;
+    touchGroup(group: string): void;
     fillState(data: Partial<FormBody>): void;
     private getValueGetter;
     private getNoArgGetter;
@@ -149,6 +212,9 @@ export declare abstract class BaseForm<RequestBody extends object, FormBody exte
      * @returns boolean indicating if the form has errors
      */
     hasErrors(): boolean;
+    getErrors(): Record<string, ErrorMessages>;
+    hasErrorsInGroup(group: string): boolean;
+    getErrorsInGroup(group: string): Record<string, ErrorMessages>;
     /**
      * Updates both the state and original value for a given property,
      * keeping the field in a clean (not dirty) state.