noibu-react-native 0.2.3 → 0.2.4

package/dist/monitors/requestMonitor.js

@@ -1,386 +0,0 @@
-import { __awaiter } from 'tslib';
-import 'react-native/Libraries/Network/fetch';
-import { saveErrorToPagevisit } from '../pageVisit/pageVisitEventError.js';
-import { isHttpCodeFailure, PageVisitEventHTTP } from '../pageVisit/pageVisitEventHTTP.js';
-import { propWriteableOrMadeWriteable, replace, safeEntries } from '../utils/object.js';
-import { HTTPDataBundler } from './httpDataBundler.js';
-import { SEVERITY, FETCH_EXCEPTION_ERROR_TYPE, PV_SEQ_ATT_NAME, RESPONSE_ERROR_TYPE, GQL_ERROR_TYPE, XML_HTTP_REQUEST_ERROR_TYPE, BODY_USED_ERROR, HTTP_RESP_LENGTH_ATT_NAME, HTTP_METHOD_ATT_NAME, HTTP_RESP_CODE_ATT_NAME, URL_ATT_NAME, HTTP_RESP_TIME_ATT_NAME } from '../constants.js';
-import ClientConfig from '../api/clientConfig.js';
-import GqlErrorValidator from './gqlErrorValidator.js';
-import { noibuLog } from '../utils/log.js';
-import { tryGetStackTrace, safeTrim } from '../utils/function.js';
-import { promiseAll } from '../utils/polyfills.js';
-import { addSafeEventListener } from '../utils/eventlistener.js';
-
-/**
- * Gets a response text Promise out of Response & headers. Returns reason if bundler decides to drop text.
- * Due to async nature of text() and async function sent to Promise.all,
- * our code race competes with client's code consuming the response.
- * So at this point engine somehow gets access to the original ReadableStream and marks it as locked,
- * thus client code may throw an error.
- */
-function consumeResponseAndGetBodyText(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(response instanceof Response)) {
-            return '';
-        }
-        if (response.bodyUsed) {
-            return BODY_USED_ERROR;
-        }
-        return response.text();
-    });
-}
-/**
- * Generates new PVEventHTTP
- */
-function getPvEventHttp(status, responseHeaders, method, url, responseTime) {
-    const httpEvent = {
-        [HTTP_METHOD_ATT_NAME]: method,
-        [HTTP_RESP_CODE_ATT_NAME]: status,
-        [URL_ATT_NAME]: url,
-        [HTTP_RESP_TIME_ATT_NAME]: responseTime,
-    };
-    const bundler = HTTPDataBundler.getInstance();
-    // add response payload length, if any
-    const contentLength = bundler.contentLength(responseHeaders);
-    if (contentLength > 0 && bundler.shouldContinueForURL(url)) {
-        httpEvent[HTTP_RESP_LENGTH_ATT_NAME] = contentLength;
-    }
-    return httpEvent;
-}
-/**
- * Gets headers from request or request options. Handles different scenarios where simple conversion is not possible
- */
-function getRequestHeaders(request, options) {
-    const headers = safeEntries((request === null || request === void 0 ? void 0 : request.headers) || (options === null || options === void 0 ? void 0 : options.headers));
-    return HTTPDataBundler.headersMapFromIterable(headers);
-}
-/**
- * Gets response headers.
- * It is always a Headers object.
- */
-function getResponseHeaders(response) {
-    const headers = safeEntries(response === null || response === void 0 ? void 0 : response.headers);
-    return HTTPDataBundler.headersMapFromIterable(headers);
-}
-/**
- * Gets request body from body strings or Request options
- */
-function getRequestBody(requestText, options) {
-    if (typeof requestText === 'string') {
-        return requestText;
-    }
-    // it's fine if it's falsy or an empty string, we catch that in HTTPDataBundler.getInstance().bundleHTTPData
-    return options === null || options === void 0 ? void 0 : options.body;
-}
-/**
- * Returns the parameters to pass the PageVisitEventHTTP constructor. Specific to the fetch wrapper.
- */
-function getHttpDataFromFetch(request, response, method, url, options, isError, requestText, responseText) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
-            return null;
-        }
-        return HTTPDataBundler.getInstance().bundleHTTPData(url, getRequestHeaders(request, options), getRequestBody(requestText, options), getResponseHeaders(response), responseText, method, isError);
-    });
-}
-/** Clones Response / Request or returns original object if cloning is not possible */
-function cloneResponse(ogResponse) {
-    if (!ogResponse.bodyUsed) {
-        return ogResponse.clone();
-    }
-    return ogResponse; // body consumed already, no http response body for us
-}
-/**
- * Handles fetch failure
- */
-function handleFetchFailure(maybeErr, url) {
-    if (!maybeErr || typeof maybeErr !== 'object') {
-        return;
-    }
-    const err = maybeErr;
-    // we do not need this error if we cannot extract both the message and stack
-    if (!(err === null || err === void 0 ? void 0 : err.message) || !(err === null || err === void 0 ? void 0 : err.stack)) {
-        return;
-    }
-    const errorFromFetch = new Error();
-    errorFromFetch.stack = err.stack;
-    // making sure we have a url
-    const checkedURL = safeTrim(url);
-    const urlMessage = checkedURL ? ` on url ${checkedURL}` : '';
-    errorFromFetch.message = `${err.message}${urlMessage}`;
-    const errorPayload = {
-        error: errorFromFetch,
-    };
-    saveErrorToPagevisit(FETCH_EXCEPTION_ERROR_TYPE, errorPayload);
-}
-/**
- * Handles fetch response safely. Reports PageVisitEventHTTP and errorToPagevisit if needed.
- */
-function safeHandleFetchResponse(startTime, url, method, options, request) {
-    return (ogResponse) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        try {
-            if (!ogResponse) {
-                // no idea how, but this happens sometimes, esp if other libs override fetch
-                // logging to track the issue if it becomes widespread
-                return ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: no response received`, false, SEVERITY.error);
-            }
-            const clonedResponse = cloneResponse(ogResponse); // gotta do it as early as possible
-            const graphqlResponse = cloneResponse(clonedResponse); // and two times more for each consumption
-            const httpEventDataResponse = cloneResponse(clonedResponse);
-            const respTime = Date.now() - startTime;
-            const status = clonedResponse.status;
-            const headers = clonedResponse.headers;
-            const gqlError = yield GqlErrorValidator.fromFetch(url, options, request, graphqlResponse);
-            const isHttpError = isHttpCodeFailure(status);
-            const [maybeRequestText, responseText] = yield promiseAll([
-                Promise.resolve((_a = request === null || request === void 0 ? void 0 : request.text) === null || _a === void 0 ? void 0 : _a.call(request)),
-                consumeResponseAndGetBodyText(httpEventDataResponse),
-            ]);
-            const httpEvent = getPvEventHttp(status, headers, method, url, respTime);
-            const httpData = yield getHttpDataFromFetch(request, httpEventDataResponse, method, url, options, isHttpError || !!gqlError, maybeRequestText, responseText);
-            const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, !!gqlError);
-            pageVisitEventHTTP.saveHTTPEvent();
-            const seq = (_b = pageVisitEventHTTP.httpData) === null || _b === void 0 ? void 0 : _b[PV_SEQ_ATT_NAME];
-            if (isHttpError) {
-                // this does not consume response body so no need to clone it
-                saveErrorToPagevisit(RESPONSE_ERROR_TYPE, clonedResponse, seq);
-            }
-            if (gqlError) {
-                gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
-            }
-        }
-        catch (e) {
-            if ((e === null || e === void 0 ? void 0 : e.name) === 'AbortError') {
-                // skip it, as it's somewhat expected
-                return;
-            }
-            const stack = tryGetStackTrace(e);
-            ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in custom fetch() callback: ${e}${stack}`, false, SEVERITY.error);
-        }
-    });
-}
-/**
- * Safe function to get method and url from fetch args
- */
-function getMethodUrlFromFetchArgs(resource, options) {
-    const defaultResource = { method: 'GET', url: '' };
-    try {
-        // There is no valid reason for fetch() to be called without a resource but we
-        // see it on a bunch of websites. It seems to work the same as empty string
-        if (!resource) {
-            return defaultResource;
-        }
-        if (resource instanceof Request && resource.method) {
-            return { method: resource.method, url: resource.url || '' };
-        }
-        return {
-            method: (options === null || options === void 0 ? void 0 : options.method) || 'GET',
-            url: typeof resource.toString === 'function' ? resource.toString() : '',
-        };
-    }
-    catch (e) {
-        ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in fetch() wrapper: ${e}`, false, SEVERITY.error);
-    }
-    return defaultResource;
-}
-/**
- * Setting up the wrapper around fetch functions to try and
- * catch http errors
- */
-function setupGlobalFetchWrapper(proto) {
-    if (!propWriteableOrMadeWriteable(proto, 'fetch')) {
-        return;
-    }
-    replace(proto, 'fetch', function (originalFunction) {
-        // please don't change the name of this function. we need this stack frame to be nbuWrapper
-        return function nbuWrapper(resource, options) {
-            let request;
-            const { url, method } = getMethodUrlFromFetchArgs(resource, options);
-            if (resource instanceof Request) {
-                /**
-                 * We clone the request object, as its body can only be read once per instance.
-                 * It's important that we do this before the original function is called, as it
-                 * cannot be cloned afterward.
-                 */
-                request = resource.clone();
-            }
-            const startTime = Date.now();
-            const promiseFromOriginalFetch = originalFunction.call(this, resource, options);
-            promiseFromOriginalFetch
-                .then(safeHandleFetchResponse(startTime, url, method, options, request))
-                .catch(err => {
-                handleFetchFailure(err, url);
-            });
-            return promiseFromOriginalFetch;
-        };
-    });
-}
-/**
- * Does a check if data collection is enabled and combines it into HttpDataBundle
- */
-function getHttpDataFromXhr(xhrObj_1, method_1, url_1, isError_1) {
-    return __awaiter(this, arguments, void 0, function* (xhrObj, method, url, isError, requestPayload = null, responseText) {
-        if (!HTTPDataBundler.getInstance().shouldContinueForURL(url)) {
-            return null;
-        }
-        const responseHeaders = HTTPDataBundler.headersMapFromString(xhrObj.getAllResponseHeaders());
-        return HTTPDataBundler.getInstance().bundleHTTPData(url, xhrObj.noibuRequestHeaders, requestPayload, responseHeaders, responseText, method, isError);
-    });
-}
-/**
- * on loadend we catch the event and
- * make sure it was correct
- */
-function loadendHandler(xhr, startTime, url, method, requestPayload) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const respTime = Date.now() - startTime;
-        const gqlError = yield GqlErrorValidator.fromXhr(url, xhr);
-        const httpError = isHttpCodeFailure(xhr.status);
-        const responseText = yield HTTPDataBundler.getResponseStringFromXHR(xhr);
-        const httpEvent = getPvEventHttp(xhr.status, HTTPDataBundler.headersMapFromString(xhr.getAllResponseHeaders()), method, url, respTime);
-        const httpData = yield getHttpDataFromXhr(xhr, method, url, httpError || !!gqlError, requestPayload, responseText);
-        const pageVisitEventHTTP = new PageVisitEventHTTP(httpEvent, httpData, gqlError);
-        // Save HTTP Info
-        pageVisitEventHTTP.saveHTTPEvent();
-        const seq = (_a = pageVisitEventHTTP.httpData) === null || _a === void 0 ? void 0 : _a[PV_SEQ_ATT_NAME];
-        if (httpError) {
-            saveErrorToPagevisit(XML_HTTP_REQUEST_ERROR_TYPE, xhr, seq);
-        }
-        if (gqlError) {
-            gqlError.forEach(error => saveErrorToPagevisit(GQL_ERROR_TYPE, error, seq));
-        }
-    });
-}
-/** gets method from xhr */
-function getMethodFromXHR(xhr, payload) {
-    if (xhr.noibuHttpMethod) {
-        return xhr.noibuHttpMethod;
-    }
-    // This is very hacky, but we do not really have an option as
-    // we do not have access to either the url nor the method when
-    // overriding the send method
-    return payload ? 'POST' : 'GET';
-}
-/**
- * Wraps the send prototype of the xmlhttp object
- * We set nbuWrapper to the handler function so if this returns an error
- * the trace message will start with nbuWrapper which would allow us to
- * detect that this is a wrapped function and not a NoibuJS error
- */
-function wrapXMLHTTPSend(proto) {
-    replace(proto, 'send', function (originalFunction) {
-        return function nbuWrapper(payload) {
-            try {
-                const method = getMethodFromXHR(this, payload);
-                const startTime = Date.now();
-                addSafeEventListener(this, 'loadend', () => loadendHandler(this, startTime, this.noibuHttpUrl || this.responseURL, method, payload));
-            }
-            catch (e) {
-                const stack = tryGetStackTrace(e);
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.send() wrapper: ${e}${stack}`, false, SEVERITY.error);
-            }
-            return originalFunction.call(this, payload);
-        };
-    });
-}
-/**
- * Wraps the open prototype of the xmlhttp object
- * We set nbuWrapper to the handler function so if this returns an error
- * the trace message will start with nbuWrapper which would allow us to
- * detect that this is a wrapped function and not a NoibuJS error
- */
-function wrapXMLHTTPOpen(proto, shouldHandleLoadend) {
-    replace(proto, 'open', function (originalFunction) {
-        return function nbuWrapper(method, url, async = true, user = null, password = null) {
-            try {
-                /**
-                 * We wrap assignment of the .noibu[...] variables in a try/catch, as we're assigning
-                 * properties to a built-in object type, and have no guarantee of success.
-                 */
-                try {
-                    this.noibuHttpMethod = method;
-                    this.noibuHttpUrl = url;
-                }
-                catch (error) {
-                    ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Unable to set custom properties on XHR object: ${error}`, false, SEVERITY.warn);
-                }
-                if (shouldHandleLoadend) {
-                    const startTime = Date.now();
-                    addSafeEventListener(this, 'loadend', () => loadendHandler(this, startTime, url, method, null));
-                }
-            }
-            catch (e) {
-                const stack = tryGetStackTrace(e);
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.open() wrapper: ${e}${stack}`, false, SEVERITY.error);
-            }
-            return originalFunction.call(this, method, url, async, user, password);
-        };
-    });
-}
-/**
- * Replaces the native XMLHTTPRequest.setHeader() function. We use this to build an array of
- * request headers as these are not stored by the XMLHTTPRequest object.
- * @param {object} proto window.XMLHTTPRequest's prototype
- */
-function wrapXMLHTTPSetRequestHeader(proto) {
-    replace(proto, 'setRequestHeader', function (originalFunction) {
-        return function nbuWrapper(header, value) {
-            // We wrap all of our logic in a try block to guarantee that we will complete the original
-            // implementation if we throw an error in our logic.
-            try {
-                if (!(this.noibuRequestHeaders instanceof Map)) {
-                    this.noibuRequestHeaders = new Map();
-                }
-                // Ensure it's a string. This also converts null to "null"
-                const stringValue = typeof value === 'string' ? value : String(value);
-                if (typeof header === 'string') {
-                    this.noibuRequestHeaders.set(header.toLowerCase(), stringValue);
-                }
-            }
-            catch (error) {
-                ClientConfig.getInstance().postNoibuErrorAndOptionallyDisableClient(`Error in XHR.setRequestHeader() wrapper: ${error}`, false, SEVERITY.error);
-            }
-            return originalFunction.call(this, header, value);
-        };
-    });
-}
-/**
- * Setting up the wrapper around send functions to try and
- * catch http errors
- */
-function setupGlobalXMLHttpWrapper() {
-    if (typeof XMLHttpRequest === 'undefined') {
-        return;
-    }
-    const XMLHttp = XMLHttpRequest;
-    // The event target needs to have a prototype and have the open function
-    const proto = XMLHttp && XMLHttp.prototype;
-    const canWriteOpen = propWriteableOrMadeWriteable(proto, 'open');
-    const canWriteSend = propWriteableOrMadeWriteable(proto, 'send');
-    const canWriteSetHeader = propWriteableOrMadeWriteable(proto, 'setRequestHeader');
-    if (canWriteOpen) {
-        // If we can't wrap the XHR.send() function, we need the wrapped .open() function to
-        // set the listener on 'loadend' events.
-        wrapXMLHTTPOpen(proto, !canWriteSend);
-    }
-    if (canWriteSend) {
-        wrapXMLHTTPSend(proto);
-    }
-    if (canWriteSetHeader) {
-        wrapXMLHTTPSetRequestHeader(proto);
-    }
-}
-/**
- * Monitors all requests
- */
-function monitorRequests() {
-    noibuLog('monitorRequests started');
-    setupGlobalFetchWrapper(global);
-    setupGlobalXMLHttpWrapper();
-    noibuLog('monitorRequests ended');
-}
-
-export { handleFetchFailure, monitorRequests };

