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

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;