mphttpx 1.0.0

package/dist/types/TextDecoderP.d.ts

@@ -0,0 +1,31 @@
+declare const state: unique symbol;
+export declare class TextDecoderP implements TextDecoder {
+    constructor(utfLabel?: string, { fatal, ignoreBOM }?: {
+        fatal?: boolean | undefined;
+        ignoreBOM?: boolean | undefined;
+    });
+    [state]: TextDecoderState;
+    get encoding(): string;
+    get fatal(): boolean;
+    get ignoreBOM(): boolean;
+    decode(buffer?: TAllowSharedBufferSource, { stream }?: {
+        stream?: boolean | undefined;
+    }): string;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class TextDecoderState {
+    fatal: boolean;
+    ignoreBOM: boolean;
+    _bomSeen: boolean;
+    _partial: number[];
+}
+type TAllowSharedBufferSource = NonNullable<Parameters<TextDecoder["decode"]>[0]>;
+declare const TextDecoderE: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};
+export { TextDecoderE as TextDecoder };

package/dist/types/TextEncoderP.d.ts

@@ -0,0 +1,15 @@
+export declare class TextEncoderP implements TextEncoder {
+    get encoding(): string;
+    encode(input?: string): Uint8Array<ArrayBuffer>;
+    encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare const TextEncoderE: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export { TextEncoderE as TextEncoder };

package/dist/types/URLSearchParamsP.d.ts

@@ -0,0 +1,31 @@
+import { state } from "./isPolyfill";
+export declare class URLSearchParamsP implements URLSearchParams {
+    constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
+    [state]: URLSearchParamsState;
+    get size(): number;
+    append(name: string, value: string): void;
+    delete(name: string, value?: string): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string, value?: string): boolean;
+    set(name: string, value: string): void;
+    sort(): void;
+    forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
+    entries(): ArrayIterator<[string, string]>;
+    keys(): ArrayIterator<string>;
+    values(): ArrayIterator<string>;
+    [Symbol.iterator](): ArrayIterator<[string, string]>;
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class URLSearchParamsState {
+    _dict: Record<string, string[]>;
+}
+declare const URLSearchParamsE: {
+    new (init?: string[][] | Record<string, string> | string | URLSearchParams): URLSearchParams;
+    prototype: URLSearchParams;
+};
+export { URLSearchParamsE as URLSearchParams };

package/dist/types/XMLHttpRequestEventTargetP.d.ts

@@ -0,0 +1,47 @@
+import { state } from "./isPolyfill";
+import { EventTargetP } from "./EventTargetP";
+export declare class XMLHttpRequestEventTargetP extends EventTargetP implements XMLHttpRequestEventTarget {
+    constructor();
+    [state]: XMLHttpRequestEventTargetState;
+    get onabort(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onabort(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onerror(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onerror(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onload(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onload(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onloadend(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onloadend(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onloadstart(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onloadstart(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get onprogress(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set onprogress(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    get ontimeout(): ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    set ontimeout(value: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+export declare class XMLHttpRequestEventTargetState {
+    /**
+     * @param _target XMLHttpRequestEventTargetP
+     */
+    constructor(_target: unknown);
+    target: XMLHttpRequest;
+    attach(type: keyof XMLHttpRequestEventTargetEventMap): void;
+    onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onabort: (ev: ProgressEvent) => void;
+    onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onerror: (ev: ProgressEvent) => void;
+    onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onload: (ev: ProgressEvent) => void;
+    onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onloadend: (ev: ProgressEvent) => void;
+    onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onloadstart: (ev: ProgressEvent) => void;
+    onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _onprogress: (ev: ProgressEvent) => void;
+    ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
+    _ontimeout: (ev: ProgressEvent) => void;
+}

package/dist/types/XMLHttpRequestP.d.ts

@@ -0,0 +1,94 @@
+import { XMLHttpRequestEventTargetP } from "./XMLHttpRequestEventTargetP";
+import { XMLHttpRequestUploadP } from "./XMLHttpRequestUploadP";
+import type { IRequestTask, IRequestSuccessCallbackBaseResult, IRequestFailCallbackResult, IAliRequestFailCallbackResult } from "./request";
+declare const state: unique symbol;
+export { state as xhrState };
+export declare class XMLHttpRequestP extends XMLHttpRequestEventTargetP implements XMLHttpRequest {
+    static readonly UNSENT = 0;
+    static readonly OPENED = 1;
+    static readonly HEADERS_RECEIVED = 2;
+    static readonly LOADING = 3;
+    static readonly DONE = 4;
+    constructor();
+    [state]: XMLHttpRequestState;
+    readonly UNSENT = 0;
+    readonly OPENED = 1;
+    readonly HEADERS_RECEIVED = 2;
+    readonly LOADING = 3;
+    readonly DONE = 4;
+    get readyState(): number;
+    get response(): any;
+    get responseText(): string;
+    get responseType(): XMLHttpRequestResponseType;
+    set responseType(value: XMLHttpRequestResponseType);
+    get responseURL(): string;
+    get responseXML(): Document | null;
+    get status(): number;
+    get statusText(): string;
+    get timeout(): number;
+    set timeout(value: number);
+    get upload(): XMLHttpRequestUploadP;
+    get withCredentials(): boolean;
+    set withCredentials(value: boolean);
+    abort(): void;
+    getAllResponseHeaders(): string;
+    getResponseHeader(name: string): string | null;
+    open(...args: [method: string, url: string | URL, async?: boolean, username?: string | null, password?: string | null]): void;
+    overrideMimeType(mime: string): void;
+    send(body?: Document | XMLHttpRequestBodyInit | null): void;
+    setRequestHeader(name: string, value: string): void;
+    get onreadystatechange(): ((this: XMLHttpRequest, ev: Event) => any) | null;
+    set onreadystatechange(value: ((this: XMLHttpRequest, ev: Event) => any) | null);
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+declare class XMLHttpRequestState {
+    constructor(target: XMLHttpRequestP);
+    target: XMLHttpRequestP;
+    readyState: number;
+    response: any;
+    responseType: XMLHttpRequestResponseType;
+    responseURL: string;
+    status: number;
+    statusText: string;
+    timeout: number;
+    upload: XMLHttpRequestUploadP;
+    withCredentials: boolean;
+    _reqCanSend: boolean;
+    _resetPending: boolean;
+    _timeoutId: number;
+    _reqURL: string;
+    _method: string;
+    _reqHeaders: Record<string, string>;
+    _resHeaders: Record<string, string> | null;
+    _resContLen: number;
+    _requestTask: IRequestTask | null;
+    execRequest(body?: Document | XMLHttpRequestBodyInit | null): void;
+    requestSuccess({ statusCode, header, data }: IRequestSuccessCallbackBaseResult): void;
+    requestFail(err: IRequestFailCallbackResult | IAliRequestFailCallbackResult): void;
+    requestComplete(): void;
+    clearRequest(delay?: boolean): void;
+    checkRequestTimeout(): void;
+    resetXHR(): void;
+    resetRequestTimeout(): void;
+    emitProcessEvent(type: string, loaded?: number, total?: number, target?: XMLHttpRequestEventTargetP): void;
+    setReadyStateAndNotify(value: number): void;
+    onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
+    _onreadystatechange: (ev: Event) => void;
+}
+export declare function normalizeMethod(method: string): string;
+export declare function convert(body?: Parameters<XMLHttpRequest["send"]>[0], setContentType?: (str: string) => void, setContentLength?: (num: number) => void): string | ArrayBuffer;
+export declare function convertBack(type: XMLHttpRequestResponseType, data?: IRequestSuccessCallbackBaseResult["data"]): string | object | ArrayBuffer | Blob;
+declare const XMLHttpRequestE: {
+    new (): XMLHttpRequest;
+    prototype: XMLHttpRequest;
+    readonly UNSENT: 0;
+    readonly OPENED: 1;
+    readonly HEADERS_RECEIVED: 2;
+    readonly LOADING: 3;
+    readonly DONE: 4;
+} | typeof XMLHttpRequestP;
+export { XMLHttpRequestE as XMLHttpRequest };

package/dist/types/XMLHttpRequestUploadP.d.ts

@@ -0,0 +1,10 @@
+import { XMLHttpRequestEventTargetP } from "./XMLHttpRequestEventTargetP";
+export declare class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP implements XMLHttpRequestUpload {
+    constructor();
+    toString(): string;
+    get isPolyfill(): {
+        symbol: symbol;
+        hierarchy: string[];
+    };
+}
+export declare function createXMLHttpRequestUploadP(): XMLHttpRequestUploadP;

package/dist/types/fetchP.d.ts

@@ -0,0 +1,3 @@
+export declare function fetchP(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+declare const fetchE: typeof fetch;
+export { fetchE as fetch };

package/dist/types/global.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,18 @@
+export { TextEncoder, TextEncoderP } from "./TextEncoderP";
+export { TextDecoder, TextDecoderP } from "./TextDecoderP";
+export { Event, EventP } from "./EventP";
+export { EventTarget, EventTargetP } from "./EventTargetP";
+export { CustomEvent, CustomEventP } from "./CustomEventP";
+export { ProgressEvent, ProgressEventP } from "./ProgressEventP";
+export { Blob, BlobP } from "./BlobP";
+export { File, FileP } from "./FileP";
+export { FileReader, FileReaderP } from "./FileReaderP";
+export { FormData, FormDataP } from "./FormDataP";
+export { URLSearchParams, URLSearchParamsP } from "./URLSearchParamsP";
+export { AbortSignal, AbortSignalP } from "./AbortSignalP";
+export { AbortController, AbortControllerP } from "./AbortControllerP";
+export { XMLHttpRequest, XMLHttpRequestP } from "./XMLHttpRequestP";
+export { fetch, fetchP } from "./fetchP";
+export { Headers, HeadersP } from "./HeadersP";
+export { Request, RequestP } from "./RequestP";
+export { Response, ResponseP } from "./ResponseP";

package/dist/types/isPolyfill.d.ts

@@ -0,0 +1,9 @@
+export declare const polyfill: unique symbol;
+export declare const state: unique symbol;
+export declare const g: typeof globalThis;
+export declare function isObjectType<T>(name: string, value: unknown): value is T;
+export declare function isPolyfillType<T>(name: string, value: unknown): value is T;
+export declare class MPException extends Error {
+    constructor(message?: string, name?: string);
+}
+export declare function defineStringTag(targetFunc: Function, stringTag: string): void;

package/dist/types/platform.d.ts

@@ -0,0 +1,4 @@
+import type { TRequestFunc } from "./request";
+export declare const mp: {
+    request: TRequestFunc;
+} | undefined;

package/dist/types/request.d.ts

@@ -0,0 +1,362 @@
+export declare const request: TRequestFunc;
+/**
+ * 发起 HTTPS 网络请求。
+ */
+export type TRequestFunc = (options: IRequestOptions) => IRequestTask;
+export interface IRequestOptions {
+    /**
+     * 开发者服务器接口地址
+     */
+    url: string;
+    /**
+     * 请求的参数
+     */
+    data?: string | object | ArrayBuffer;
+    /**
+     * 设置请求的 header，header 中不能设置 Referer。content-type 默认为 application/json
+     */
+    header?: object;
+    /**
+     * 超时时间，单位为毫秒。默认值为 60000
+     */
+    timeout?: number;
+    /**
+     * HTTP 请求方法
+     * 默认值：GET
+     */
+    method?: "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT";
+    /**
+     * 返回的数据格式
+     * 合法值：
+     * - json(默认值): 返回的数据为 JSON，返回后会对返回的数据进行一次 JSON.parse
+     * - 其他: 不对返回的内容进行 JSON.parse
+     */
+    dataType?: "json" | "text";
+    /**
+     * 响应的数据类型
+     * 合法值：
+     * - text(默认值): 响应的数据为文本
+     * - arraybuffer: 响应的数据为 ArrayBuffer
+     */
+    responseType?: "text" | "arraybuffer";
+    /**
+     * 使用高性能模式。从基础库 v3.5.0 开始在 Android 端默认开启，其他端暂不生效。该模式下有更优的网络性能表现，更多信息请查看下方说明。
+     * 默认值：true
+     */
+    useHighPerformanceMode?: boolean;
+    /**
+     * 开启 http2
+     * 默认值：false
+     */
+    enableHttp2?: boolean;
+    /**
+     * 是否开启 profile。iOS 和 Android 端默认开启，其他端暂不支持。开启后可在接口回调的 res.profile 中查看性能调试信息。
+     * 默认值：true
+     */
+    enableProfile?: boolean;
+    /**
+     * 是否开启 Quic/h3 协议（iOS 微信目前使用 gQUIC-Q43；Android 微信在 v8.0.54 前使用 gQUIC-Q43，v8.0.54 开始使用 IETF QUIC，即 h3 协议；PC微信使用 IETF QUIC，即 h3 协议）
+     * 默认值：false
+     */
+    enableQuic?: boolean;
+    /**
+     * 开启 Http 缓存
+     * 默认值：false
+     */
+    enableCache?: boolean;
+    /**
+     * 是否开启 HttpDNS 服务。如开启，需要同时填入 httpDNSServiceId 。
+     * 默认值：false
+     */
+    enableHttpDNS?: boolean;
+    /**
+     * HttpDNS 服务商 Id。
+     */
+    httpDNSServiceId?: string;
+    /**
+     * HttpDNS 超时时间。HttpDNS解析时间超过该值时不再走HttpDNS，本次请求将回退到localDNS。默认为 60000 毫秒。
+     * 默认值：60000
+     */
+    httpDNSTimeout?: number;
+    /**
+     * 开启 transfer-encoding chunked。
+     * 默认值：false
+     */
+    enableChunked?: boolean;
+    /**
+     * 强制使用蜂窝网络发送请求
+     * 默认值：false
+     */
+    forceCellularNetwork?: boolean;
+    /**
+     * 重定向拦截策略。（目前安卓、iOS、开发者工具已支持，PC端将在后续支持）
+     * 合法值：
+     * - follow(默认值): 不拦截重定向，即客户端自动处理重定向
+     * - manual: 拦截重定向。开启后，当 http 状态码为 3xx 时客户端不再自动重定向，而是触发 onHeadersReceived 回调，并结束本次 request 请求。可通过 onHeadersReceived 回调中的 header.Location 获取重定向的 url
+     */
+    redirect?: "follow" | "manual";
+    /**
+     * 接口调用成功的回调函数
+     */
+    success?: (res: IRequestSuccessCallbackResult) => void;
+    /**
+     * 接口调用失败的回调函数
+     */
+    fail?: (err: IRequestFailCallbackResult) => void;
+    /**
+     * 接口调用结束的回调函数（调用成功、失败都会执行）
+     */
+    complete?: Function;
+}
+export interface IGeneralCallbackResult {
+    /**
+     * 网络请求过程中的一些异常信息，例如httpdns超时等
+     */
+    exception: {
+        /**
+         * 本次请求底层重试次数
+         */
+        retryCount: number;
+        /**
+         * 本次请求底层失败信息，所有失败信息均符合Errno错误码
+         */
+        reasons: Array<{
+            /**
+             * 错误原因
+             */
+            errMsg: string;
+            /**
+             * 错误码
+             */
+            errno: number;
+        }>;
+    };
+    /**
+     * 最终请求是否使用了HttpDNS解析的IP。仅当enableHttpDNS传true时返回此字段。如果开启enableHttpDNS但最终请求未使用HttpDNS解析的IP，可在exception查看原因。
+     */
+    useHttpDNS: boolean;
+}
+export interface IRequestSuccessCallbackBaseResult {
+    /**
+     * 开发者服务器返回的数据
+     */
+    data: string | object | ArrayBuffer;
+    /**
+     * 开发者服务器返回的 HTTP 状态码
+     */
+    statusCode: number;
+    /**
+     * 开发者服务器返回的 HTTP Response Header
+     */
+    header: object;
+}
+export interface IRequestSuccessCallbackResult extends IGeneralCallbackResult, IRequestSuccessCallbackBaseResult {
+    /**
+     * 开发者服务器返回的 cookies，格式为字符串数组
+     */
+    cookies: string[];
+    /**
+     * 网络请求过程中一些调试信息。目前仅 iOS 和 Android 端支持，其他端暂不支持。
+     */
+    profile: {
+        /**
+         * 调用接口的时间。
+         */
+        invokeStart: number;
+        /**
+         * httpDNS 开始查询的时间。仅当开启 httpDNS 功能时返回该字段。目前仅wx.request接口支持
+         */
+        httpDNSDomainLookUpStart: number;
+        /**
+         * httpDNS 完成查询的时间。仅当开启 httpDNS 功能时返回该字段。目前仅wx.request接口支持
+         */
+        httpDNSDomainLookUpEnd: number;
+        /**
+         * 开始排队的时间。达到并行上限时才需要排队。
+         */
+        queueStart: number;
+        /**
+         * 结束排队的时间。达到并行上限时才需要排队。如果未发生排队，则该字段和 queueStart 字段值相同
+         */
+        queueEnd: number;
+        /**
+         * 第一个 HTTP 重定向发生时的时间。有跳转且是同域名内的重定向才算，否则值为 0
+         */
+        redirectStart: number;
+        /**
+         * 最后一个 HTTP 重定向完成时的时间。有跳转且是同域名内部的重定向才算，否则值为 0
+         */
+        redirectEnd: number;
+        /**
+         * 组件准备好使用 HTTP 请求抓取资源的时间，这发生在检查本地缓存之前
+         */
+        fetchStart: number;
+        /**
+         * Local DNS 域名查询开始的时间，如果使用了本地缓存（即无 DNS 查询）或持久连接，则与 fetchStart 值相等
+         */
+        domainLookUpStart: number;
+        /**
+         * Local DNS 域名查询完成的时间，如果使用了本地缓存（即无 DNS 查询）或持久连接，则与 fetchStart 值相等
+         */
+        domainLookUpEnd: number;
+        /**
+         * HTTP（TCP） 开始建立连接的时间，如果是持久连接，则与 fetchStart 值相等。注意如果在传输层发生了错误且重新建立连接，则这里显示的是新建立的连接开始的时间
+         */
+        connectStart: number;
+        /**
+         * HTTP（TCP） 完成建立连接的时间（完成握手），如果是持久连接，则与 fetchStart 值相等。注意如果在传输层发生了错误且重新建立连接，则这里显示的是新建立的连接完成的时间。注意这里握手结束，包括安全连接建立完成、SOCKS 授权通过
+         */
+        connectEnd: number;
+        /**
+         * SSL建立连接的时间,如果不是安全连接,则值为 0
+         */
+        SSLconnectionStart: number;
+        /**
+         * SSL建立完成的时间,如果不是安全连接,则值为 0
+         */
+        SSLconnectionEnd: number;
+        /**
+         * HTTP请求读取真实文档开始的时间（完成建立连接），包括从本地读取缓存。连接错误重连时，这里显示的也是新建立连接的时间
+         */
+        requestStart: number;
+        /**
+         * HTTP请求读取真实文档结束的时间
+         */
+        requestEnd: number;
+        /**
+         * HTTP 开始接收响应的时间（获取到第一个字节），包括从本地读取缓存
+         */
+        responseStart: number;
+        /**
+         * HTTP 响应全部接收完成的时间（获取到最后一个字节），包括从本地读取缓存
+         */
+        responseEnd: number;
+        /**
+         * 当次请求连接过程中实时 rtt
+         */
+        rtt: number;
+        /**
+         * 评估的网络状态 unknown, offline, slow 2g, 2g, 3g, 4g, last/0, 1, 2, 3, 4, 5, 6
+         */
+        estimate_nettype: number;
+        /**
+         * 协议层根据多个请求评估当前网络的 rtt（仅供参考）
+         */
+        httpRttEstimate: number;
+        /**
+         * 传输层根据多个请求评估的当前网络的 rtt（仅供参考）
+         */
+        transportRttEstimate: number;
+        /**
+         * 评估当前网络下载的kbps
+         */
+        downstreamThroughputKbpsEstimate: number;
+        /**
+         * 当前网络的实际下载kbps
+         */
+        throughputKbps: number;
+        /**
+         * 当前请求的IP
+         */
+        peerIP: string;
+        /**
+         * 当前请求的端口
+         */
+        port: number;
+        /**
+         * 是否复用连接
+         */
+        socketReused: boolean;
+        /**
+         * 发送的字节数
+         */
+        sendBytesCount: number;
+        /**
+         * 收到字节数
+         */
+        receivedBytedCount: number;
+        /**
+         * 使用协议类型，有效值：http1.1, h2, quic, unknown
+         */
+        protocol: string;
+        /**
+         * 是否走到了高性能模式。基础库 v3.3.4 起支持。
+         */
+        usingHighPerformanceMode: boolean;
+    };
+}
+export interface IRequestFailCallbackResult extends IGeneralCallbackResult {
+    /**
+     * 错误信息
+     */
+    errMsg: string;
+    /**
+     * errno 错误码
+     */
+    errno: number;
+}
+export interface IAliRequestFailCallbackResult {
+    /**
+     * 错误码
+     */
+    error: number;
+    /**
+     * 错误信息
+     */
+    errorMessage: string;
+    /**
+     * 开发者服务器返回的数据，格式取决于请求时的 dataType 参数。
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    data?: string | object | ArrayBuffer;
+    /**
+     * 开发者服务器返回的 HTTP 状态码
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    status?: number;
+    /**
+     * 开发者服务器返回的 HTTP Response Header
+     * 注意：当错误码为 14 或 19 时才会返回此字段
+     */
+    headers?: object;
+}
+export interface IRequestTask {
+    /**
+     * 中断请求任务
+     */
+    abort: () => void;
+    /**
+     * 监听 HTTP Response Header 事件。会比请求完成事件更早
+     */
+    onHeadersReceived: (listener: (res: {
+        /**
+         * 开发者服务器返回的 HTTP Response Header
+         */
+        header: object;
+        /**
+         * 开发者服务器返回的 HTTP 状态码 （目前开发者工具上不会返回 statusCode 字段，可用真机查看该字段，后续将会支持）
+         */
+        statusCode: number;
+        /**
+         * 开发者服务器返回的 cookies，格式为字符串数组
+         */
+        cookies: string[];
+    }) => void) => void;
+    /**
+     * 移除 HTTP Response Header 事件的监听函数
+     */
+    offHeadersReceived: (listener: Function) => void;
+    /**
+     * 监听 Transfer-Encoding Chunk Received 事件。当接收到新的chunk时触发。
+     */
+    onChunkReceived: (listener: (res: {
+        /**
+         * 返回的chunk buffer
+         */
+        data: ArrayBuffer;
+    }) => void) => void;
+    /**
+     * 移除 Transfer-Encoding Chunk Received 事件的监听函数
+     */
+    offChunkReceived: (listener: Function) => void;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "mphttpx",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rollup --config",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Xingzeng",
+  "license": "MIT",
+  "description": "",
+  "keywords": [
+    "mini-program",
+    "polyfill"
+  ],
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "rollup": "^4.53.1",
+    "rollup-plugin-dts": "^6.3.0",
+    "tslib": "^2.8.1"
+  }
+}