package/dist/src/monitors/appNavigationMonitor.d.ts

@@ -1,22 +0,0 @@
-/**
- * Attaches corresponding listener to the passed navigation integration
- */
-export declare class AppNavigationMonitor {
-    private static instance;
-    /**
-     * guesses which navigation is used in app, and registers a listener if found
-     */
-    constructor();
-    /**
-     * handler for updating navigation breadcrumbs and notifying metro of location change
-     */
-    onNavigation(breadcrumbs: string[]): void;
-    /**
-     * Gets the singleton instance
-     */
-    static getInstance(): AppNavigationMonitor;
-    /**
-     * Called when the event needs to be emitted
-     */
-    private reportLocationChange;
-}

package/dist/src/monitors/clickMonitor.d.ts

@@ -1,44 +0,0 @@
-/** Monitors the clicks which we capture and later process */
-export class ClickMonitor {
-    /** gets the singleton instance
-     * @returns {ClickMonitor}
-     */
-    static getInstance(): ClickMonitor;
-    /**
-     * Gets selectors to prevent those elements from being recorded
-     */
-    static getBlockedElements(): string[];
-    textCapturedWhiteListRegex: RegExp;
-    htmlIDAllowListRegex: RegExp;
-    /** Starts monitoring clicks on every Press-able component */
-    monitorClicks(): void;
-    /**
-     * Handles a single click event
-     * @param  {{ _targetInst: RNNode }} event
-     */
-    _onClickHandle(event: {
-        _targetInst: RNNode;
-    }): void;
-    /** Gets the textual content from an element, if any
-     * @param  {} element
-     */
-    _getTextualContentFromEl(element: any): string;
-    /** Parse and trim text
-     * @param  {} text
-     */
-    _trimText(text: any): any;
-    /**
-     * Recursively parses element's inner content and masks blocked css classes
-     * @param {NReactNative.Node} element
-     * @param {String} text
-     * @param {Number} textLimit
-     * @param {Object} counter
-     */
-    _parseInnerContent(element: NReactNative.Node, text: string, textLimit: number, counter: any): string;
-    /**
-     * normalize value and append to the resulting text if not empty
-     * @param {String} text
-     * @param {Array.<any>} values
-     */
-    _parseAndAppendText(text: string, values: Array<any>): string;
-}

