@openreplay/tracker 8.0.0 → 8.0.1-beta14

package/lib/app/index.d.ts

@@ -73,12 +73,13 @@ export default class App {
     private readonly startCallbacks;
     private readonly stopCallbacks;
     private readonly commitCallbacks;
-    private readonly options;
+    readonly options: AppOptions;
     readonly networkOptions?: NetworkOptions;
     private readonly revID;
     private activityState;
     private readonly version;
     private readonly worker?;
+    private featureFlags;
     private compressionThreshold;
     private restartAttempts;
     private readonly bc;
@@ -120,6 +121,8 @@ export default class App {
     resolveResourceURL(resourceURL: string): string;
     isServiceURL(url: string): boolean;
     active(): boolean;
+    isFeatureActive(feature: string): boolean;
+    getFeatureFlags(): string[];
     resetNextPageSession(flag: boolean): void;
     private _start;
     /**

package/lib/app/index.js

@@ -32,7 +32,8 @@ export default class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '8.0.0'; // TODO: version compatability check inside each plugin.
+        this.version = '8.0.1-beta14'; // TODO: version compatability check inside each plugin.
+        this.featureFlags = [];
         this.compressionThreshold = 24 * 1000;
         this.restartAttempts = 0;
         this.bc = new BroadcastChannel('rick');
@@ -332,6 +333,12 @@ export default class App {
     active() {
         return this.activityState === ActivityState.Active;
     }
+    isFeatureActive(feature) {
+        return this.featureFlags.includes(feature);
+    }
+    getFeatureFlags() {
+        return this.featureFlags;
+    }
     resetNextPageSession(flag) {
         if (flag) {
             this.sessionStorage.setItem(this.options.session_reset_key, 't');
@@ -410,7 +417,8 @@ export default class App {
             delay, //  derived from token
             sessionID, //  derived from token
             startTimestamp, // real startTS (server time), derived from sessionID
-             } = r;
+            userBrowser, userCity, userCountry, userDevice, userOS, userState, } = r;
+            // TODO: insert feature flags here
             if (typeof token !== 'string' ||
                 typeof userUUID !== 'string' ||
                 (typeof startTimestamp !== 'number' && typeof startTimestamp !== 'undefined') ||
@@ -421,6 +429,14 @@ export default class App {
             }
             this.delay = delay;
             this.session.setSessionToken(token);
+            this.session.setUserInfo({
+                userBrowser,
+                userCity,
+                userCountry,
+                userDevice,
+                userOS,
+                userState,
+            });
             this.session.assign({
                 sessionID,
                 timestamp: startTimestamp || timestamp,

package/lib/app/session.d.ts

@@ -1,4 +1,12 @@
 import type App from './index.js';
+interface UserInfo {
+    userBrowser: string;
+    userCity: string;
+    userCountry: string;
+    userDevice: string;
+    userOS: string;
+    userState: string;
+}
 interface SessionInfo {
     sessionID: string | undefined;
     metadata: Record<string, string>;
@@ -22,12 +30,14 @@ export default class Session {
     private timestamp;
     private projectID;
     private tabId;
+    userInfo: UserInfo;
     constructor(app: App, options: Options);
     attachUpdateCallback(cb: OnUpdateCallback): void;
     private handleUpdate;
     assign(newInfo: Partial<SessionInfo>): void;
     setMetadata(key: string, value: string): void;
     setUserID(userID: string): void;
+    setUserInfo(userInfo: UserInfo): void;
     private getPageNumber;
     incPageNo(): number;
     getSessionToken(): string | undefined;

package/lib/app/session.js

@@ -48,6 +48,9 @@ export default class Session {
         this.userID = userID;
         this.handleUpdate({ userID });
     }
+    setUserInfo(userInfo) {
+        this.userInfo = userInfo;
+    }
     getPageNumber() {
         const pageNoStr = this.app.sessionStorage.getItem(this.options.session_pageno_key);
         if (pageNoStr == null) {

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export { default as App } from './app/index.js';
 import * as _Messages from './app/messages.gen.js';
 export declare const Messages: typeof _Messages;
 export { SanitizeLevel } from './app/sanitizer.js';
+import FeatureFlags, { IFeatureFlag } from './modules/featureFlags.js';
 import type { Options as AppOptions } from './app/index.js';
 import type { Options as ConsoleOptions } from './modules/console.js';
 import type { Options as ExceptionOptions } from './modules/exception.js';
@@ -21,12 +22,22 @@ export type Options = Partial<AppOptions & ConsoleOptions & ExceptionOptions & I
     autoResetOnWindowOpen?: boolean;
     network?: NetworkOptions;
     mouse?: MouseHandlerOptions;
+    flags?: {
+        onFlagsLoad?: (flags: IFeatureFlag[]) => void;
+    };
     __DISABLE_SECURE_MODE?: boolean;
 };
 export default class API {
     private readonly options;
+    featureFlags: FeatureFlags;
     private readonly app;
     constructor(options: Options);
+    isFlagEnabled(flagName: string): boolean;
+    onFlagsLoad(callback: (flags: IFeatureFlag[]) => void): void;
+    clearPersistFlags(): void;
+    reloadFlags(): Promise<void>;
+    getFeatureFlag(flagName: string): IFeatureFlag | undefined;
+    getAllFeatureFlags(): IFeatureFlag[];
     use<T>(fn: (app: App | null, options?: Options) => T): T;
     isActive(): boolean;
     start(startOpts?: Partial<StartOptions>): Promise<StartPromiseReturn>;

package/lib/index.js

@@ -22,6 +22,7 @@ import ConstructedStyleSheets from './modules/constructedStyleSheets.js';
 import Selection from './modules/selection.js';
 import Tabs from './modules/tabs.js';
 import { IN_BROWSER, deprecationWarn, DOCS_HOST } from './utils.js';
+import FeatureFlags from './modules/featureFlags.js';
 const DOCS_SETUP = '/installation/javascript-sdk';
 function processOptions(obj) {
     if (obj == null) {
@@ -115,7 +116,15 @@ export default class API {
             Network(app, options.network);
             Selection(app);
             Tabs(app);
+            this.featureFlags = new FeatureFlags(app);
             window.__OPENREPLAY__ = this;
+            app.attachStartCallback(() => {
+                var _a;
+                if ((_a = options.flags) === null || _a === void 0 ? void 0 : _a.onFlagsLoad) {
+                    this.onFlagsLoad(options.flags.onFlagsLoad);
+                }
+                void this.featureFlags.reloadFlags();
+            });
             if (options.autoResetOnWindowOpen) {
                 const wOpen = window.open;
                 app.attachStartCallback(() => {
@@ -139,13 +148,31 @@ export default class API {
             // no-cors issue only with text/plain or not-set Content-Type
             // req.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
             req.send(JSON.stringify({
-                trackerVersion: '8.0.0',
+                trackerVersion: '8.0.1-beta14',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)
             }));
         }
     }
+    isFlagEnabled(flagName) {
+        return this.featureFlags.isFlagEnabled(flagName);
+    }
+    onFlagsLoad(callback) {
+        this.featureFlags.onFlagsLoad(callback);
+    }
+    clearPersistFlags() {
+        this.featureFlags.clearPersistFlags();
+    }
+    reloadFlags() {
+        return this.featureFlags.reloadFlags();
+    }
+    getFeatureFlag(flagName) {
+        return this.featureFlags.getFeatureFlag(flagName);
+    }
+    getAllFeatureFlags() {
+        return this.featureFlags.flags;
+    }
     use(fn) {
         return fn(this.app, this.options);
     }

package/lib/modules/Network/fetchProxy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * I took inspiration in few stack exchange posts
+ * and Tencent vConsole library (MIT)
+ * by wrapping the XMLHttpRequest object in a Proxy
+ * we can intercept the network requests
+ * in not-so-hacky way
+ * */
+import NetworkMessage from './networkMessage.js';
+import { RequestResponseData } from './types.js';
+import { NetworkRequest } from '../../common/messages.gen.js';
+export declare class ResponseProxyHandler<T extends Response> implements ProxyHandler<T> {
+    resp: Response;
+    item: NetworkMessage;
+    constructor(resp: T, item: NetworkMessage);
+    set(target: T, key: string, value: (args: any[]) => any): boolean;
+    get(target: T, key: string): any;
+    protected mockReader(): void;
+}
+export declare class FetchProxyHandler<T extends typeof fetch> implements ProxyHandler<T> {
+    private readonly ignoredHeaders;
+    private readonly setSessionTokenHeader;
+    private readonly sanitize;
+    private readonly sendMessage;
+    private readonly isServiceUrl;
+    constructor(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (item: NetworkRequest) => void, isServiceUrl: (url: string) => boolean);
+    apply(target: T, thisArg: typeof window, argsList: [RequestInfo | URL, RequestInit]): any;
+    protected beforeFetch(item: NetworkMessage, input: RequestInfo, init?: RequestInit): void;
+    protected afterFetch(item: NetworkMessage): (resp: Response) => Response;
+    protected handleResponseBody(resp: Response, item: NetworkMessage): Promise<string> | Promise<ArrayBuffer>;
+}
+export default class FetchProxy {
+    static origFetch: typeof fetch;
+    static create(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (item: NetworkRequest) => void, isServiceUrl: (url: string) => boolean): typeof fetch;
+}

package/lib/modules/Network/fetchProxy.js

@@ -0,0 +1,234 @@
+/**
+ * I took inspiration in few stack exchange posts
+ * and Tencent vConsole library (MIT)
+ * by wrapping the XMLHttpRequest object in a Proxy
+ * we can intercept the network requests
+ * in not-so-hacky way
+ * */
+import NetworkMessage, { RequestState } from './networkMessage.js';
+import { formatByteSize, genStringBody, getStringResponseByType, getURL } from './utils.js';
+export class ResponseProxyHandler {
+    constructor(resp, item) {
+        this.resp = resp;
+        this.item = item;
+        this.mockReader();
+    }
+    set(target, key, value) {
+        return Reflect.set(target, key, value);
+    }
+    get(target, key) {
+        const value = Reflect.get(target, key);
+        switch (key) {
+            case 'arrayBuffer':
+            case 'blob':
+            case 'formData':
+            case 'json':
+            case 'text':
+                return () => {
+                    this.item.responseType = key.toLowerCase();
+                    // @ts-ignore
+                    return value.apply(target).then((resp) => {
+                        this.item.response = getStringResponseByType(this.item.responseType, resp);
+                        return resp;
+                    });
+                };
+        }
+        if (typeof value === 'function') {
+            return value.bind(target);
+        }
+        else {
+            return value;
+        }
+    }
+    mockReader() {
+        let readerReceivedValue;
+        if (!this.resp.body) {
+            // some browsers do not return `body` in some cases, like `OPTIONS` method
+            return;
+        }
+        if (typeof this.resp.body.getReader !== 'function') {
+            return;
+        }
+        const _getReader = this.resp.body.getReader;
+        // @ts-ignore
+        this.resp.body.getReader = () => {
+            const reader = _getReader.apply(this.resp.body);
+            // when readyState is already 4,
+            // it's not a chunked stream, or it had already been read.
+            // so should not update status.
+            if (this.item.readyState === RequestState.DONE) {
+                return reader;
+            }
+            const _read = reader.read;
+            const _cancel = reader.cancel;
+            this.item.responseType = 'arraybuffer';
+            // @ts-ignore
+            reader.read = () => {
+                return _read.apply(reader).then((result) => {
+                    if (!readerReceivedValue) {
+                        // @ts-ignore
+                        readerReceivedValue = new Uint8Array(result.value);
+                    }
+                    else {
+                        const newValue = new Uint8Array(readerReceivedValue.length + result.value.length);
+                        newValue.set(readerReceivedValue);
+                        newValue.set(result.value, readerReceivedValue.length);
+                        readerReceivedValue = newValue;
+                    }
+                    this.item.endTime = performance.now();
+                    this.item.duration = this.item.endTime - (this.item.startTime || this.item.endTime);
+                    this.item.readyState = result.done ? 4 : 3;
+                    this.item.statusText = result.done ? String(this.item.status) : 'Loading';
+                    this.item.responseSize = readerReceivedValue.length;
+                    this.item.responseSizeText = formatByteSize(this.item.responseSize);
+                    if (result.done) {
+                        this.item.response = getStringResponseByType(this.item.responseType, readerReceivedValue);
+                    }
+                    return result;
+                });
+            };
+            reader.cancel = (...args) => {
+                this.item.cancelState = 2;
+                this.item.statusText = 'Cancel';
+                this.item.endTime = performance.now();
+                this.item.duration = this.item.endTime - (this.item.startTime || this.item.endTime);
+                this.item.response = getStringResponseByType(this.item.responseType, readerReceivedValue);
+                return _cancel.apply(reader, args);
+            };
+            return reader;
+        };
+    }
+}
+export class FetchProxyHandler {
+    constructor(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+        this.ignoredHeaders = ignoredHeaders;
+        this.setSessionTokenHeader = setSessionTokenHeader;
+        this.sanitize = sanitize;
+        this.sendMessage = sendMessage;
+        this.isServiceUrl = isServiceUrl;
+    }
+    apply(target, thisArg, argsList) {
+        const input = argsList[0];
+        const init = argsList[1];
+        const isORUrl = input instanceof URL || typeof input === 'string'
+            ? this.isServiceUrl(String(input))
+            : this.isServiceUrl(String(input.url));
+        if (isORUrl) {
+            return target.apply(window, argsList);
+        }
+        const item = new NetworkMessage(this.ignoredHeaders, this.setSessionTokenHeader, this.sanitize);
+        this.beforeFetch(item, input, init);
+        return target.apply(window, argsList)
+            .then(this.afterFetch(item))
+            .catch((e) => {
+            // mock finally
+            item.endTime = performance.now();
+            item.duration = item.endTime - (item.startTime || item.endTime);
+            throw e;
+        });
+    }
+    beforeFetch(item, input, init) {
+        let url, method = 'GET', requestHeader = {};
+        // handle `input` content
+        if (typeof input === 'string') {
+            // when `input` is a string
+            method = (init === null || init === void 0 ? void 0 : init.method) || 'GET';
+            url = getURL(input);
+            requestHeader = (init === null || init === void 0 ? void 0 : init.headers) || {};
+        }
+        else {
+            // when `input` is a `Request` object
+            method = input.method || 'GET';
+            url = getURL(input.url);
+            requestHeader = input.headers;
+        }
+        item.method = method;
+        item.requestType = 'fetch';
+        item.requestHeader = requestHeader;
+        item.url = url.toString();
+        item.name = (url.pathname.split('/').pop() || '') + url.search;
+        item.status = 0;
+        item.statusText = 'Pending';
+        item.readyState = 1;
+        if (!item.startTime) {
+            // UNSENT
+            item.startTime = performance.now();
+        }
+        if (Object.prototype.toString.call(requestHeader) === '[object Headers]') {
+            item.requestHeader = {};
+            for (const [key, value] of requestHeader) {
+                item.requestHeader[key] = value;
+            }
+        }
+        else {
+            item.requestHeader = requestHeader;
+        }
+        // save GET data
+        if (url.search && url.searchParams) {
+            item.getData = {};
+            for (const [key, value] of url.searchParams) {
+                item.getData[key] = value;
+            }
+        }
+        // save POST data
+        if (init === null || init === void 0 ? void 0 : init.body) {
+            item.requestData = genStringBody(init.body);
+        }
+    }
+    afterFetch(item) {
+        return (resp) => {
+            item.endTime = performance.now();
+            item.duration = item.endTime - (item.startTime || item.endTime);
+            item.status = resp.status;
+            item.statusText = String(resp.status);
+            let isChunked = false;
+            item.header = {};
+            for (const [key, value] of resp.headers) {
+                item.header[key] = value;
+                isChunked = value.toLowerCase().indexOf('chunked') > -1 ? true : isChunked;
+            }
+            if (isChunked) {
+                // when `transfer-encoding` is chunked, the response is a stream which is under loading,
+                // so the `readyState` should be 3 (Loading),
+                // and the response should NOT be `clone()` which will affect stream reading.
+                item.readyState = 3;
+            }
+            else {
+                // Otherwise, not chunked, the response is not a stream,
+                // so it's completed and can be cloned for `text()` calling.
+                item.readyState = 4;
+                void this.handleResponseBody(resp.clone(), item).then((responseValue) => {
+                    item.responseSize =
+                        typeof responseValue === 'string' ? responseValue.length : responseValue.byteLength;
+                    item.responseSizeText = formatByteSize(item.responseSize);
+                    item.response = getStringResponseByType(item.responseType, responseValue);
+                    this.sendMessage(item.getMessage());
+                });
+            }
+            return new Proxy(resp, new ResponseProxyHandler(resp, item));
+        };
+    }
+    handleResponseBody(resp, item) {
+        // parse response body by Content-Type
+        const contentType = resp.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            item.responseType = 'json';
+            return resp.text();
+        }
+        else if (contentType &&
+            (contentType.includes('text/html') || contentType.includes('text/plain'))) {
+            item.responseType = 'text';
+            return resp.text();
+        }
+        else {
+            item.responseType = 'arraybuffer';
+            return resp.arrayBuffer();
+        }
+    }
+}
+export default class FetchProxy {
+    static create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+        return new Proxy(fetch, new FetchProxyHandler(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl));
+    }
+}
+FetchProxy.origFetch = fetch;

