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

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

@@ -6,6 +6,7 @@ export interface PropertyAwareField<T> {
     model: WritableComputedRef<T>;
     errors: string[];
     dirty: boolean;
+    touched: boolean;
 }
 /**
  * Wandelt ein reguläres Interface in ein property-aware Interface um

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

@@ -0,0 +1,13 @@
+/**
+ * Opt-in object wrapper for nested property-aware fields.
+ * Fields declared as PropertyAwareObject are exposed as nested property-aware
+ * children instead of a single scalar field.
+ */
+export declare const PROPERTY_AWARE_OBJECT_MARKER = "__propertyAwareObject";
+export declare class PropertyAwareObject<T extends object = Record<string, unknown>> {
+    [key: string]: unknown;
+    private readonly __propertyAwareObjectBrand;
+    constructor(values: T);
+    static from<T extends object>(values: T): PropertyAwareObject<T>;
+    toJSON(): Record<string, unknown>;
+}

package/dist/vue/forms/PropertyAwareObject.js

@@ -0,0 +1,18 @@
+/**
+ * Opt-in object wrapper for nested property-aware fields.
+ * Fields declared as PropertyAwareObject are exposed as nested property-aware
+ * children instead of a single scalar field.
+ */
+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);
+    }
+}

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

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

package/dist/vue/forms/index.js

@@ -3,4 +3,6 @@ import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver'
 import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
 import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver';
 import { PropertyAwareArray } from './PropertyAwareArray';
-export { BaseForm, propertyAwareToRaw, PropertyAwareArray, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver };
+import { PropertyAwareObject } from './PropertyAwareObject';
+import { StrictPersistenceRestorePolicy } from './persistence';
+export { BaseForm, propertyAwareToRaw, PropertyAwareArray, PropertyAwareObject, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver, StrictPersistenceRestorePolicy };

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

@@ -0,0 +1,4 @@
+import { type PersistenceRestoreContext, type PersistenceRestorePolicy, type PersistenceRestoreResult } from './types';
+export declare class StrictPersistenceRestorePolicy<FormBody extends object> implements PersistenceRestorePolicy<FormBody> {
+    resolve(context: PersistenceRestoreContext<FormBody>): PersistenceRestoreResult<FormBody>;
+}

package/dist/vue/forms/persistence/StrictPersistenceRestorePolicy.js

@@ -0,0 +1,42 @@
+import { collectPropertyAwareMismatchPaths, propertyAwareDeepEqual } from './utils';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isPersistedFormLike(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return 'state' in value && 'original' in value && 'dirty' in value;
+}
+export class StrictPersistenceRestorePolicy {
+    resolve(context) {
+        const { defaults, persisted } = context;
+        if (persisted === null) {
+            return {
+                action: 'ignore',
+                reason: 'no_persisted_state'
+            };
+        }
+        if (!isPersistedFormLike(persisted)) {
+            return {
+                action: 'discard',
+                reason: 'invalid_persisted_state'
+            };
+        }
+        if (propertyAwareDeepEqual(defaults, persisted.original)) {
+            return {
+                action: 'restore',
+                reason: 'defaults_match',
+                persisted
+            };
+        }
+        return {
+            action: 'discard',
+            reason: 'defaults_mismatch',
+            persisted,
+            details: {
+                mismatchPaths: collectPropertyAwareMismatchPaths(defaults, persisted.original)
+            }
+        };
+    }
+}

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

@@ -0,0 +1,3 @@
+import { StrictPersistenceRestorePolicy } from './StrictPersistenceRestorePolicy';
+export { StrictPersistenceRestorePolicy };
+export type { PersistenceDebugEvent, PersistenceRestoreContext, PersistenceRestorePolicy, PersistenceRestoreResult } from './types';

package/dist/vue/forms/persistence/index.js

@@ -0,0 +1,2 @@
+import { StrictPersistenceRestorePolicy } from './StrictPersistenceRestorePolicy';
+export { StrictPersistenceRestorePolicy };

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

@@ -0,0 +1,23 @@
+import { type PersistedForm } from '../types/PersistedForm';
+export interface PersistenceRestoreContext<FormBody extends object> {
+    formName: string;
+    persistSuffix?: string | undefined;
+    defaults: FormBody;
+    persisted: PersistedForm<FormBody> | null;
+}
+export interface PersistenceRestoreResult<FormBody extends object> {
+    action: 'restore' | 'discard' | 'ignore';
+    reason: string;
+    persisted?: PersistedForm<FormBody> | undefined;
+    details?: Record<string, unknown> | undefined;
+}
+export interface PersistenceDebugEvent<FormBody extends object> {
+    formName: string;
+    persistSuffix?: string | undefined;
+    action: PersistenceRestoreResult<FormBody>['action'];
+    reason: string;
+    details?: Record<string, unknown> | undefined;
+}
+export interface PersistenceRestorePolicy<FormBody extends object> {
+    resolve(context: PersistenceRestoreContext<FormBody>): PersistenceRestoreResult<FormBody>;
+}

package/dist/vue/forms/persistence/types.js

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

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

