keq 2.0.0 → 2.0.2

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.0.2](https://www.github.com/keq-request/keq/compare/v2.0.1...v2.0.2) (2023-09-27)
+
+
+### Bug Fixes
+
+* cannot import umd package ([4eb05b3](https://www.github.com/keq-request/keq/commit/4eb05b35a41fd7b00e21ae5978eb3dc3900a3bdc))
+
+### [2.0.1](https://www.github.com/keq-request/keq/compare/v2.0.0...v2.0.1) (2023-09-27)
+
+
+### Bug Fixes
+
+* cannot import createRequest ([2acdc47](https://www.github.com/keq-request/keq/commit/2acdc47200c36c83d7539f7d3b68d8df7bb49803))
+
 ## [2.0.0](https://www.github.com/keq-request/keq/compare/v1.10.1...v2.0.0) (2023-09-25)
 
 

package/dist/esm/src/index.d.ts

@@ -1,3 +1,4 @@
+export { createRequest } from './create-request';
 export { Keq } from './keq';
 export { composeMiddleware } from './middleware';
 export { request } from './request';

package/dist/esm/src/index.js

@@ -1,3 +1,4 @@
+export { createRequest } from './create-request';
 export { Keq } from './keq';
 export { composeMiddleware } from './middleware';
 export { request } from './request';

package/dist/umd/src/constant.d.ts

@@ -0,0 +1 @@
+export declare const OUTPUT_PROPERTY: unique symbol;

package/dist/umd/src/constant.js

@@ -0,0 +1,14 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OUTPUT_PROPERTY = void 0;
+    exports.OUTPUT_PROPERTY = Symbol('outputProperty');
+});

package/dist/umd/src/core.d.ts

@@ -0,0 +1,28 @@
+import { URL } from 'whatwg-url';
+import { KeqRequestContext } from './types/keq-context';
+import { KeqMiddleware } from './types/keq-middleware';
+import { KeqOptions } from './types/keq-options';
+import { KeqRequestInit } from './types/keq-request-init';
+/**
+ * @description Keq 核心 API，发送请求必要的原子化的API
+ */
+export declare class Core<T> {
+    private requestPromise?;
+    protected requestContext: KeqRequestContext;
+    protected __prepend_middlewares__: KeqMiddleware[];
+    protected __append_middlewares__: KeqMiddleware[];
+    protected __options__: KeqOptions;
+    constructor(url: (URL | globalThis.URL), init: KeqRequestInit);
+    prependMiddlewares(...middlewares: KeqMiddleware[]): this;
+    appendMiddlewares(...middlewares: KeqMiddleware[]): this;
+    private run;
+    end(): Promise<T>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+}

package/dist/umd/src/core.js

@@ -0,0 +1,125 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "whatwg-url", "./exception/exception", "./util/clone", "./constant", "./middleware", "./util/shadow-clone"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Core = void 0;
+    const whatwg_url_1 = require("whatwg-url");
+    const exception_1 = require("./exception/exception");
+    const clone_1 = require("./util/clone");
+    const constant_1 = require("./constant");
+    const middleware_1 = require("./middleware");
+    const shadow_clone_1 = require("./util/shadow-clone");
+    /**
+     * @description Keq 核心 API，发送请求必要的原子化的API
+     */
+    class Core {
+        requestPromise;
+        requestContext;
+        __prepend_middlewares__ = [];
+        __append_middlewares__ = [];
+        __options__ = { resolveWithFullResponse: false };
+        constructor(url, init) {
+            this.requestContext = {
+                method: 'get',
+                headers: new Headers(),
+                routeParams: {},
+                body: undefined,
+                ...init,
+                url: new whatwg_url_1.URL(url.href),
+            };
+        }
+        prependMiddlewares(...middlewares) {
+            this.__prepend_middlewares__.push(...middlewares);
+            return this;
+        }
+        appendMiddlewares(...middlewares) {
+            this.__append_middlewares__.unshift(...middlewares);
+            return this;
+        }
+        async run() {
+            const headers = new Headers();
+            for (const [key, value] of this.requestContext.headers.entries()) {
+                headers.append(key, value);
+            }
+            const requestContext = {
+                method: this.requestContext.method,
+                url: new whatwg_url_1.URL(this.requestContext.url.href),
+                headers,
+                routeParams: (0, shadow_clone_1.shadowClone)(this.requestContext.routeParams),
+                body: (0, clone_1.clone)(this.requestContext.body),
+            };
+            const options = (0, shadow_clone_1.shadowClone)(this.__options__);
+            const ctx = {
+                request: requestContext,
+                options,
+                get output() {
+                    throw new exception_1.Exception('output property is write-only');
+                },
+                set output(value) {
+                    this[constant_1.OUTPUT_PROPERTY] = value;
+                },
+            };
+            const middleware = (0, middleware_1.composeMiddleware)([...this.__prepend_middlewares__, ...this.__append_middlewares__]);
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            await middleware(ctx, async () => { });
+            let output = ctx[constant_1.OUTPUT_PROPERTY];
+            if (ctx.options.resolveWithFullResponse) {
+                return ctx.response;
+            }
+            if (!(constant_1.OUTPUT_PROPERTY in ctx)) {
+                const response = ctx.response;
+                if (response?.status === 204) {
+                    // 204: NO CONTENT
+                    output = response && response.body;
+                }
+                else {
+                    const headers = response?.headers;
+                    const contentType = headers?.get('content-type') || '';
+                    try {
+                        if (contentType.includes('application/json')) {
+                            output = ctx.response && await ctx.response.json();
+                        }
+                        else if (contentType.includes('multipart/form-data')) {
+                            output = ctx.response && await ctx.response.formData();
+                        }
+                        else if (contentType.includes('plain/text')) {
+                            output = ctx.response && await ctx.response.text();
+                        }
+                        else {
+                            output = ctx.response && ctx.response.body;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to auto parse response body', e);
+                    }
+                }
+            }
+            return output;
+        }
+        async end() {
+            return this.run();
+        }
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onfulfilled The callback to execute when the Promise is resolved.
+         * @param onrejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         */
+        then(onfulfilled, onrejected) {
+            if (!this.requestPromise)
+                this.requestPromise = this.end();
+            return this.requestPromise.then(onfulfilled, onrejected);
+        }
+        catch(onrejected) {
+            return this.end().catch(onrejected);
+        }
+    }
+    exports.Core = Core;
+});

package/dist/umd/src/exception/exception.d.ts

@@ -0,0 +1,4 @@
+import { CustomError } from 'ts-custom-error';
+export declare class Exception extends CustomError {
+    constructor(message?: string);
+}

package/dist/umd/src/exception/exception.js

@@ -0,0 +1,21 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "ts-custom-error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Exception = void 0;
+    const ts_custom_error_1 = require("ts-custom-error");
+    class Exception extends ts_custom_error_1.CustomError {
+        constructor(message) {
+            super(message);
+            Object.defineProperty(this, 'name', { value: 'KeqError' });
+        }
+    }
+    exports.Exception = Exception;
+});

