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

package/dist/persistenceDrivers/MemoryPersistenceDriver.d.ts

@@ -0,0 +1,11 @@
+import { type PersistenceDriver } from './types/PersistenceDriver';
+export declare class MemoryPersistenceDriver implements PersistenceDriver {
+    protected suffix?: string | undefined;
+    protected static store: Map<string, string>;
+    constructor(suffix?: string | undefined);
+    static clear(): void;
+    protected storageKey(key: string): string;
+    get<T>(key: string): T | null;
+    set<T>(key: string, state: T): void;
+    remove(key: string): void;
+}

package/dist/persistenceDrivers/MemoryPersistenceDriver.js

@@ -0,0 +1,22 @@
+export class MemoryPersistenceDriver {
+    constructor(suffix) {
+        this.suffix = suffix;
+    }
+    static clear() {
+        MemoryPersistenceDriver.store.clear();
+    }
+    storageKey(key) {
+        return this.suffix ? `state_${key}_${this.suffix}` : `state_${key}`;
+    }
+    get(key) {
+        const data = MemoryPersistenceDriver.store.get(this.storageKey(key));
+        return data ? JSON.parse(data) : null;
+    }
+    set(key, state) {
+        MemoryPersistenceDriver.store.set(this.storageKey(key), JSON.stringify(state));
+    }
+    remove(key) {
+        MemoryPersistenceDriver.store.delete(this.storageKey(key));
+    }
+}
+MemoryPersistenceDriver.store = new Map();

package/dist/persistenceDrivers/index.d.ts

@@ -1,6 +1,7 @@
 import { LocalStorageDriver } from './LocalStorageDriver';
+import { MemoryPersistenceDriver } from './MemoryPersistenceDriver';
 import { NonPersistentDriver } from './NonPersistentDriver';
 import { SessionStorageDriver } from './SessionStorageDriver';
 import { type PersistenceDriver } from './types/PersistenceDriver';
-export { LocalStorageDriver, NonPersistentDriver, SessionStorageDriver };
+export { LocalStorageDriver, MemoryPersistenceDriver, NonPersistentDriver, SessionStorageDriver };
 export type { PersistenceDriver };

package/dist/persistenceDrivers/index.js

@@ -1,4 +1,5 @@
 import { LocalStorageDriver } from './LocalStorageDriver';
+import { MemoryPersistenceDriver } from './MemoryPersistenceDriver';
 import { NonPersistentDriver } from './NonPersistentDriver';
 import { SessionStorageDriver } from './SessionStorageDriver';
-export { LocalStorageDriver, NonPersistentDriver, SessionStorageDriver };
+export { LocalStorageDriver, MemoryPersistenceDriver, NonPersistentDriver, SessionStorageDriver };

package/dist/requests/BaseRequest.d.ts

@@ -20,6 +20,7 @@ export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErro
     protected abortSignal: AbortSignal | undefined;
     protected concurrencyOptions: RequestConcurrencyOptions | undefined;
     protected additionalHeaders: HeadersContract;
+    protected instanceRequestDriver: RequestDriverContract | undefined;
     protected events: {
         [key in RequestEvents]?: EventHandlerCallback[];
     };
@@ -35,6 +36,7 @@ export declare abstract class BaseRequest<RequestLoaderLoadingType, ResponseErro
     static setDefaultBaseUrl(url: string): void;
     setRequestLoader(loader: RequestLoaderContract<RequestLoaderLoadingType>): this;
     setConcurrency(options?: RequestConcurrencyOptions): this;
+    setRequestDriver(driver: RequestDriverContract): this;
     getRequestId(): string;
     abstract method(): RequestMethodEnum;
     abstract url(): URL | string;

package/dist/requests/BaseRequest.js

@@ -24,6 +24,7 @@ export class BaseRequest {
         this.abortSignal = undefined;
         this.concurrencyOptions = undefined;
         this.additionalHeaders = {};
+        this.instanceRequestDriver = undefined;
         /* @ts-expect-error Ignore generics */
         this.events = {};
         if (BaseRequest.requestLoaderFactory !== undefined) {
@@ -47,6 +48,10 @@ export class BaseRequest {
         this.concurrencyOptions = options;
         return this;
     }
+    setRequestDriver(driver) {
+        this.instanceRequestDriver = driver;
+        return this;
+    }
     getRequestId() {
         return this.requestId;
     }
@@ -227,8 +232,8 @@ export class BaseRequest {
         };
     }
     resolveRequestDriver() {
-        var _a;
-        return (_a = this.getRequestDriver()) !== null && _a !== void 0 ? _a : BaseRequest.requestDriver;
+        var _a, _b;
+        return (_b = (_a = this.instanceRequestDriver) !== null && _a !== void 0 ? _a : this.getRequestDriver()) !== null && _b !== void 0 ? _b : BaseRequest.requestDriver;
     }
     getRequestDriver() {
         return undefined;

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

@@ -4,6 +4,7 @@ import { type BodyFactoryContract } from './BodyFactoryContract';
 import { type HeadersContract } from './HeadersContract';
 import { type RequestConcurrencyOptions } from '../types/RequestConcurrencyOptions';
 import { type ResponseHandlerContract } from '../drivers/contracts/ResponseHandlerContract';
+import { type RequestDriverContract } from './RequestDriverContract';
 export type EventHandlerCallback<T> = (value: T) => void;
 export interface SendRequestOptions {
     resolveBody?: boolean;
@@ -30,4 +31,5 @@ export interface BaseRequestContract<RequestLoaderLoadingType, RequestBodyInterf
     getResponse(): ResponseClass;
     setAbortSignal(signal: AbortSignal): this;
     setConcurrency(options?: RequestConcurrencyOptions): this;
+    setRequestDriver(driver: RequestDriverContract): this;
 }

package/dist/requests/drivers/mock/MockRequestAssertionError.d.ts

@@ -0,0 +1,3 @@
+export declare class MockRequestAssertionError extends Error {
+    constructor(message: string);
+}

package/dist/requests/drivers/mock/MockRequestAssertionError.js

@@ -0,0 +1,6 @@
+export class MockRequestAssertionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MockRequestAssertionError';
+    }
+}

package/dist/requests/drivers/mock/MockRequestDriver.d.ts