@@ -0,0 +1,2 @@
+export declare function propertyAwareDeepEqual<T>(a: T, b: T): boolean;
+export declare function collectPropertyAwareMismatchPaths(a: unknown, b: unknown, path?: string, maxPaths?: number): string[];

package/dist/vue/forms/persistence/utils.js

@@ -0,0 +1,77 @@
+import { isEqual } from 'lodash-es';
+import { PropertyAwareArray } from '../PropertyAwareArray';
+import { PropertyAwareObject, PROPERTY_AWARE_OBJECT_MARKER } from '../PropertyAwareObject';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function isPropertyAwareObject(value) {
+    return value instanceof PropertyAwareObject;
+}
+function isSerializedPropertyAwareObject(value) {
+    return isRecord(value) && value[PROPERTY_AWARE_OBJECT_MARKER] === true;
+}
+function normalizePropertyAwareEqualityValue(value) {
+    if (value instanceof PropertyAwareArray) {
+        return Array.from(value, (item) => normalizePropertyAwareEqualityValue(item));
+    }
+    if (isPropertyAwareObject(value) || isSerializedPropertyAwareObject(value)) {
+        const normalized = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key === PROPERTY_AWARE_OBJECT_MARKER) {
+                continue;
+            }
+            normalized[key] = normalizePropertyAwareEqualityValue(child);
+        }
+        return normalized;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizePropertyAwareEqualityValue(item));
+    }
+    if (isRecord(value)) {
+        const normalized = {};
+        for (const [key, child] of Object.entries(value)) {
+            normalized[key] = normalizePropertyAwareEqualityValue(child);
+        }
+        return normalized;
+    }
+    return value;
+}
+export function propertyAwareDeepEqual(a, b) {
+    return isEqual(normalizePropertyAwareEqualityValue(a), normalizePropertyAwareEqualityValue(b));
+}
+export function collectPropertyAwareMismatchPaths(a, b, path = '', maxPaths = 10) {
+    const mismatches = [];
+    const visit = (left, right, currentPath) => {
+        if (mismatches.length >= maxPaths) {
+            return;
+        }
+        const normalizedLeft = normalizePropertyAwareEqualityValue(left);
+        const normalizedRight = normalizePropertyAwareEqualityValue(right);
+        if (isEqual(normalizedLeft, normalizedRight)) {
+            return;
+        }
+        if (Array.isArray(normalizedLeft) && Array.isArray(normalizedRight)) {
+            if (normalizedLeft.length !== normalizedRight.length) {
+                mismatches.push(currentPath || '(root)');
+                return;
+            }
+            normalizedLeft.forEach((item, index) => {
+                visit(item, normalizedRight[index], currentPath ? `${currentPath}.${index}` : String(index));
+            });
+            return;
+        }
+        if (isRecord(normalizedLeft) && isRecord(normalizedRight)) {
+            const keys = new Set([...Object.keys(normalizedLeft), ...Object.keys(normalizedRight)]);
+            for (const key of keys) {
+                visit(normalizedLeft[key], normalizedRight[key], currentPath ? `${currentPath}.${key}` : key);
+                if (mismatches.length >= maxPaths) {
+                    return;
+                }
+            }
+            return;
+        }
+        mismatches.push(currentPath || '(root)');
+    };
+    visit(a, b, path);
+    return mismatches;
+}

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

@@ -5,8 +5,9 @@ import { JsonRule } from './rules/JsonRule';
 import { RequiredRule } from './rules/RequiredRule';
 import { UrlRule } from './rules/UrlRule';
 import { MinRule } from './rules/MinRule';
+import { PrecognitiveRule } from './rules/PrecognitiveRule';
 import { ValidationMode } from './ValidationMode.enum';
 import { type BidirectionalRule } from './types/BidirectionalRule';
-import { type ValidationRules } from './types/ValidationRules';
-export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, ValidationMode };
-export type { BidirectionalRule, ValidationRules };
+import { type ValidationGroups, type ValidationRules } from './types/ValidationRules';
+export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, PrecognitiveRule, ValidationMode };
+export type { BidirectionalRule, ValidationGroups, ValidationRules };

package/dist/vue/forms/validation/index.js

@@ -5,5 +5,6 @@ import { JsonRule } from './rules/JsonRule';
 import { RequiredRule } from './rules/RequiredRule';
 import { UrlRule } from './rules/UrlRule';
 import { MinRule } from './rules/MinRule';
+import { PrecognitiveRule } from './rules/PrecognitiveRule';
 import { ValidationMode } from './ValidationMode.enum';
-export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, ValidationMode };
+export { BaseRule, ConfirmedRule, EmailRule, JsonRule, RequiredRule, UrlRule, MinRule, PrecognitiveRule, ValidationMode };

package/dist/vue/forms/validation/rules/BaseRule.d.ts