package/dist/umd/src/exception/invalid-arguments.exception.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from './exception';
+export declare class InvalidArgumentsExceptions extends Exception {
+    constructor();
+}

package/dist/umd/src/exception/invalid-arguments.exception.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InvalidArgumentsExceptions = void 0;
+    const exception_1 = require("./exception");
+    class InvalidArgumentsExceptions extends exception_1.Exception {
+        constructor() {
+            super('Invalid arguments');
+        }
+    }
+    exports.InvalidArgumentsExceptions = InvalidArgumentsExceptions;
+});

package/dist/umd/src/exception/overwrite-array-body.exception.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from './exception';
+export declare class OverwriteArrayBodyException extends Exception {
+    constructor();
+}

package/dist/umd/src/exception/overwrite-array-body.exception.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OverwriteArrayBodyException = void 0;
+    const exception_1 = require("./exception");
+    class OverwriteArrayBodyException extends exception_1.Exception {
+        constructor() {
+            super('Cannot merge or overwrite body, because it has been set as an array. Please use .body(arr) instead');
+        }
+    }
+    exports.OverwriteArrayBodyException = OverwriteArrayBodyException;
+});

package/dist/umd/src/is/is-blob.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if given valie is Blob or File -like object
+ */
+export declare function isBlob(value: any): value is Blob;