package/dist/src/monitors/errorMonitor.d.ts

@@ -1,28 +0,0 @@
-type WrappedFunction<T extends Function = Function> = T & Partial<{
-    __noibu__: boolean;
-    __noibu_wrapped__: T;
-}>;
-/**
- * wraps a provided function into a function that try and catches
- * the original function, doing so allows us to catch errors
- * functionToWrap: function to be wrapped
- * @param  {} functionToWrap
- */
-export declare function wrap(functionToWrap: WrappedFunction): Function;
-/** iterates arguments to try to extract errors from them
- * @param  {Array<string | Error>} argsFromErrorLog
- */
-export declare function processErrorLogArguments(argsFromErrorLog: any[]): void;
-/**
- * handler for promise rejection failures
- * @param error
- */
-export declare function onPromiseRejectionHandler(error: {
-    message: string;
-    stack?: string;
-}): void;
-/**
- * Monitors the errors happening on the window
- */
-export declare function monitorErrors(): void;
-export {};

package/dist/src/monitors/gqlErrorValidator.d.ts

@@ -1,82 +0,0 @@
-/**
- * Try detecting GraphQL errors from http response
- */
-export default class GqlErrorValidator {
-    /**
-     * Retrieves GQL error object based on fetch request/response
-     * @param {String} url
-     * @param {{}} [options]
-     * @param {Request} [request]
-     * @param {Response} [response] - cloned() from original response
-     */
-    static fromFetch(url: string, options?: {} | undefined, request?: Request | undefined, response?: Response | undefined): Promise<any>;
-    /**
-     * Retrieves GQL error object based on XHR object
-     * @param {String} url
-     * @param {XMLHttpRequest} xhr
-     */
-    static fromXhr(url: string, xhr: XMLHttpRequest): Promise<any>;
-    /**
-     * Try safely parse a string and return null if fails
-     * @param {String} content
-     */
-    static _parseJsonSafely(content: string): any;
-    /**
-     * Try to get content type for fetch arguments
-     * @param {{}} options
-     * @param {Request} [request]
-     */
-    static _getContentTypeFromFetchArguments(options: {}, request?: Request | undefined): string | null;
-    /**
-     * Checks if request is aborted
-     * If it has been aborder we are not able to consume the response
-     * @param {{}} options
-     * @param {Request} request
-     */
-    static _isRequestAborted(options: {}, request: Request): any;
-    /**
-     * Determines if request should be processed
-     * @param {String|URL} url
-     * @param {String} contentType
-     */
-    static _shouldHandleRequest(url: string | URL, contentType: string): boolean;
-    /**
-     * Sanitizes payload object
-     * @param {any} data
-     * @param {Array<String>} validationIssues
-     */
-    static _validate(data: any, validationIssues: Array<string>): any;
-    /**
-     * Sanitizes message object
-     * @param {any} error
-     */
-    static _validateMessage(error: any): void;
-    /**
-     * Sanitizes extensions object
-     * @param {any} error
-     * @param {Array<String>} validationIssues
-     */
-    static _validateExtensions(error: any): void;
-    /**
-     * Sanitizes locations object
-     * @param {any} error
-     * @param {Array<String>} validationIssues
-     */
-    static _validateLocations(error: any, validationIssues: Array<string>): void;
-    /**
-     * Sanitizes path object
-     * @param {any} error
-     * @param {Array<String>} validationIssues
-     */
-    static _validatePath(error: any, validationIssues: Array<string>): void;
-    /**
-     * Posts error
-     * @param {String} message
-     */
-    static _postError(message: string): void;
-    /**
-     * Posts issue found during object sanitization
-     * @param {Array<String>} validationIssues
-     */
-    static _postValidationIssues(validationIssues: Array<string>): void;
-}