@@ -0,0 +1,160 @@
+import { type BodyContent, type BodyContract } from '../../contracts/BodyContract';
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract';
+import { type HeadersContract, type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type RequestDriverContract } from '../../contracts/RequestDriverContract';
+import { RequestMethodEnum } from '../../RequestMethod.enum';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+import { type MockResponseBody, type MockResponseDefinition } from './MockResponseHandler';
+export type MockRequestBody = BodyContent | Record<string, unknown> | unknown[] | null | undefined;
+export type MockRequestMatchMode = 'ordered' | 'unordered';
+export type MockRequestPredicate<T> = ((value: T) => boolean) & {
+    description?: string;
+};
+export interface MockRequestDriverOptions {
+    matchMode?: MockRequestMatchMode;
+}
+export interface MockRequestQuery {
+    [key: string]: string | string[];
+}
+export interface MockRequestBodyMatchContext {
+    method: RequestMethodEnum;
+    url: string;
+    headers: ResolvedHeadersContract;
+    body?: MockNormalizedRequestBody;
+    getJson<T>(): T | undefined;
+    getText(): string | undefined;
+    getQuery(): MockRequestQuery;
+}
+export type MockRequestMethodMatcher = RequestMethodEnum | MockRequestPredicate<RequestMethodEnum>;
+export type MockRequestUrlMatcher = URL | string | MockRequestPredicate<URL>;
+export type MockRequestHeadersMatcher = HeadersContract | ResolvedHeadersContract | MockRequestPredicate<ResolvedHeadersContract>;
+export type MockRequestQueryMatcher = MockRequestQuery | MockRequestPredicate<MockRequestQuery>;
+export type MockRequestBodyMatcher = MockRequestBody | MockRequestPredicate<MockRequestBodyMatchContext>;
+export interface MockRequestExpectation {
+    method: MockRequestMethodMatcher;
+    url: MockRequestUrlMatcher;
+    headers?: MockRequestHeadersMatcher;
+    query?: MockRequestQueryMatcher;
+    body?: MockRequestBodyMatcher;
+    response: MockResponseDefinition;
+}
+export interface MockRequestExpectationCriteria {
+    method: MockRequestMethodMatcher;
+    url: MockRequestUrlMatcher;
+    headers?: MockRequestHeadersMatcher;
+    query?: MockRequestQueryMatcher;
+    body?: MockRequestBodyMatcher;
+}
+export type MockNormalizedRequestBody = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'binary';
+    mimeType?: string;
+    bytes: number[];
+} | {
+    kind: 'form-data';
+    entries: MockNormalizedFormDataEntry[];
+} | {
+    kind: 'null';
+};
+export interface MockNormalizedFormDataEntry {
+    key: string;
+    value: {
+        kind: 'text';
+        value: string;
+    } | {
+        kind: 'file';
+        name?: string;
+        mimeType?: string;
+        bytes: number[];
+    };
+}
+export interface MockRequestHistoryEntry {
+    method: RequestMethodEnum;
+    url: string;
+    headers: ResolvedHeadersContract;
+    body?: MockNormalizedRequestBody;
+}
+interface NormalizedMockRequest {
+    method: RequestMethodEnum;
+    url: string;
+    urlWithoutQuery: string;
+    parsedUrl: URL;
+    headers: ResolvedHeadersContract;
+    query: MockRequestQuery;
+    body?: MockNormalizedRequestBody;
+}
+interface MockRequestMatchFailure {
+    field: 'method' | 'url' | 'headers' | 'query' | 'body';
+    message: string;
+    expectation: MockRequestExpectation;
+    expectedValue?: unknown;
+    actualValue?: unknown;
+    diffPaths?: string[];
+}
+export declare class MockRequestExpectationBuilder {
+    protected readonly driver: MockRequestDriver;
+    protected criteria: MockRequestExpectationCriteria;
+    constructor(driver: MockRequestDriver, criteria: MockRequestExpectationCriteria);
+    withHeaders(headers: MockRequestHeadersMatcher): this;
+    withQuery(query: MockRequestQueryMatcher): this;
+    withBody(body: MockRequestBodyMatcher): this;
+    respond(response: MockResponseDefinition): MockRequestDriver;
+}
+export declare class MockRequestDriver implements RequestDriverContract {
+    protected config?: DriverConfigContract | undefined;
+    protected expectations: MockRequestExpectation[];
+    protected history: MockRequestHistoryEntry[];
+    protected matchMode: MockRequestMatchMode;
+    constructor(config?: DriverConfigContract | undefined, expectations?: MockRequestExpectation[], options?: MockRequestDriverOptions);
+    setMatchMode(mode: MockRequestMatchMode): this;
+    ordered(): this;
+    unordered(): this;
+    expect(expectation: MockRequestExpectation): this;
+    expectAny(criteria: MockRequestExpectationCriteria): MockRequestExpectationBuilder;
+    reset(): this;
+    getHistory(): MockRequestHistoryEntry[];
+    assertNoPendingExpectations(): void;
+    assertExpectationsMet(): void;
+    send(url: URL | string, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract, requestConfig?: DriverConfigContract): Promise<ResponseHandlerContract>;
+    protected selectExpectation(actualRequest: NormalizedMockRequest): Promise<{
+        index: number;
+        expectation: MockRequestExpectation;
+    }>;
+    protected matchExpectation(expectation: MockRequestExpectation, actualRequest: NormalizedMockRequest): Promise<MockRequestMatchFailure | undefined>;
+    protected matchMethod(method: MockRequestMethodMatcher, actualRequest: NormalizedMockRequest, expectation: MockRequestExpectation): MockRequestMatchFailure | undefined;
+    protected matchUrl(expectation: MockRequestExpectation, actualRequest: NormalizedMockRequest): MockRequestMatchFailure | undefined;
+    protected matchHeaders(headers: MockRequestHeadersMatcher | undefined, actualRequest: NormalizedMockRequest, expectation: MockRequestExpectation): MockRequestMatchFailure | undefined;
+    protected matchQuery(query: MockRequestQueryMatcher | undefined, actualRequest: NormalizedMockRequest, expectation: MockRequestExpectation): MockRequestMatchFailure | undefined;
+    protected matchBody(body: MockRequestBodyMatcher | undefined, actualRequest: NormalizedMockRequest, expectation: MockRequestExpectation): Promise<MockRequestMatchFailure | undefined>;
+    protected createBodyMatchContext(actualRequest: NormalizedMockRequest): MockRequestBodyMatchContext;
+    protected normalizeActualRequest(url: URL | string, method: RequestMethodEnum, headers: HeadersContract, body?: BodyContract): Promise<NormalizedMockRequest>;
+    protected toHistoryEntry(request: NormalizedMockRequest): MockRequestHistoryEntry;
+    protected buildUnexpectedRequestMessage(actualRequest: NormalizedMockRequest): string;
+    protected buildUnorderedMismatchMessage(actualRequest: NormalizedMockRequest, failures: MockRequestMatchFailure[]): string;
+    protected buildMismatchMessage(failure: MockRequestMatchFailure, actualRequest: NormalizedMockRequest): string;
+    protected formatExpectationSnapshot(expectation: MockRequestExpectation): string;
+    protected formatRequestSnapshot(request: NormalizedMockRequest): string;
+    protected describeExpectation(expectation: MockRequestExpectation): string;
+    protected describeMatcher(matcher: unknown): string;
+    protected describeUrlMatcher(expectation: MockRequestExpectation): string;
+    protected describeBodyMatcher(body: MockRequestBodyMatcher): string;
+    protected describeBodyForMessage(body?: MockNormalizedRequestBody): unknown;
+    protected normalizeUrl(url: URL | string): string;
+    protected resolveHeaders(headers: HeadersContract | ResolvedHeadersContract): ResolvedHeadersContract;
+    protected normalizeBody(body: MockRequestBody): Promise<MockNormalizedRequestBody | undefined>;
+    protected normalizeFormData(body: FormData): Promise<MockNormalizedRequestBody>;
+    protected getBlobName(value: Blob): string | undefined;
+    protected getOptionalBlobDetails(value: Blob): {
+        name?: string;
+        mimeType?: string;
+    };
+    protected readBlob(value: Blob): Promise<ArrayBuffer>;
+    protected isBufferSource(value: MockRequestBody): value is BufferSource;
+    protected toArrayBuffer(value: BufferSource): ArrayBuffer;
+}
+export type { MockResponseBody, MockResponseDefinition };
+export declare function getMockRequestJsonBody<T>(request: Pick<MockRequestHistoryEntry, 'body'>): T | undefined;
+export declare function getMockRequestTextBody(request: Pick<MockRequestHistoryEntry, 'body'>): string | undefined;
+export declare function getMockRequestQuery(request: Pick<MockRequestHistoryEntry, 'url'>): MockRequestQuery;