package/lib/modules/Network/index.d.ts

@@ -0,0 +1,3 @@
+import { RequestResponseData } from './types.js';
+import { NetworkRequest } from '../../common/messages.gen.js';
+export default function setProxy(context: typeof globalThis, ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (message: NetworkRequest) => void, isServiceUrl: (url: string) => boolean): void;

package/lib/modules/Network/index.js

@@ -0,0 +1,6 @@
+import FetchProxy from './fetchProxy.js';
+import XHRProxy from './xhrProxy.js';
+export default function setProxy(context, ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+    context.XMLHttpRequest = XHRProxy.create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl);
+    context.fetch = FetchProxy.create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl);
+}

package/lib/modules/Network/networkMessage.d.ts

@@ -0,0 +1,49 @@
+import { RequestResponseData } from './types.js';
+export type httpMethod = '' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+export declare enum RequestState {
+    UNSENT = 0,
+    OPENED = 1,
+    HEADERS_RECEIVED = 2,
+    LOADING = 3,
+    DONE = 4
+}
+/**
+ * I know we're not using most of the information from this class
+ * but it can be useful in the future if we will decide to display more stuff in our ui
+ * */
+export default class NetworkMessage {
+    private readonly ignoredHeaders;
+    private readonly setSessionTokenHeader;
+    private readonly sanitize;
+    id: string;
+    name?: string;
+    method: httpMethod;
+    url: string;
+    status: number;
+    statusText?: string;
+    cancelState?: 0 | 1 | 2 | 3;
+    readyState?: RequestState;
+    header: {
+        [key: string]: string;
+    };
+    responseType: XMLHttpRequest['responseType'];
+    requestType: 'xhr' | 'fetch' | 'ping' | 'custom';
+    requestHeader: HeadersInit;
+    response: any;
+    responseSize: number;
+    responseSizeText: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    getData: {
+        [key: string]: string;
+    };
+    requestData: string | null;
+    constructor(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData);
+    getMessage(): import("../../common/messages.gen.js").NetworkRequest;
+    writeHeaders(): {
+        reqHs: Record<string, string>;
+        resHs: Record<string, string>;
+    };
+    isHeaderIgnored(key: string): boolean;
+}