package/dist/src/monitors/inputMonitor.d.ts

@@ -1,34 +0,0 @@
-/**
- * Singleton class to manage the client configuration
- * this class will be responsible for debouncing all events
- * that are registered
- */
-export class InputMonitor {
-    /**
-     * gets the instance of InputMonitor
-     * @returns {InputMonitor}
-     */
-    static getInstance(): InputMonitor;
-    eventsToDebounce: {};
-    /** will debounce all events that are of this type by the debounce period
-     * @param  {} type
-     * @param  {} debouncePeriod
-     * @param  {} eventName=type
-     */
-    registerInputType(type: any, debouncePeriod: any, eventName?: any): void;
-    /**
-     * Creates an event object with the event and the time it was added then pushes
-     * that event object to the queue of events waiting to be debounced.
-     * @param  {} event
-     * @param  {} type
-     */
-    addEvent(event: any, type: any): void;
-    /**
-     * Adds the events from the object to the page visit and sets up a timer
-     * to send the events if no more are received without the timeout
-     * @param  {} type
-     */
-    _debouncePvEvents(type: any): void;
-    /** Sets up the page hide handler to try to push remaining events in the queues */
-    _setupUnloadHandler(): void;
-}

package/dist/src/monitors/requestMonitor.d.ts

@@ -1,10 +0,0 @@
-/** @module RequestMonitor */
-import 'react-native/Libraries/Network/fetch';
-/**
- * Handles fetch failure
- */
-export declare function handleFetchFailure(maybeErr: unknown, url: unknown): void;
-/**
- * Monitors all requests
- */
-export declare function monitorRequests(): void;