package/dist/requests/drivers/mock/MockRequestDriver.js

@@ -0,0 +1,588 @@
+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 { ResponseException } from '../../exceptions/ResponseException';
+import { isEqual } from 'lodash-es';
+import { MockRequestAssertionError } from './MockRequestAssertionError';
+import { MockResponseHandler } from './MockResponseHandler';
+function isPredicate(value) {
+    return typeof value === 'function';
+}
+function parseUrl(url) {
+    if (url instanceof URL) {
+        return url;
+    }
+    return new URL(url, 'https://mock-request.invalid');
+}
+function buildUrlWithoutQuery(url) {
+    const clone = new URL(url.toString());
+    clone.search = '';
+    return clone.toString();
+}
+function parseQuery(url) {
+    const query = {};
+    for (const [key, value] of url.searchParams.entries()) {
+        const current = query[key];
+        if (current === undefined) {
+            query[key] = value;
+            continue;
+        }
+        if (Array.isArray(current)) {
+            current.push(value);
+            continue;
+        }
+        query[key] = [current, value];
+    }
+    return query;
+}
+function stringify(value) {
+    return value === undefined ? 'undefined' : JSON.stringify(value, null, 2);
+}
+function getPredicateDescription(predicate) {
+    var _a;
+    return (_a = predicate.description) !== null && _a !== void 0 ? _a : '[custom matcher]';
+}
+function getTextBody(body) {
+    if (!body || body.kind !== 'text') {
+        return undefined;
+    }
+    return body.value;
+}
+function getJsonBody(body) {
+    const textBody = getTextBody(body);
+    if (textBody === undefined) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(textBody);
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function collectJsonDiffPaths(expected, actual, path = '', maxPaths = 10) {
+    const mismatches = [];
+    const visit = (left, right, currentPath) => {
+        if (mismatches.length >= maxPaths) {
+            return;
+        }
+        if (JSON.stringify(left) === JSON.stringify(right)) {
+            return;
+        }
+        if (Array.isArray(left) && Array.isArray(right)) {
+            if (left.length !== right.length) {
+                mismatches.push(currentPath || '(root)');
+                return;
+            }
+            left.forEach((item, index) => {
+                visit(item, right[index], currentPath ? `${currentPath}.${index}` : String(index));
+            });
+            return;
+        }
+        if (isRecord(left) && isRecord(right)) {
+            const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+            for (const key of keys) {
+                visit(left[key], right[key], currentPath ? `${currentPath}.${key}` : key);
+                if (mismatches.length >= maxPaths) {
+                    return;
+                }
+            }
+            return;
+        }
+        mismatches.push(currentPath || '(root)');
+    };
+    visit(expected, actual, path);
+    return mismatches;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export class MockRequestExpectationBuilder {
+    constructor(driver, criteria) {
+        this.driver = driver;
+        this.criteria = Object.assign({}, criteria);
+    }
+    withHeaders(headers) {
+        this.criteria.headers = headers;
+        return this;
+    }
+    withQuery(query) {
+        this.criteria.query = query;
+        return this;
+    }
+    withBody(body) {
+        this.criteria.body = body;
+        return this;
+    }
+    respond(response) {
+        this.driver.expect(Object.assign(Object.assign({}, this.criteria), { response }));
+        return this.driver;
+    }
+}
+export class MockRequestDriver {
+    constructor(config, expectations = [], options = {}) {
+        var _a;
+        this.config = config;
+        this.expectations = [];
+        this.history = [];
+        this.expectations.push(...expectations);
+        this.matchMode = (_a = options.matchMode) !== null && _a !== void 0 ? _a : 'ordered';
+    }
+    setMatchMode(mode) {
+        this.matchMode = mode;
+        return this;
+    }
+    ordered() {
+        return this.setMatchMode('ordered');
+    }
+    unordered() {
+        return this.setMatchMode('unordered');
+    }
+    expect(expectation) {
+        this.expectations.push(expectation);
+        return this;
+    }
+    expectAny(criteria) {
+        return new MockRequestExpectationBuilder(this, criteria);
+    }
+    reset() {
+        this.expectations = [];
+        this.history = [];
+        return this;
+    }
+    getHistory() {
+        return [...this.history];
+    }
+    assertNoPendingExpectations() {
+        this.assertExpectationsMet();
+    }
+    assertExpectationsMet() {
+        if (this.expectations.length === 0) {
+            return;
+        }
+        const nextExpectation = this.expectations[0];
+        if (!nextExpectation) {
+            return;
+        }
+        throw new MockRequestAssertionError([
+            `Expected ${this.expectations.length} more mocked request(s).`,
+            `Match mode: ${this.matchMode}`,
+            `Next expected request: ${this.describeExpectation(nextExpectation)}`
+        ].join('\n'));
+    }
+    send(url, method, headers, body, requestConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((_a = requestConfig === null || requestConfig === void 0 ? void 0 : requestConfig.abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                throw new DOMException('The operation was aborted.', 'AbortError');
+            }
+            const actualRequest = yield this.normalizeActualRequest(url, method, headers, body);
+            const { index, expectation } = yield this.selectExpectation(actualRequest);
+            this.expectations.splice(index, 1);
+            this.history.push(this.toHistoryEntry(actualRequest));
+            const response = new MockResponseHandler(expectation.response);
+            if (!response.getRawResponse().ok) {
+                throw new ResponseException(response);
+            }
+            return response;
+        });
+    }
+    selectExpectation(actualRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.expectations.length === 0) {
+                throw new MockRequestAssertionError(this.buildUnexpectedRequestMessage(actualRequest));
+            }
+            if (this.matchMode === 'ordered') {
+                const expectation = this.expectations[0];
+                if (!expectation) {
+                    throw new MockRequestAssertionError(this.buildUnexpectedRequestMessage(actualRequest));
+                }
+                const failure = yield this.matchExpectation(expectation, actualRequest);
+                if (failure) {
+                    throw new MockRequestAssertionError(this.buildMismatchMessage(failure, actualRequest));
+                }
+                return { index: 0, expectation };
+            }
+            const failures = [];
+            for (const [index, expectation] of this.expectations.entries()) {
+                const failure = yield this.matchExpectation(expectation, actualRequest);
+                if (!failure) {
+                    return { index, expectation };
+                }
+                failures.push(failure);
+            }
+            throw new MockRequestAssertionError(this.buildUnorderedMismatchMessage(actualRequest, failures));
+        });
+    }
+    matchExpectation(expectation, actualRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const methodFailure = this.matchMethod(expectation.method, actualRequest, expectation);
+            if (methodFailure) {
+                return methodFailure;
+            }
+            const urlFailure = this.matchUrl(expectation, actualRequest);
+            if (urlFailure) {
+                return urlFailure;
+            }
+            const headersFailure = this.matchHeaders(expectation.headers, actualRequest, expectation);
+            if (headersFailure) {
+                return headersFailure;
+            }
+            const queryFailure = this.matchQuery(expectation.query, actualRequest, expectation);
+            if (queryFailure) {
+                return queryFailure;
+            }
+            return yield this.matchBody(expectation.body, actualRequest, expectation);
+        });
+    }
+    matchMethod(method, actualRequest, expectation) {
+        if (isPredicate(method)) {
+            if (method(actualRequest.method)) {
+                return undefined;
+            }
+            return {
+                field: 'method',
+                message: 'Method matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(method),
+                actualValue: actualRequest.method
+            };
+        }
+        if (method === actualRequest.method) {
+            return undefined;
+        }
+        return {
+            field: 'method',
+            message: 'HTTP method did not match.',
+            expectation,
+            expectedValue: method,
+            actualValue: actualRequest.method
+        };
+    }
+    matchUrl(expectation, actualRequest) {
+        if (isPredicate(expectation.url)) {
+            if (expectation.url(actualRequest.parsedUrl)) {
+                return undefined;
+            }
+            return {
+                field: 'url',
+                message: 'URL matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(expectation.url),
+                actualValue: actualRequest.url
+            };
+        }
+        const expectedUrl = parseUrl(expectation.url);
+        const actualComparableUrl = expectation.query !== undefined && expectedUrl.search.length === 0 ? actualRequest.urlWithoutQuery : actualRequest.url;
+        const expectedComparableUrl = expectation.query !== undefined && expectedUrl.search.length === 0 ? buildUrlWithoutQuery(expectedUrl) : this.normalizeUrl(expectation.url);
+        if (expectedComparableUrl === actualComparableUrl) {
+            return undefined;
+        }
+        return {
+            field: 'url',
+            message: 'URL did not match.',
+            expectation,
+            expectedValue: expectedComparableUrl,
+            actualValue: actualComparableUrl
+        };
+    }
+    matchHeaders(headers, actualRequest, expectation) {
+        if (headers === undefined) {
+            return undefined;
+        }
+        if (isPredicate(headers)) {
+            if (headers(actualRequest.headers)) {
+                return undefined;
+            }
+            return {
+                field: 'headers',
+                message: 'Header matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(headers),
+                actualValue: actualRequest.headers
+            };
+        }
+        const expectedHeaders = this.resolveHeaders(headers);
+        if (isEqual(expectedHeaders, actualRequest.headers)) {
+            return undefined;
+        }
+        return {
+            field: 'headers',
+            message: 'Headers did not match exactly.',
+            expectation,
+            expectedValue: expectedHeaders,
+            actualValue: actualRequest.headers
+        };
+    }
+    matchQuery(query, actualRequest, expectation) {
+        if (query === undefined) {
+            return undefined;
+        }
+        if (isPredicate(query)) {
+            if (query(actualRequest.query)) {
+                return undefined;
+            }
+            return {
+                field: 'query',
+                message: 'Query matcher returned false.',
+                expectation,
+                expectedValue: getPredicateDescription(query),
+                actualValue: actualRequest.query
+            };
+        }
+        if (isEqual(query, actualRequest.query)) {
+            return undefined;
+        }
+        return {
+            field: 'query',
+            message: 'Query parameters did not match exactly.',
+            expectation,
+            expectedValue: query,
+            actualValue: actualRequest.query
+        };
+    }
+    matchBody(body, actualRequest, expectation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (body === undefined) {
+                return undefined;
+            }
+            if (isPredicate(body)) {
+                const context = this.createBodyMatchContext(actualRequest);
+                if (body(context)) {
+                    return undefined;
+                }
+                return {
+                    field: 'body',
+                    message: 'Body matcher returned false.',
+                    expectation,
+                    expectedValue: getPredicateDescription(body),
+                    actualValue: this.describeBodyForMessage(actualRequest.body)
+                };
+            }
+            const expectedBody = yield this.normalizeBody(body);
+            if (JSON.stringify(expectedBody) === JSON.stringify(actualRequest.body)) {
+                return undefined;
+            }
+            const expectedJson = getJsonBody(expectedBody);
+            const actualJson = getJsonBody(actualRequest.body);
+            return Object.assign({ field: 'body', message: expectedJson !== undefined && actualJson !== undefined ? 'JSON body did not match.' : 'Body did not match exactly.', expectation, expectedValue: expectedJson !== null && expectedJson !== void 0 ? expectedJson : expectedBody, actualValue: actualJson !== null && actualJson !== void 0 ? actualJson : actualRequest.body }, (expectedJson !== undefined && actualJson !== undefined ? { diffPaths: collectJsonDiffPaths(expectedJson, actualJson) } : {}));
+        });
+    }
+    createBodyMatchContext(actualRequest) {
+        return Object.assign(Object.assign({ method: actualRequest.method, url: actualRequest.url, headers: actualRequest.headers }, (actualRequest.body !== undefined ? { body: actualRequest.body } : {})), { getJson: () => getJsonBody(actualRequest.body), getText: () => getTextBody(actualRequest.body), getQuery: () => actualRequest.query });
+    }
+    normalizeActualRequest(url, method, headers, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const resolvedUrl = parseUrl(url);
+            const normalizedBody = yield this.normalizeBody(body === null || body === void 0 ? void 0 : body.getContent());
+            return Object.assign({ method, url: this.normalizeUrl(url), urlWithoutQuery: buildUrlWithoutQuery(resolvedUrl), parsedUrl: resolvedUrl, headers: this.resolveHeaders(Object.assign(Object.assign(Object.assign({}, (_a = this.config) === null || _a === void 0 ? void 0 : _a.headers), headers), body === null || body === void 0 ? void 0 : body.getHeaders())), query: parseQuery(resolvedUrl) }, (normalizedBody !== undefined ? { body: normalizedBody } : {}));
+        });
+    }
+    toHistoryEntry(request) {
+        return Object.assign({ method: request.method, url: request.url, headers: request.headers }, (request.body !== undefined ? { body: request.body } : {}));
+    }
+    buildUnexpectedRequestMessage(actualRequest) {
+        return ['Unexpected request received with no expectations left.', '', 'Actual request:', this.formatRequestSnapshot(actualRequest)].join('\n');
+    }
+    buildUnorderedMismatchMessage(actualRequest, failures) {
+        const pending = this.expectations.map((expectation, index) => `${index + 1}. ${this.describeExpectation(expectation)}`).join('\n');
+        const firstFailure = failures[0];
+        return [
+            'Mock request did not match any pending expectation.',
+            firstFailure ? `Closest failure: ${firstFailure.message}` : 'No expectation matched.',
+            '',
+            'Actual request:',
+            this.formatRequestSnapshot(actualRequest),
+            '',
+            'Pending expectations:',
+            pending
+        ].join('\n');
+    }
+    buildMismatchMessage(failure, actualRequest) {
+        const lines = [
+            `Mock request ${failure.field} mismatch.`,
+            failure.message,
+            '',
+            'Expected request:',
+            this.formatExpectationSnapshot(failure.expectation),
+            '',
+            'Actual request:',
+            this.formatRequestSnapshot(actualRequest)
+        ];
+        if (failure.expectedValue !== undefined || failure.actualValue !== undefined) {
+            lines.push('', `Expected ${failure.field}: ${stringify(failure.expectedValue)}`, `Actual ${failure.field}: ${stringify(failure.actualValue)}`);
+        }
+        if (failure.diffPaths && failure.diffPaths.length > 0) {
+            lines.push('', `Differing JSON paths: ${failure.diffPaths.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    formatExpectationSnapshot(expectation) {
+        const lines = [`method: ${this.describeMatcher(expectation.method)}`, `url: ${this.describeUrlMatcher(expectation)}`];
+        if (expectation.headers !== undefined) {
+            lines.push(`headers: ${this.describeMatcher(expectation.headers)}`);
+        }
+        if (expectation.query !== undefined) {
+            lines.push(`query: ${this.describeMatcher(expectation.query)}`);
+        }
+        if (expectation.body !== undefined) {
+            lines.push(`body: ${this.describeBodyMatcher(expectation.body)}`);
+        }
+        return lines.join('\n');
+    }
+    formatRequestSnapshot(request) {
+        const lines = [
+            `method: ${request.method}`,
+            `url: ${request.url}`,
+            `headers: ${stringify(request.headers)}`,
+            `query: ${stringify(request.query)}`,
+            `body: ${stringify(this.describeBodyForMessage(request.body))}`
+        ];
+        return lines.join('\n');
+    }
+    describeExpectation(expectation) {
+        return `${this.describeMatcher(expectation.method)} ${this.describeUrlMatcher(expectation)}`;
+    }
+    describeMatcher(matcher) {
+        if (isPredicate(matcher)) {
+            return getPredicateDescription(matcher);
+        }
+        if (typeof matcher === 'object') {
+            return stringify(matcher);
+        }
+        return String(matcher);
+    }
+    describeUrlMatcher(expectation) {
+        if (isPredicate(expectation.url)) {
+            return getPredicateDescription(expectation.url);
+        }
+        const url = parseUrl(expectation.url);
+        if (expectation.query !== undefined && url.search.length === 0) {
+            return buildUrlWithoutQuery(url);
+        }
+        return this.normalizeUrl(expectation.url);
+    }
+    describeBodyMatcher(body) {
+        if (isPredicate(body)) {
+            return getPredicateDescription(body);
+        }
+        return stringify(body);
+    }
+    describeBodyForMessage(body) {
+        const json = getJsonBody(body);
+        return json !== null && json !== void 0 ? json : body;
+    }
+    normalizeUrl(url) {
+        return parseUrl(url).toString();
+    }
+    resolveHeaders(headers) {
+        const resolved = {};
+        for (const key in headers) {
+            const value = headers[key];
+            if (value === undefined) {
+                continue;
+            }
+            resolved[key] = typeof value === 'function' ? value() : value;
+        }
+        return resolved;
+    }
+    normalizeBody(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (body === undefined) {
+                return undefined;
+            }
+            if (body === null) {
+                return { kind: 'null' };
+            }
+            if (typeof body === 'string') {
+                return { kind: 'text', value: body };
+            }
+            if (body instanceof FormData) {
+                return yield this.normalizeFormData(body);
+            }
+            if (body instanceof Blob) {
+                const mimeType = body.type || undefined;
+                return Object.assign(Object.assign({ kind: 'binary' }, (mimeType !== undefined ? { mimeType } : {})), { bytes: Array.from(new Uint8Array(yield this.readBlob(body))) });
+            }
+            if (this.isBufferSource(body)) {
+                return {
+                    kind: 'binary',
+                    bytes: Array.from(new Uint8Array(this.toArrayBuffer(body)))
+                };
+            }
+            return {
+                kind: 'text',
+                value: JSON.stringify(body)
+            };
+        });
+    }
+    normalizeFormData(body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const entries = [];
+            for (const [key, value] of body.entries()) {
+                if (typeof value === 'string') {
+                    entries.push({ key, value: { kind: 'text', value } });
+                    continue;
+                }
+                entries.push({
+                    key,
+                    value: Object.assign(Object.assign({ kind: 'file' }, this.getOptionalBlobDetails(value)), { bytes: Array.from(new Uint8Array(yield this.readBlob(value))) })
+                });
+            }
+            return { kind: 'form-data', entries };
+        });
+    }
+    getBlobName(value) {
+        if (typeof File !== 'undefined' && value instanceof File) {
+            return value.name;
+        }
+        return undefined;
+    }
+    getOptionalBlobDetails(value) {
+        const name = this.getBlobName(value);
+        const mimeType = value.type || undefined;
+        return Object.assign(Object.assign({}, (name !== undefined ? { name } : {})), (mimeType !== undefined ? { mimeType } : {}));
+    }
+    readBlob(value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blobWithReader = value;
+            if (typeof blobWithReader.arrayBuffer === 'function') {
+                return yield blobWithReader.arrayBuffer();
+            }
+            if (typeof FileReader !== 'undefined') {
+                return yield new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.onload = () => resolve(reader.result);
+                    reader.onerror = () => { var _a; return reject((_a = reader.error) !== null && _a !== void 0 ? _a : new Error('Failed to read Blob contents.')); };
+                    reader.readAsArrayBuffer(value);
+                });
+            }
+            return yield new Response(value).arrayBuffer();
+        });
+    }
+    isBufferSource(value) {
+        return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+    }
+    toArrayBuffer(value) {
+        if (value instanceof ArrayBuffer) {
+            return value.slice(0);
+        }
+        return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    }
+}
+export function getMockRequestJsonBody(request) {
+    return getJsonBody(request.body);
+}
+export function getMockRequestTextBody(request) {
+    return getTextBody(request.body);
+}
+export function getMockRequestQuery(request) {
+    return parseQuery(parseUrl(request.url));
+}

package/dist/requests/drivers/mock/MockRequestTestHelpers.d.ts

@@ -0,0 +1,20 @@
+import { type DriverConfigContract } from '../../contracts/DriverConfigContract';
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type MockNormalizedRequestBody, type MockRequestBodyMatchContext, type MockRequestDriverOptions, MockRequestDriver, type MockRequestExpectation, type MockRequestHistoryEntry, type MockRequestPredicate, type MockRequestQuery, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody } from './MockRequestDriver';
+import { type MockResponseDefinition } from './MockResponseHandler';
+export interface InstallMockRequestDriverOptions extends MockRequestDriverOptions {
+    config?: DriverConfigContract;
+    expectations?: MockRequestExpectation[];
+}
+export declare function matchHeaders(expectedSubset: ResolvedHeadersContract): MockRequestPredicate<ResolvedHeadersContract>;
+export declare function matchQuery(expectedSubset: MockRequestQuery): MockRequestPredicate<MockRequestQuery>;
+export declare function expectJsonBody(expected: unknown, options?: {
+    partial?: boolean;
+}): MockRequestPredicate<MockRequestBodyMatchContext>;
+export declare function jsonResponse<ResponseBody extends object | string | Blob | BufferSource | null | undefined>(status: number, body: ResponseBody, headers?: ResolvedHeadersContract): MockResponseDefinition;
+export declare function validationError(errors: Record<string, string[]>, message?: string): MockResponseDefinition;
+export declare function emptyResponse(status?: number, headers?: ResolvedHeadersContract): MockResponseDefinition;
+export declare function installMockRequestDriver(options?: InstallMockRequestDriverOptions): MockRequestDriver;
+export declare function resetMockRequestDriver(): MockRequestDriver;
+export { getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };
+export type { MockNormalizedRequestBody, MockRequestHistoryEntry };

package/dist/requests/drivers/mock/MockRequestTestHelpers.js

@@ -0,0 +1,70 @@
+import { isEqual } from 'lodash-es';
+import { BaseRequest } from '../../BaseRequest';
+import { MockRequestDriver, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody } from './MockRequestDriver';
+function createPredicate(description, predicate) {
+    const matcher = ((value) => predicate(value));
+    matcher.description = description;
+    return matcher;
+}
+function matchesSubset(actual, expected) {
+    if (Array.isArray(expected)) {
+        if (!Array.isArray(actual) || actual.length < expected.length) {
+            return false;
+        }
+        return expected.every((item, index) => matchesSubset(actual[index], item));
+    }
+    if (isRecord(expected)) {
+        if (!isRecord(actual)) {
+            return false;
+        }
+        return Object.keys(expected).every((key) => matchesSubset(actual[key], expected[key]));
+    }
+    return isEqual(actual, expected);
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function matchHeaders(expectedSubset) {
+    return createPredicate(`headers subset ${JSON.stringify(expectedSubset)}`, (actual) => Object.entries(expectedSubset).every(([key, value]) => actual[key] === value));
+}
+export function matchQuery(expectedSubset) {
+    return createPredicate(`query subset ${JSON.stringify(expectedSubset)}`, (actual) => Object.entries(expectedSubset).every(([key, value]) => isEqual(actual[key], value)));
+}
+export function expectJsonBody(expected, options = {}) {
+    return createPredicate(options.partial ? `JSON body partial ${JSON.stringify(expected)}` : `JSON body ${JSON.stringify(expected)}`, (context) => {
+        const actual = context.getJson();
+        if (actual === undefined) {
+            return false;
+        }
+        return options.partial ? matchesSubset(actual, expected) : isEqual(actual, expected);
+    });
+}
+export function jsonResponse(status, body, headers) {
+    return Object.assign(Object.assign({ status }, (headers !== undefined ? { headers } : {})), { body });
+}
+export function validationError(errors, message = 'The given data was invalid.') {
+    return jsonResponse(422, {
+        message,
+        errors
+    });
+}
+export function emptyResponse(status = 204, headers) {
+    return Object.assign({ status }, (headers !== undefined ? { headers } : {}));
+}
+let installedMockRequestDriver;
+export function installMockRequestDriver(options = {}) {
+    var _a;
+    const driver = new MockRequestDriver(options.config, (_a = options.expectations) !== null && _a !== void 0 ? _a : [], options.matchMode !== undefined ? { matchMode: options.matchMode } : {});
+    BaseRequest.setRequestDriver(driver);
+    installedMockRequestDriver = driver;
+    return driver;
+}
+export function resetMockRequestDriver() {
+    if (!installedMockRequestDriver) {
+        return installMockRequestDriver();
+    }
+    installedMockRequestDriver.reset();
+    BaseRequest.setRequestDriver(installedMockRequestDriver);
+    return installedMockRequestDriver;
+}
+export { getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };

package/dist/requests/drivers/mock/MockResponseHandler.d.ts

@@ -0,0 +1,22 @@
+import { type ResolvedHeadersContract } from '../../contracts/HeadersContract';
+import { type ResponseHandlerContract } from '../contracts/ResponseHandlerContract';
+export type MockResponseBody = string | Blob | BufferSource | object | null | undefined;
+export interface MockResponseDefinition {
+    status?: number;
+    statusText?: string;
+    headers?: ResolvedHeadersContract;
+    body?: MockResponseBody;
+}
+export declare class MockResponseHandler implements ResponseHandlerContract {
+    protected response: Response;
+    constructor(definition: MockResponseDefinition);
+    getStatusCode(): number | undefined;
+    getHeaders(): ResolvedHeadersContract;
+    getRawResponse(): Response;
+    json<ResponseBodyInterface>(): Promise<ResponseBodyInterface>;
+    text(): Promise<string>;
+    blob(): Promise<Blob>;
+    protected resolveBody(body: MockResponseBody, headers: Headers): BodyInit | null | undefined;
+    protected isJsonValue(value: MockResponseBody): value is object;
+    protected hasHeader(headers: Headers, key: string): boolean;
+}

package/dist/requests/drivers/mock/MockResponseHandler.js

@@ -0,0 +1,59 @@
+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 MockResponseHandler {
+    constructor(definition) {
+        var _a;
+        const headers = new Headers(definition.headers);
+        const body = this.resolveBody(definition.body, headers);
+        this.response = new Response(body, Object.assign({ status: (_a = definition.status) !== null && _a !== void 0 ? _a : 200, headers }, (definition.statusText !== undefined ? { statusText: definition.statusText } : {})));
+    }
+    getStatusCode() {
+        return this.response.status;
+    }
+    getHeaders() {
+        return Object.fromEntries(this.response.headers);
+    }
+    getRawResponse() {
+        return this.response;
+    }
+    json() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.clone().json();
+        });
+    }
+    text() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.clone().text();
+        });
+    }
+    blob() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.response.clone().blob();
+        });
+    }
+    resolveBody(body, headers) {
+        if (body === undefined || body === null) {
+            return body;
+        }
+        if (this.isJsonValue(body)) {
+            if (!this.hasHeader(headers, 'content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+            return JSON.stringify(body);
+        }
+        return body;
+    }
+    isJsonValue(value) {
+        return typeof value === 'object' && value !== null && !(value instanceof Blob) && !(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value);
+    }
+    hasHeader(headers, key) {
+        return Array.from(headers.keys()).some((headerKey) => headerKey.toLowerCase() === key.toLowerCase());
+    }
+}

package/dist/requests/index.d.ts

@@ -13,6 +13,9 @@ import { BinaryBody } from './bodies/BinaryBody';
 import { JsonBodyFactory } from './factories/JsonBodyFactory';
 import { BinaryBodyFactory, type BinaryBodyContent } from './factories/BinaryBodyFactory';
 import { FormDataFactory } from './factories/FormDataFactory';
+import { MockRequestDriver, MockRequestExpectationBuilder, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody, type MockNormalizedRequestBody, type MockRequestBody, type MockRequestBodyMatchContext, type MockRequestBodyMatcher, type MockRequestDriverOptions, type MockRequestExpectation, type MockRequestExpectationCriteria, type MockRequestHeadersMatcher, type MockRequestHistoryEntry, type MockRequestMatchMode, type MockRequestMethodMatcher, type MockRequestPredicate, type MockRequestQuery, type MockRequestQueryMatcher, type MockRequestUrlMatcher, type MockResponseBody, type MockResponseDefinition } from './drivers/mock/MockRequestDriver';
+import { MockRequestAssertionError } from './drivers/mock/MockRequestAssertionError';
+import { emptyResponse, expectJsonBody, installMockRequestDriver, jsonResponse, matchHeaders, matchQuery, resetMockRequestDriver, validationError, type InstallMockRequestDriverOptions } from './drivers/mock/MockRequestTestHelpers';
 import { type BodyContent, type BodyContract } from './contracts/BodyContract';
 import { type RequestLoaderContract } from './contracts/RequestLoaderContract';
 import { type RequestDriverContract } from './contracts/RequestDriverContract';
@@ -27,5 +30,5 @@ import { type HeaderValue, type HeadersContract, type ResolvedHeadersContract }
 import { type RequestConcurrencyOptions } from './types/RequestConcurrencyOptions';
 import { type RequestUploadProgress } from './types/RequestUploadProgress';
 import { XMLHttpRequestDriver } from './drivers/xhr/XMLHttpRequestDriver';
-export { FetchDriver, BaseResponse, JsonResponse, BlobResponse, PlainTextResponse, BaseRequest, ErrorHandler, RequestErrorRouter, RequestEvents, RequestMethodEnum, RequestConcurrencyMode, ResponseException, StaleResponseException, BinaryBody, JsonBodyFactory, BinaryBodyFactory, FormDataFactory, XMLHttpRequestDriver };
-export type { BodyContent, BinaryBodyContent, RequestDriverContract, RequestLoaderContract, BodyContract, RequestLoaderFactoryContract, DriverConfigContract, BodyFactoryContract, ResponseHandlerContract, BaseRequestContract, HeaderValue, HeadersContract, ResolvedHeadersContract, RequestConcurrencyOptions, RequestUploadProgress };
+export { FetchDriver, BaseResponse, JsonResponse, BlobResponse, PlainTextResponse, BaseRequest, ErrorHandler, RequestErrorRouter, RequestEvents, RequestMethodEnum, RequestConcurrencyMode, ResponseException, StaleResponseException, BinaryBody, JsonBodyFactory, BinaryBodyFactory, FormDataFactory, XMLHttpRequestDriver, MockRequestDriver, MockRequestExpectationBuilder, MockRequestAssertionError, expectJsonBody, matchHeaders, matchQuery, jsonResponse, validationError, emptyResponse, installMockRequestDriver, resetMockRequestDriver, getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };
+export type { BodyContent, BinaryBodyContent, RequestDriverContract, RequestLoaderContract, BodyContract, RequestLoaderFactoryContract, DriverConfigContract, BodyFactoryContract, ResponseHandlerContract, BaseRequestContract, HeaderValue, HeadersContract, ResolvedHeadersContract, RequestConcurrencyOptions, RequestUploadProgress, MockNormalizedRequestBody, MockRequestBody, MockRequestBodyMatchContext, MockRequestBodyMatcher, MockRequestDriverOptions, MockRequestExpectation, MockRequestExpectationCriteria, MockRequestHeadersMatcher, MockRequestHistoryEntry, MockRequestMatchMode, MockRequestMethodMatcher, MockRequestPredicate, MockRequestQuery, MockRequestQueryMatcher, MockRequestUrlMatcher, MockResponseBody, MockResponseDefinition, InstallMockRequestDriverOptions };

package/dist/requests/index.js

@@ -13,7 +13,10 @@ import { BinaryBody } from './bodies/BinaryBody';
 import { JsonBodyFactory } from './factories/JsonBodyFactory';
 import { BinaryBodyFactory } from './factories/BinaryBodyFactory';
 import { FormDataFactory } from './factories/FormDataFactory';
+import { MockRequestDriver, MockRequestExpectationBuilder, getMockRequestJsonBody, getMockRequestQuery, getMockRequestTextBody } from './drivers/mock/MockRequestDriver';
+import { MockRequestAssertionError } from './drivers/mock/MockRequestAssertionError';
+import { emptyResponse, expectJsonBody, installMockRequestDriver, jsonResponse, matchHeaders, matchQuery, resetMockRequestDriver, validationError } from './drivers/mock/MockRequestTestHelpers';
 import { ResponseException } from './exceptions/ResponseException';
 import { StaleResponseException } from './exceptions/StaleResponseException';
 import { XMLHttpRequestDriver } from './drivers/xhr/XMLHttpRequestDriver';
-export { FetchDriver, BaseResponse, JsonResponse, BlobResponse, PlainTextResponse, BaseRequest, ErrorHandler, RequestErrorRouter, RequestEvents, RequestMethodEnum, RequestConcurrencyMode, ResponseException, StaleResponseException, BinaryBody, JsonBodyFactory, BinaryBodyFactory, FormDataFactory, XMLHttpRequestDriver };
+export { FetchDriver, BaseResponse, JsonResponse, BlobResponse, PlainTextResponse, BaseRequest, ErrorHandler, RequestErrorRouter, RequestEvents, RequestMethodEnum, RequestConcurrencyMode, ResponseException, StaleResponseException, BinaryBody, JsonBodyFactory, BinaryBodyFactory, FormDataFactory, XMLHttpRequestDriver, MockRequestDriver, MockRequestExpectationBuilder, MockRequestAssertionError, expectJsonBody, matchHeaders, matchQuery, jsonResponse, validationError, emptyResponse, installMockRequestDriver, resetMockRequestDriver, getMockRequestJsonBody, getMockRequestTextBody, getMockRequestQuery };

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

@@ -1,6 +1,7 @@
 import { BaseForm, propertyAwareToRaw } from './BaseForm';
 import { type PersistedForm } from './types/PersistedForm';
 import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver';
+import { MemoryPersistenceDriver } from '../../persistenceDrivers/MemoryPersistenceDriver';
 import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
 import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver';
 import { type PersistenceDriver } from '../../persistenceDrivers/types/PersistenceDriver';
@@ -8,5 +9,5 @@ import { PropertyAwareArray, type PropertyAwareField, type PropertyAware } from
 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 { BaseForm, propertyAwareToRaw, PropertyAwareArray, PropertyAwareObject, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver, MemoryPersistenceDriver, StrictPersistenceRestorePolicy };
 export type { PersistedForm, PersistenceDriver, PropertyAwareField, PropertyAware, PersistenceDebugEvent, PersistenceRestoreContext, PersistenceRestorePolicy, PersistenceRestoreResult };

package/dist/vue/forms/index.js

@@ -1,8 +1,9 @@
 import { BaseForm, propertyAwareToRaw } from './BaseForm';
 import { LocalStorageDriver } from '../../persistenceDrivers/LocalStorageDriver';
+import { MemoryPersistenceDriver } from '../../persistenceDrivers/MemoryPersistenceDriver';
 import { NonPersistentDriver } from '../../persistenceDrivers/NonPersistentDriver';
 import { SessionStorageDriver } from '../../persistenceDrivers/SessionStorageDriver';
 import { PropertyAwareArray } from './PropertyAwareArray';
 import { PropertyAwareObject } from './PropertyAwareObject';
 import { StrictPersistenceRestorePolicy } from './persistence';
-export { BaseForm, propertyAwareToRaw, PropertyAwareArray, PropertyAwareObject, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver, StrictPersistenceRestorePolicy };
+export { BaseForm, propertyAwareToRaw, PropertyAwareArray, PropertyAwareObject, NonPersistentDriver, SessionStorageDriver, LocalStorageDriver, MemoryPersistenceDriver, StrictPersistenceRestorePolicy };

package/package.json

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