package/dist/umd/src/is/is-blob.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object", "./is-string"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBlob = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    const is_string_1 = require("./is-string");
+    const names = ['Blob', 'File'];
+    /**
+     * Check if given valie is Blob or File -like object
+     */
+    function isBlob(value) {
+        if (value instanceof Blob)
+            return true;
+        return (0, is_object_1.isObject)(value)
+            && (0, is_string_1.isString)(value.type)
+            && (0, is_function_1.isFunction)(value.arrayBuffer)
+            && (0, is_function_1.isFunction)(value.stream)
+            && (0, is_function_1.isFunction)(value.constructor)
+            && names.includes(value.constructor.name)
+            && 'size' in value;
+    }
+    exports.isBlob = isBlob;
+});

package/dist/umd/src/is/is-browser.d.ts

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/dist/umd/src/is/is-browser.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBrowser = void 0;
+    function isBrowser() {
+        return typeof window !== 'undefined';
+    }
+    exports.isBrowser = isBrowser;
+});

package/dist/umd/src/is/is-file.d.ts

@@ -0,0 +1 @@
+export declare function isFile(object: any): object is File;

package/dist/umd/src/is/is-file.js

@@ -0,0 +1,21 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-blob", "./is-browser"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFile = void 0;
+    const is_blob_1 = require("./is-blob");
+    const is_browser_1 = require("./is-browser");
+    function isFile(object) {
+        if ((0, is_browser_1.isBrowser)())
+            return object instanceof Blob;
+        return (0, is_blob_1.isBlob)(object);
+    }
+    exports.isFile = isFile;
+});

package/dist/umd/src/is/is-form-data.d.ts

@@ -0,0 +1 @@
+export declare function isFormData(object: any): object is FormData;

package/dist/umd/src/is/is-form-data.js

@@ -0,0 +1,30 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFormData = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    function isFormData(object) {
+        if (object instanceof FormData)
+            return true;
+        return ((0, is_object_1.isObject)(object) &&
+            (0, is_function_1.isFunction)(object.append) &&
+            (0, is_function_1.isFunction)(object.delete) &&
+            (0, is_function_1.isFunction)(object.get) &&
+            (0, is_function_1.isFunction)(object.getAll) &&
+            (0, is_function_1.isFunction)(object.has) &&
+            (0, is_function_1.isFunction)(object.set) &&
+            (0, is_function_1.isFunction)(object.entries) &&
+            (0, is_function_1.isFunction)(object.keys) &&
+            (0, is_function_1.isFunction)(object.values));
+    }
+    exports.isFormData = isFormData;
+});

package/dist/umd/src/is/is-function.d.ts

@@ -0,0 +1 @@
+export declare function isFunction(value: any): boolean;

package/dist/umd/src/is/is-function.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFunction = void 0;
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+    exports.isFunction = isFunction;
+});

package/dist/umd/src/is/is-headers.d.ts

@@ -0,0 +1 @@
+export declare function isHeaders(obj: any): obj is Headers;

package/dist/umd/src/is/is-headers.js

@@ -0,0 +1,33 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isHeaders = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    function isHeaders(obj) {
+        if (obj instanceof Headers)
+            return true;
+        if ((0, is_object_1.isObject)(obj) &&
+            (0, is_function_1.isFunction)(obj.forEach) &&
+            (0, is_function_1.isFunction)(obj.get) &&
+            (0, is_function_1.isFunction)(obj.has) &&
+            (0, is_function_1.isFunction)(obj.set) &&
+            (0, is_function_1.isFunction)(obj.append) &&
+            (0, is_function_1.isFunction)(obj.delete) &&
+            (0, is_function_1.isFunction)(obj.entries) &&
+            (0, is_function_1.isFunction)(obj.keys) &&
+            (0, is_function_1.isFunction)(obj.values)) {
+            return true;
+        }
+        return false;
+    }
+    exports.isHeaders = isHeaders;
+});

package/dist/umd/src/is/is-object.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: any): boolean;

package/dist/umd/src/is/is-object.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isObject = void 0;
+    function isObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    exports.isObject = isObject;
+});

package/dist/umd/src/is/is-string.d.ts

@@ -0,0 +1 @@
+export declare function isString(value: any): boolean;

package/dist/umd/src/is/is-string.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isString = void 0;
+    function isString(value) {
+        return typeof value === 'string';
+    }
+    exports.isString = isString;
+});