package/dist/types/RRWeb.d.ts

@@ -1,48 +0,0 @@
-export declare const enum EventType {
-    DomContentLoaded = 0,
-    Load = 1,
-    FullSnapshot = 2,
-    IncrementalSnapshot = 3,
-    Meta = 4,
-    Custom = 5,
-    Plugin = 6
-}
-export declare const enum NodeType {
-    Document = 0,
-    DocumentType = 1,
-    Element = 2,
-    Text = 3,
-    CDATA = 4,
-    Comment = 5
-}
-export declare const enum IncrementalSource {
-    Mutation = 0,
-    MouseMove = 1,
-    MouseInteraction = 2,
-    Scroll = 3,
-    ViewportResize = 4,
-    Input = 5,
-    TouchMove = 6,
-    MediaInteraction = 7,
-    StyleSheetRule = 8,
-    CanvasMutation = 9,
-    Font = 10,
-    Log = 11,
-    Drag = 12,
-    StyleDeclaration = 13,
-    Selection = 14,
-    AdoptedStyleSheet = 15
-}
-export declare const enum MouseInteractions {
-    MouseUp = 0,
-    MouseDown = 1,
-    Click = 2,
-    ContextMenu = 3,
-    DblClick = 4,
-    Focus = 5,
-    Blur = 6,
-    TouchStart = 7,
-    TouchMove_Departed = 8,
-    TouchEnd = 9,
-    TouchCancel = 10
-}

package/dist/types/ReactNative.d.ts

@@ -1,4 +0,0 @@
-export interface RNNode {
-    memoizedProps: any;
-    elementType: string;
-}