@@ -1,5 +1,12 @@
+export interface AsyncValidationContext {
+    field: string;
+    payload: Record<string, unknown>;
+    isSubmitting: boolean;
+}
 export declare abstract class BaseRule<FormBody extends object> {
     dependsOn: Array<keyof FormBody>;
     abstract validate(value: unknown, state: FormBody): boolean;
     abstract getMessage(): string;
+    validateAsync(_value: unknown, _state: FormBody, _context: AsyncValidationContext): Promise<Record<string, string[]> | null>;
+    getAsyncValidationPaths(field: keyof FormBody, _state: FormBody): string[];
 }

package/dist/vue/forms/validation/rules/BaseRule.js

@@ -1,5 +1,24 @@
+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());
+    });
+};
 export class BaseRule {
     constructor() {
         this.dependsOn = [];
     }
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    validateAsync(_value, _state, _context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    getAsyncValidationPaths(field, _state) {
+        return [String(field)];
+    }
 }

package/dist/vue/forms/validation/rules/PrecognitiveRule.d.ts

@@ -0,0 +1,22 @@
+import { BaseRequest } from '../../../../requests/BaseRequest';
+import { BaseResponse } from '../../../../requests/responses/BaseResponse';
+import { BaseRule, type AsyncValidationContext } from './BaseRule';
+export interface PrecognitiveValidationErrorBody {
+    errors?: Record<string, string[]>;
+}
+export interface PrecognitiveRuleOptions<FormBody extends object> {
+    validateOnly?: string[] | ((field: keyof FormBody, state: FormBody) => string[]);
+    acceptHeader?: string;
+    resolveErrors?: (body: PrecognitiveValidationErrorBody) => Record<string, string[]>;
+}
+type PrecognitiveRequestFactory = () => BaseRequest<unknown, PrecognitiveValidationErrorBody, unknown, BaseResponse<unknown>, object, object>;
+export declare class PrecognitiveRule<FormBody extends object> extends BaseRule<FormBody> {
+    private readonly requestFactory;
+    private readonly options;
+    constructor(requestFactory: PrecognitiveRequestFactory, options?: PrecognitiveRuleOptions<FormBody>);
+    validate(): boolean;
+    getMessage(): string;
+    getAsyncValidationPaths(field: keyof FormBody, state: FormBody): string[];
+    validateAsync(_value: unknown, state: FormBody, context: AsyncValidationContext): Promise<Record<string, string[]> | null>;
+}
+export {};

package/dist/vue/forms/validation/rules/PrecognitiveRule.js

@@ -0,0 +1,58 @@
+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 { ValidationException } from '../../../../requests/exceptions/ValidationException';
+import { BaseRule } from './BaseRule';
+export class PrecognitiveRule extends BaseRule {
+    constructor(requestFactory, options = {}) {
+        super();
+        this.requestFactory = requestFactory;
+        this.options = options;
+    }
+    validate() {
+        return true;
+    }
+    getMessage() {
+        return '';
+    }
+    getAsyncValidationPaths(field, state) {
+        const validateOnly = this.options.validateOnly;
+        if (Array.isArray(validateOnly)) {
+            return [...validateOnly];
+        }
+        if (typeof validateOnly === 'function') {
+            return validateOnly(field, state);
+        }
+        return [String(field)];
+    }
+    validateAsync(_value, state, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            const request = this.requestFactory();
+            const validateOnly = this.getAsyncValidationPaths(context.field, state);
+            request.setBody(context.payload);
+            request.setHeaders({
+                Accept: (_a = this.options.acceptHeader) !== null && _a !== void 0 ? _a : 'application/json',
+                Precognition: 'true',
+                'Precognition-Validate-Only': validateOnly.join(',')
+            });
+            try {
+                yield request.send({ resolveBody: false });
+                return {};
+            }
+            catch (error) {
+                if (error instanceof ValidationException) {
+                    const body = error.getBody();
+                    return (_e = (_d = (_c = (_b = this.options).resolveErrors) === null || _c === void 0 ? void 0 : _c.call(_b, body)) !== null && _d !== void 0 ? _d : body.errors) !== null && _e !== void 0 ? _e : {};
+                }
+                throw error;
+            }
+        });
+    }
+}

package/dist/vue/forms/validation/types/ValidationRules.d.ts

@@ -2,10 +2,13 @@ import { type BaseRule } from '../rules/BaseRule';
 import { type BidirectionalRule } from './BidirectionalRule';
 import { type ValidationMode } from '../ValidationMode.enum';
 type Rule<FormBody extends object> = BaseRule<FormBody> & Partial<BidirectionalRule<FormBody>>;
+type ValidationGroupPath<FormBody extends object> = Extract<keyof FormBody, string> | string;
 export type ValidationRules<FormBody extends object> = Partial<Record<keyof FormBody, {
     rules: Rule<FormBody>[];
     options?: {
         mode?: ValidationMode;
+        asyncDebounceMs?: number;
     };
 }>>;
+export type ValidationGroups<FormBody extends object> = Partial<Record<string, ValidationGroupPath<FormBody>[]>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueprint-ts/core",
-  "version": "4.1.0-beta.3",
+  "version": "4.1.0-beta.5",
   "license": "MIT",
   "publishConfig": {
     "access": "public"