package/dist/umd/src/is/is-url-search-params.d.ts

@@ -0,0 +1 @@
+export declare function isUrlSearchParams(obj: any): obj is URLSearchParams;

package/dist/umd/src/is/is-url-search-params.js

@@ -0,0 +1,36 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isUrlSearchParams = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    function isUrlSearchParams(obj) {
+        if (obj instanceof URLSearchParams)
+            return true;
+        if ((0, is_object_1.isObject)(obj) &&
+            (0, is_function_1.isFunction)(obj.append) &&
+            (0, is_function_1.isFunction)(obj.delete) &&
+            (0, is_function_1.isFunction)(obj.entrie) &&
+            (0, is_function_1.isFunction)(obj.forEac) &&
+            (0, is_function_1.isFunction)(obj.get) &&
+            (0, is_function_1.isFunction)(obj.getAll) &&
+            (0, is_function_1.isFunction)(obj.has) &&
+            (0, is_function_1.isFunction)(obj.keys) &&
+            (0, is_function_1.isFunction)(obj.set) &&
+            (0, is_function_1.isFunction)(obj.values) &&
+            (0, is_function_1.isFunction)(obj.sort) &&
+            (0, is_function_1.isFunction)(obj.toStri)) {
+            return true;
+        }
+        return false;
+    }
+    exports.isUrlSearchParams = isUrlSearchParams;
+});

package/dist/umd/src/keq.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="node" />
+import { Core } from './core';
+import { KeqMiddleware } from './types/keq-middleware';
+import { KeqBuildInOptions, KeqOptions, KeqOptionsWithFullResponse, KeqOptionsWithoutFullResponse } from './types/keq-options';
+import { KeqRequestBody } from './types/keq-request-body';
+import { KeqRetryDelay } from './types/keq-retry-delay';
+import { KeqRetryOn } from './types/keq-retry-on';
+import { ShorthandContentType } from './types/shorthand-content-type';
+/**
+ * @description Keq 扩展 API，人性化的常用的API
+ */
+export declare class Keq<T> extends Core<T> {
+    use(...middlewares: KeqMiddleware[]): this;
+    option(key: 'resolveWithFullResponse', value?: true): Core<Response>;
+    option<K extends keyof KeqBuildInOptions>(key: K, value?: KeqBuildInOptions[K]): this;
+    option(key: string, value?: any): this;
+    options(opts: KeqOptionsWithoutFullResponse): this;
+    options(opts: KeqOptionsWithFullResponse): Core<Response>;
+    options(opts: KeqOptions): this;
+    /**
+     * Set request header
+     *
+     * @description 设置请求头
+     */
+    set(headers: Headers): this;
+    set(headers: Record<string, string>): this;
+    set(name: string, value: string): this;
+    /**
+     * Set request query/searchParams
+     */
+    query(key: Record<string, string | number | string[] | number[] | undefined>): this;
+    query(key: string, value: string | number | string[] | number[] | undefined): this;
+    /**
+     * Set request route params
+     */
+    params(key: Record<string, string | number>): this;
+    params(key: string, value: string | number): this;
+    /**
+     * Set request body
+     */
+    body(value: KeqRequestBody): this;
+    /**
+     * Setting the Content-Type
+     */
+    type(contentType: ShorthandContentType | string): this;
+    /**
+     * Http Basic Authentication
+     */
+    auth(username: string, password: string): this;
+    private setTypeIfEmpty;
+    /**
+     * set request body
+     */
+    send(value: FormData | URLSearchParams | object | Array<any> | string): this;
+    field(arg1: string, value: string | string[]): this;
+    field(arg1: Record<string, string>): this;
+    attach(key: string, value: Blob | File | Buffer): this;
+    attach(key: string, value: Blob | File | Buffer, filename: string): this;
+    attach(key: string, value: Blob | File | Buffer): this;
+    /**
+     *
+     * @param retryTimes Max number of retries per call
+     * @param retryDelay Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor)
+     * @param retryCallback Will be called after request failed
+     */
+    retry(retryTimes: number, retryDelay?: KeqRetryDelay, retryOn?: KeqRetryOn): Keq<T>;
+    redirect(mod: RequestRedirect): this;
+    credentials(mod: RequestCredentials): this;
+    mode(mod: RequestMode): this;
+}