package/lib/modules/Network/networkMessage.js

@@ -0,0 +1,78 @@
+import { NetworkRequest } from '../../app/messages.gen.js';
+import { getTimeOrigin } from '../../utils.js';
+export var RequestState;
+(function (RequestState) {
+    RequestState[RequestState["UNSENT"] = 0] = "UNSENT";
+    RequestState[RequestState["OPENED"] = 1] = "OPENED";
+    RequestState[RequestState["HEADERS_RECEIVED"] = 2] = "HEADERS_RECEIVED";
+    RequestState[RequestState["LOADING"] = 3] = "LOADING";
+    RequestState[RequestState["DONE"] = 4] = "DONE";
+})(RequestState || (RequestState = {}));
+/**
+ * I know we're not using most of the information from this class
+ * but it can be useful in the future if we will decide to display more stuff in our ui
+ * */
+export default class NetworkMessage {
+    constructor(ignoredHeaders = [], setSessionTokenHeader, sanitize) {
+        this.ignoredHeaders = ignoredHeaders;
+        this.setSessionTokenHeader = setSessionTokenHeader;
+        this.sanitize = sanitize;
+        this.id = '';
+        this.name = '';
+        this.method = '';
+        this.url = '';
+        this.status = 0;
+        this.statusText = '';
+        this.cancelState = 0;
+        this.readyState = 0;
+        this.header = {};
+        this.responseType = '';
+        this.requestHeader = {};
+        this.responseSize = 0; // bytes
+        this.responseSizeText = '';
+        this.startTime = 0;
+        this.endTime = 0;
+        this.duration = 0;
+        this.getData = {};
+        this.requestData = null;
+    }
+    getMessage() {
+        const { reqHs, resHs } = this.writeHeaders();
+        const request = {
+            headers: reqHs,
+            body: this.method === 'GET' ? JSON.stringify(this.getData) : this.requestData,
+        };
+        const response = { headers: resHs, body: this.response };
+        const messageInfo = this.sanitize({
+            url: this.url,
+            method: this.method,
+            status: this.status,
+            request,
+            response,
+        });
+        return NetworkRequest(this.requestType, messageInfo.method, messageInfo.url, JSON.stringify(messageInfo.request), JSON.stringify(messageInfo.response), messageInfo.status, this.startTime + getTimeOrigin(), this.duration);
+    }
+    writeHeaders() {
+        const reqHs = {};
+        Object.entries(this.requestHeader).forEach(([key, value]) => {
+            if (this.isHeaderIgnored(key))
+                return;
+            reqHs[key] = value;
+        });
+        this.setSessionTokenHeader((name, value) => {
+            reqHs[name] = value;
+        });
+        const resHs = {};
+        Object.entries(this.header).forEach(([key, value]) => {
+            if (this.isHeaderIgnored(key))
+                return;
+            resHs[key] = value;
+        });
+        return { reqHs, resHs };
+    }
+    isHeaderIgnored(key) {
+        if (Array.isArray(this.ignoredHeaders))
+            return this.ignoredHeaders.includes(key);
+        return this.ignoredHeaders;
+    }
+}

package/lib/modules/Network/types.d.ts

@@ -0,0 +1,13 @@
+export interface RequestResponseData {
+    readonly status: number;
+    readonly method: string;
+    url: string;
+    request: {
+        body: string | null;
+        headers: Record<string, string>;
+    };
+    response: {
+        body: string | null;
+        headers: Record<string, string>;
+    };
+}

package/lib/modules/Network/types.js

@@ -0,0 +1,2 @@
+export {};
+// we only support sanitizing for json/string data because how you're gonna sanitize binary data?

package/lib/modules/Network/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const genResponseByType: (responseType: XMLHttpRequest['responseType'], response: any) => string | Record<string, any>;
+export declare const getStringResponseByType: (responseType: XMLHttpRequest['responseType'], response: any) => string;
+export declare const genStringBody: (body?: BodyInit) => string | null;
+export declare const genGetDataByUrl: (url: string, getData?: Record<string, any>) => Record<string, any>;
+export declare const genFormattedBody: (body?: BodyInit) => string | {
+    [key: string]: string;
+} | null;
+export declare function isPureObject(input: any): input is Record<any, any>;
+export declare function isIterable(value: any): boolean;
+export declare function formatByteSize(bytes: number): string;
+export declare const getURL: (urlString: string) => URL;