@mountainpass/waychaser 4.0.38 → 5.0.2

package/dist/waychaser.d.ts

@@ -0,0 +1,130 @@
+import { InvocableOperation, Operation } from './operation';
+import { OperationArray } from './operation-array';
+import { ProblemDocument } from '@mountainpass/problem-document';
+export declare type ValidationSuccess<Content> = {
+    success: true;
+    content: Content;
+};
+export declare type ValidationError = {
+    success: false;
+    problem: ProblemDocument;
+};
+export declare type ValidationResult<Content> = ValidationSuccess<Content> | ValidationError;
+export declare type Validator<Content> = (content: unknown) => ValidationResult<Content>;
+/**
+ * @param result
+ */
+export declare function isValidationSuccess<Content>(result: ValidationResult<Content>): result is ValidationSuccess<Content>;
+export declare class WayChaserResponse<Content> {
+    content: Content;
+    allOperations: Record<string, Array<Operation>>;
+    operations: OperationArray;
+    anchor?: string;
+    response: Response;
+    fullContent?: unknown;
+    parameters: Record<string, unknown>;
+    constructor({ handlers, defaultOptions, baseResponse, content, fullContent, anchor, parentOperations, parameters }: {
+        handlers?: HandlerSpec[];
+        defaultOptions?: WayChaserOptions;
+        baseResponse: Response;
+        content: Content;
+        fullContent?: unknown;
+        parameters?: Record<string, unknown>;
+        anchor?: string;
+        parentOperations?: Record<string, Array<Operation>>;
+    });
+    static create(baseResponse: Response, content: unknown, defaultOptions: WayChaserOptions, mergedOptions: WayChaserOptions): WayChaserResponse<unknown>;
+    static create<Content>(baseResponse: Response, content: unknown, defaultOptions: WayChaserOptions, mergedOptions: WayChaserOptions<Content>): WayChaserResponse<Content>;
+    get ops(): OperationArray;
+    invoke(relationship: string | Record<string, unknown> | ((this: void, value: InvocableOperation, index: number, object: InvocableOperation[]) => unknown), options?: Partial<WayChaserOptions>): Promise<WayChaserResponse<unknown>> | undefined;
+    invoke<RelatedContent>(relationship: string | Record<string, unknown> | ((this: void, value: InvocableOperation, index: number, object: InvocableOperation[]) => unknown), options?: Partial<WayChaserOptions<RelatedContent>>): Promise<WayChaserResponse<RelatedContent>> | undefined;
+    invokeAll(relationship: string | Record<string, unknown> | ((this: void, value: InvocableOperation, index: number, object: InvocableOperation[]) => unknown), options?: Partial<WayChaserOptions>): Promise<Array<WayChaserResponse<unknown>>>;
+    invokeAll<RelatedContent>(relationship: string | Record<string, unknown> | ((this: void, value: InvocableOperation, index: number, object: InvocableOperation[]) => unknown), options?: Partial<WayChaserOptions<RelatedContent>>): Promise<Array<WayChaserResponse<RelatedContent>>>;
+    get body(): ReadableStream;
+    get bodyUsed(): boolean;
+    get headers(): Headers;
+    get ok(): boolean;
+    get redirected(): boolean;
+    get status(): number;
+    get statusText(): string;
+    get type(): ResponseType;
+    get url(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<Blob>;
+    clone(): Response;
+    formData(): Promise<FormData>;
+    text(): Promise<string>;
+}
+export declare class WayChaserProblem extends Error {
+    readonly problem: ProblemDocument;
+    readonly response: WayChaserResponse<unknown>;
+    constructor({ response, problem }: {
+        response: WayChaserResponse<unknown>;
+        problem: ProblemDocument;
+    });
+}
+export declare type HandlerSpec = {
+    handler: (baseResponse: Response, content: unknown, stopper: () => void) => Array<Operation> | undefined;
+    mediaRanges: Array<string | {
+        mediaType: string;
+        q?: number;
+    }>;
+    q?: number;
+};
+export declare type Stopper = () => void;
+export declare type WayChaserOptions<ValidatorContent = null> = RequestInit & {
+    fetch: typeof fetch;
+    handlers: Array<HandlerSpec>;
+    defaultHandlers: Array<HandlerSpec>;
+    preInterceptors: Array<(uriOrRequest: any, updateOptions: any, stopper: any) => void>;
+    postInterceptors: Array<(<InterceptorContent>(response: (WayChaserResponse<InterceptorContent>), stop: Stopper) => void)>;
+    postErrorInterceptors: Array<(error: WayChaserProblem | Error, stopper: Stopper) => void>;
+    contentParser: (response: Response) => Promise<unknown | ProblemDocument | undefined>;
+    parameters?: Record<string, unknown>;
+    validator?: Validator<ValidatorContent>;
+};
+/**
+ * @param handlers
+ */
+export declare function sortHandlers(handlers: Array<HandlerSpec>): Array<HandlerSpec>;
+export declare function _waychaser(uriOrRequest: string | Request, defaults: WayChaserOptions, options?: Partial<WayChaserOptions>): Promise<WayChaserResponse<unknown>>;
+export declare function _waychaser<Content>(uriOrRequest: string | Request, defaults: WayChaserOptions, options?: Partial<WayChaserOptions<Content>>): Promise<WayChaserResponse<Content>>;
+/**
+ * calls fetch on the passed in uriOrRequest and parses the response
+ *
+ * @param uriOrRequest see RequestInit
+ * @param options see WayChaserOptions
+ * @returns WayChaserResponse<Content>
+ * @throws TypeError | AbortError | WayChaserResponseProblem | Error
+ */
+export declare const waychaser: (<Content>(uriOrRequest: string | Request, options?: Partial<WayChaserOptions<Content>> | undefined) => Promise<WayChaserResponse<Content>>) & {
+    currentDefaults: WayChaserOptions<null>;
+    defaults: (newDefaults: Partial<WayChaserOptions>) => {
+        <Content_1>(uriOrRequest: string | Request, options?: Partial<WayChaserOptions<Content_1>> | undefined): Promise<WayChaserResponse<Content_1>>;
+        currentDefaults: {
+            defaultHandlers: HandlerSpec[];
+            handlers: never[];
+            headers: {};
+            body?: BodyInit | null | undefined;
+            cache?: RequestCache | undefined;
+            credentials?: RequestCredentials | undefined;
+            integrity?: string | undefined;
+            keepalive?: boolean | undefined;
+            method?: string | undefined;
+            mode?: RequestMode | undefined;
+            redirect?: RequestRedirect | undefined;
+            referrer?: string | undefined;
+            referrerPolicy?: ReferrerPolicy | undefined;
+            signal?: AbortSignal | null | undefined;
+            window?: null | undefined;
+            fetch: typeof fetch;
+            preInterceptors: ((uriOrRequest: any, updateOptions: any, stopper: any) => void)[];
+            postInterceptors: (<InterceptorContent>(response: WayChaserResponse<InterceptorContent>, stop: Stopper) => void)[];
+            postErrorInterceptors: ((error: WayChaserProblem | Error, stopper: Stopper) => void)[];
+            contentParser: (response: Response) => Promise<unknown | ProblemDocument | undefined>;
+            parameters?: Record<string, unknown> | undefined;
+            validator?: Validator<null> | undefined;
+        };
+        defaults(newDefaults: Partial<WayChaserOptions>): any;
+    };
+};