@teardown/react-native 1.0.12 → 1.1.0-beta-04

package/dist/components/debugger-ui.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent } from 'react';
+export type DebuggerUiPosition = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'center-left' | 'center-right';
+export type DebuggerUiOptions = {
+    enabled?: boolean;
+    position?: DebuggerUiPosition;
+};
+export declare const DebuggerUi: FunctionComponent<DebuggerUiOptions>;

package/dist/components/debugger-ui.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DebuggerUi = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const react_native_safe_area_context_1 = require("react-native-safe-area-context");
+const teardown_logo_1 = require("./teardown-logo");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const react_native_ui_1 = require("@teardown/react-native-ui");
+const teardown_service_1 = require("../services/teardown.service");
+const DebuggerUi = props => {
+    const { enabled = true } = props;
+    return null;
+    if (!__DEV__) {
+        // never render the debugger ui in any mode apart from __DEV__ == true "development"
+        return null;
+    }
+    const isNotEnabled = !enabled;
+    if (isNotEnabled) {
+        return null;
+    }
+    return (0, jsx_runtime_1.jsx)(DebuggerUiEnabled, { ...props });
+};
+exports.DebuggerUi = DebuggerUi;
+const DebuggerUiEnabled = props => {
+    const { position } = props;
+    const safeAreaInsets = (0, react_native_safe_area_context_1.useSafeAreaInsets)();
+    const bottomSheetRef = (0, react_1.useRef)(null);
+    return ((0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: (0, jsx_runtime_1.jsx)(react_native_1.View, { style: styles.container, pointerEvents: 'box-none', children: (0, jsx_runtime_1.jsx)(react_native_gesture_handler_1.GestureHandlerRootView, { children: (0, jsx_runtime_1.jsxs)(react_native_ui_1.BottomSheetModalProvider, { children: [(0, jsx_runtime_1.jsx)(react_native_1.Pressable, { onPress: () => {
+                                // bottomSheetRef.current?.snapToIndex(0);
+                            }, style: [
+                                styles.orb,
+                                getOrbPosition(safeAreaInsets, position ?? 'center-right'),
+                            ], children: (0, jsx_runtime_1.jsx)(teardown_logo_1.TeardownLogo, { height: 20, width: 20 }) }), (0, jsx_runtime_1.jsxs)(react_native_ui_1.BottomSheet, { sheetRef: bottomSheetRef, handleComponent: handleProps => ((0, jsx_runtime_1.jsx)(DebuggerStatusHandleComponent, { ...handleProps })), children: [(0, jsx_runtime_1.jsx)(react_native_ui_1.BottomSheetCloseIcon, {}), (0, jsx_runtime_1.jsxs)(react_native_ui_1.BottomSheetView, { style: {
+                                        paddingBottom: safeAreaInsets.bottom + 16,
+                                    }, children: [(0, jsx_runtime_1.jsx)(react_native_ui_1.BottomSheetHeader, { children: (0, jsx_runtime_1.jsx)(react_native_ui_1.BottomSheetTitle, { children: "Debugger" }) }), (0, jsx_runtime_1.jsx)(react_native_ui_1.BottomSheetContent, { children: (0, jsx_runtime_1.jsx)(react_native_ui_1.Button, { onPress: () => {
+                                                    react_native_1.DevSettings.reload('Teardown reconnect');
+                                                }, children: "Reconnect debugger" }) })] })] })] }) }) }) }));
+};
+const DebuggerStatusHandleComponent = () => {
+    const { client } = teardown_service_1.TeardownService.useState();
+    const [debuggerStatus, setDebuggerStatus] = (0, react_1.useState)(client.debugger?.getStatus() ?? null);
+    (0, react_1.useEffect)(() => {
+        const listener = client.debugger?.emitter.on("CONNECTION_STATUS_CHANGED", (event) => {
+            const { payload } = event;
+            setDebuggerStatus(event.payload.status);
+        });
+        return () => {
+            listener?.remove();
+        };
+    }, [client]);
+    return ((0, jsx_runtime_1.jsx)(react_native_1.View, { style: [
+            {
+                backgroundColor: getColorForDebuggerStatus(debuggerStatus),
+            },
+            styles.debugger_status,
+        ], children: (0, jsx_runtime_1.jsx)(react_native_1.Text, { style: styles.debugger_status_text, children: debuggerStatus }) }));
+};
+const styles = react_native_1.StyleSheet.create({
+    debugger_status: {
+        flex: 1,
+        borderTopLeftRadius: 15,
+        borderTopRightRadius: 15,
+        padding: 4,
+    },
+    debugger_status_text: {
+        color: 'white',
+        fontSize: 12,
+        textAlign: 'center',
+        fontWeight: 'bold',
+    },
+    container: {
+        ...react_native_1.StyleSheet.absoluteFillObject,
+        backgroundColor: 'white',
+    },
+    orb: {
+        height: 40,
+        width: 40,
+        backgroundColor: 'hsl(240 5% 6%)',
+        borderRadius: 40,
+        position: 'absolute',
+        justifyContent: 'center',
+        alignItems: 'center',
+    },
+    half_height: {
+        height: '50%',
+        backgroundColor: '#e1e1e1',
+        position: 'absolute',
+        left: 0,
+        right: 0,
+        bottom: 0,
+    },
+    logo: {
+        height: 20,
+        width: 20,
+    },
+});
+const getColorForDebuggerStatus = (status) => {
+    switch (status) {
+        case 'CONNECTING':
+            return 'yellow';
+        case 'CONNECTED':
+            return 'green';
+        case 'DISCONNECTED':
+            return 'red';
+        case 'FAILED':
+            return 'red';
+        default:
+            return 'gray';
+    }
+};
+const getOrbPosition = (edgeInsets, position) => {
+    const DEFAULT_PADDING = 16;
+    switch (position) {
+        case 'top-left':
+            return {
+                top: DEFAULT_PADDING + edgeInsets.top,
+                left: DEFAULT_PADDING,
+            };
+        case 'top-right':
+            return {
+                top: DEFAULT_PADDING + edgeInsets.top,
+                right: DEFAULT_PADDING,
+            };
+        case 'bottom-left':
+            return {
+                bottom: DEFAULT_PADDING + edgeInsets.bottom,
+                left: DEFAULT_PADDING,
+            };
+        case 'bottom-right':
+            return {
+                bottom: DEFAULT_PADDING + edgeInsets.bottom,
+                right: DEFAULT_PADDING,
+            };
+        case 'center-left':
+            return {
+                top: '50%',
+                left: DEFAULT_PADDING,
+            };
+        case 'center-right':
+            return {
+                top: '50%',
+                right: DEFAULT_PADDING,
+            };
+    }
+};

package/dist/components/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./debugger-ui"), exports);

package/dist/components/teardown-logo.d.ts

@@ -0,0 +1,4 @@
+import type { FunctionComponent } from "react";
+import { type SvgProps } from "react-native-svg";
+export type TeardownLogoProps = SvgProps;
+export declare const TeardownLogo: FunctionComponent<TeardownLogoProps>;

package/dist/components/teardown-logo.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeardownLogo = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_native_svg_1 = __importStar(require("react-native-svg"));
+const TeardownLogo = (props) => {
+    const {} = props;
+    return ((0, jsx_runtime_1.jsx)(react_native_svg_1.default, { width: "350", height: "350", viewBox: "0 0 350 350", fill: "none", ...props, children: (0, jsx_runtime_1.jsx)(react_native_svg_1.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M175.09 345L300 218.574L256.859 174.909L299.821 131.426L174.91 5.00001L50 131.426L93.141 175.091L50.179 218.574L175.09 345ZM114.879 197.093L93.656 218.574L175.09 300.995L256.523 218.574L235.12 196.911L174.91 257.853L114.879 197.093ZM213.382 174.909L174.91 213.848L136.618 175.091L175.09 136.152L213.382 174.909ZM235.12 152.907L175.09 92.147L114.879 153.089L93.477 131.426L174.91 49.005L256.344 131.426L235.12 152.907Z", fill: "white" }) }));
+};
+exports.TeardownLogo = TeardownLogo;

package/dist/containers/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./teardown.container"), exports);

package/dist/containers/teardown.container.d.ts

@@ -0,0 +1,11 @@
+import type { FunctionComponent, PropsWithChildren } from "react";
+import type { PluginTuple, TeardownClient } from "../teardown.client";
+import type { DebuggerUiOptions } from "../components";
+export type TeardownContainerOptions = {
+    debugger: DebuggerUiOptions;
+};
+export type TeardownContainerProps<T extends readonly PluginTuple[]> = PropsWithChildren<{
+    client: TeardownClient<T>;
+    options?: TeardownContainerOptions;
+}>;
+export declare const TeardownContainer: FunctionComponent<TeardownContainerProps<any>>;

package/dist/containers/teardown.container.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeardownContainer = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const services_1 = require("../services");
+const react_native_safe_area_context_1 = require("react-native-safe-area-context");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const TeardownContainer = (props) => {
+    const { children, client, options } = props;
+    const providedState = services_1.TeardownService.useProvidedState(client);
+    return ((0, jsx_runtime_1.jsx)(react_native_safe_area_context_1.SafeAreaProvider, { children: (0, jsx_runtime_1.jsx)(react_native_gesture_handler_1.GestureHandlerRootView, { children: children }) }));
+};
+exports.TeardownContainer = TeardownContainer;

package/dist/debugger.d.ts

@@ -0,0 +1,13 @@
+import { type ClientWebsocketEvents, type ConnectionEstablishedWebsocketEvent, WebsocketClient, type WebsocketClientOptions, type WebsocketConnectionStatus } from "@teardown/websocket";
+export type DebuggerStatus = WebsocketConnectionStatus;
+export type DebuggerOptions = WebsocketClientOptions & {
+    deviceName?: string;
+};
+export declare class Debugger extends WebsocketClient<ClientWebsocketEvents> {
+    private readonly customDeviceName?;
+    constructor(options?: DebuggerOptions);
+    private getDeviceName;
+    onConnectionEstablished(event: ConnectionEstablishedWebsocketEvent): Promise<void>;
+    getHostFromUrl(url: string): string;
+    getHost(): string;
+}

package/dist/debugger.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Debugger = void 0;
+const logger_1 = require("@teardown/logger");
+const websocket_1 = require("@teardown/websocket");
+const react_native_1 = require("react-native");
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+class Debugger extends websocket_1.WebsocketClient {
+    customDeviceName;
+    constructor(options) {
+        super({
+            logger: new logger_1.Logger("Debugger"),
+            ...options,
+        });
+        this.customDeviceName = options?.deviceName;
+    }
+    async getDeviceName() {
+        if (this.customDeviceName) {
+            return this.customDeviceName;
+        }
+        try {
+            return await react_native_device_info_1.default.getDeviceName();
+        }
+        catch (error) {
+            return react_native_1.Platform.select({
+                ios: "iPhone",
+                android: "Android",
+                default: "Unknown Device",
+            });
+        }
+    }
+    async onConnectionEstablished(event) {
+        const [deviceId, deviceName] = await Promise.all([
+            react_native_device_info_1.default.getUniqueId(),
+            this.getDeviceName(),
+        ]);
+        this.send("DEVICE_CONNECTION_ESTABLISHED", {
+            deviceId,
+            deviceName,
+            platform: react_native_1.Platform.OS,
+            platformVersion: react_native_1.Platform.Version,
+            reactNativeVersion: react_native_1.Platform.constants.reactNativeVersion,
+            isDisableAnimations: react_native_1.Platform.constants.isDisableAnimations ?? false,
+            isTesting: react_native_1.Platform.constants.isTesting,
+        });
+    }
+    getHostFromUrl(url) {
+        const host = url.match(/^(?:https?:\/\/)?(\[[^\]]+\]|[^/:\s]+)(?::\d+)?(?:[/?#]|$)/)?.[1];
+        if (typeof host !== "string") {
+            throw new Error("Invalid URL - host not found");
+        }
+        return host;
+    }
+    getHost() {
+        try {
+            // https://github.com/facebook/react-native/blob/2a7f969500cef73b621269299619ee1f0ee9521a/packages/react-native/src/private/specs/modules/NativeSourceCode.js#L16
+            const scriptURL = react_native_1.NativeModules?.SourceCode?.getConstants().scriptURL;
+            if (typeof scriptURL !== "string")
+                throw new Error("Invalid non-string URL");
+            return this.getHostFromUrl(scriptURL);
+        }
+        catch (error) {
+            const superHost = super.getHost();
+            const errorMessage = typeof error === "object" && error !== null && "message" in error
+                ? error.message
+                : String(error);
+            this.logger.warn(`Failed to get host: "${errorMessage}" - Falling back to ${superHost}`);
+            return superHost;
+        }
+    }
+}
+exports.Debugger = Debugger;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./containers";
+export * from "./teardown.client";
+export * from "./plugins";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export * from './components';
+__exportStar(require("./containers"), exports);
+// export * from './services';
+__exportStar(require("./teardown.client"), exports);
+__exportStar(require("./plugins"), exports);

package/dist/metro/index.d.ts

@@ -0,0 +1,2 @@
+import type { MetroConfig } from "metro-config";
+export declare const getConfig: (configPath: string) => Promise<MetroConfig>;

package/dist/metro/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const getConfig = async (configPath) => { };
+exports.getConfig = getConfig;

package/dist/metro-plugin.d.ts

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

package/dist/metro-plugin.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const chokidar_1 = __importDefault(require("chokidar"));
+function getConfig() {
+    const screensDir = node_path_1.default.join(__dirname, "screens");
+    const outputFile = node_path_1.default.join(__dirname, "screens.gen.tsx");
+    return {
+        server: {
+            enhanceMiddleware: (middleware) => {
+                return (req, res, next) => {
+                    console.log("Request URL:", req.url);
+                    // Handle requests as usual
+                    return middleware;
+                };
+            },
+        },
+    };
+}
+// Function to generate the output file
+function generateOutputFile() {
+    // Your code to generate the output file based on the files in the ./screens folder
+    const outputContent = "/* Generated file */";
+    console.log("Generating output file...");
+    // fs.writeFileSync(outputFile, outputContent);
+}
+// Initialize the watcher
+const watcher = chokidar_1.default.watch(screensDir, {
+    ignored: /(^|[\/\\])\../, // Ignore dotfiles
+    persistent: true,
+});
+// Watch for changes in the ./screens folder
+watcher
+    .on("add", generateOutputFile)
+    .on("change", generateOutputFile)
+    .on("unlink", generateOutputFile)
+    .on("ready", generateOutputFile) // Generate the initial output file
+    .on("error", (error) => console.error(`Watcher error: ${error}`));
+console.log(`Watching ${screensDir} for changes...`);
+module.exports = {
+    server: {},
+};

package/dist/plugins/http.plugin.d.ts

@@ -0,0 +1,23 @@
+import type { TeardownClient } from "../teardown.client";
+import { type DefaultPluginOptions, Plugin } from "../teardown.client";
+export type HTTPPluginOptions = DefaultPluginOptions<{
+    ignoreURLs?: RegExp[];
+}>;
+export declare class HTTPPlugin extends Plugin {
+    private client;
+    private requests;
+    private ignoreURLs;
+    constructor(options?: HTTPPluginOptions);
+    install(client: TeardownClient<any>): void;
+    enableXHRInterceptor(): void;
+    disableInterception(): void;
+    private shouldIgnoreURL;
+    private xhrOpenCallback;
+    private xhrRequestHeaderCallback;
+    private xhrSendCallback;
+    private serializeRequestBody;
+    private xhrResponseCallback;
+    private parseResponseHeaders;
+    private parseResponseBody;
+    private sendHTTPEvent;
+}

package/dist/plugins/http.plugin.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPPlugin = void 0;
+const util_1 = require("@teardown/util");
+// @ts-ignore
+const XHRInterceptor_1 = __importDefault(require("react-native/Libraries/Network/XHRInterceptor"));
+const teardown_client_1 = require("../teardown.client");
+class HTTPPlugin extends teardown_client_1.Plugin {
+    client = null;
+    requests = new Map();
+    ignoreURLs;
+    constructor(options = {}) {
+        super({
+            ...options,
+            key: "HTTPPlugin",
+        });
+        this.ignoreURLs = options.ignoreURLs || [];
+    }
+    install(client) {
+        this.client = client;
+        this.enableXHRInterceptor();
+    }
+    enableXHRInterceptor() {
+        // noinspection TypeScriptUnresolvedReference
+        if (XHRInterceptor_1.default.isInterceptorEnabled()) {
+            // this.logger.info(
+            //     'XHRInterceptor is already enabled by another library. Disable it or run this plugin first when your app loads.',
+            // );
+            this.logger.info("XHRInterceptor is already enabled. Teardown overrides the existing interceptor - other plugins may not work as expected.");
+            this.disableInterception();
+        }
+        this.logger.info("Enabling XHRInterceptor");
+        // noinspection TypeScriptUnresolvedReference
+        XHRInterceptor_1.default.setOpenCallback(this.xhrOpenCallback);
+        // noinspection TypeScriptUnresolvedReference
+        XHRInterceptor_1.default.setRequestHeaderCallback(this.xhrRequestHeaderCallback);
+        // noinspection TypeScriptUnresolvedReference
+        XHRInterceptor_1.default.setSendCallback(this.xhrSendCallback);
+        // noinspection TypeScriptUnresolvedReference
+        XHRInterceptor_1.default.setResponseCallback(this.xhrResponseCallback);
+        // noinspection TypeScriptUnresolvedReference
+        XHRInterceptor_1.default.enableInterception();
+        this.logger.info("XHRInterceptor enabled");
+    }
+    disableInterception() {
+        this.logger.info("Disabling XHRInterceptor");
+        XHRInterceptor_1.default.disableInterception();
+        this.requests.clear();
+        this.logger.info("XHRInterceptor disabled");
+    }
+    shouldIgnoreURL(url) {
+        return this.ignoreURLs.some((ignoreRegex) => ignoreRegex.test(url));
+    }
+    xhrOpenCallback = (method, url, xhr) => {
+        if (this.shouldIgnoreURL(url)) {
+            return;
+        }
+        const requestId = util_1.Util.generateUUID();
+        const HTTPRequestInfo = {
+            id: requestId,
+            type: "XMLHttpRequest",
+            url,
+            method: method,
+            requestHeaders: { "TD-Request-ID": requestId },
+            startTime: performance.now(),
+            updatedAt: performance.now(),
+        };
+        this.requests.set(xhr._id, HTTPRequestInfo);
+    };
+    xhrRequestHeaderCallback = (header, value, xhr) => {
+        const request = this.requests.get(xhr._id);
+        if (request) {
+            request.requestHeaders[header] = value;
+            request.updatedAt = performance.now();
+        }
+    };
+    xhrSendCallback = (data, xhr) => {
+        const request = this.requests.get(xhr._id);
+        if (request) {
+            xhr.setRequestHeader("TD-Request-ID", request.id);
+            request.dataSent = this.serializeRequestBody(data);
+            request.updatedAt = performance.now();
+            this.sendHTTPEvent(request);
+        }
+    };
+    serializeRequestBody(data) {
+        if (typeof data === "string") {
+            return data;
+        }
+        try {
+            return JSON.stringify(data);
+        }
+        catch (error) {
+            this.logger.warn("Failed to stringify request body", error);
+            return "[Unable to serialize request body]";
+        }
+    }
+    xhrResponseCallback = (status, timeout, response, responseURL, responseType, xhr) => {
+        const request = this.requests.get(xhr._id);
+        if (request) {
+            request.status = status;
+            request.responseHeaders = this.parseResponseHeaders(xhr.getAllResponseHeaders());
+            request.response = this.parseResponseBody(response, responseType);
+            request.responseURL = responseURL;
+            request.responseType = responseType;
+            request.timeout = timeout;
+            request.endTime = performance.now();
+            request.updatedAt = performance.now();
+            this.sendHTTPEvent(request);
+            this.requests.delete(xhr._id);
+        }
+    };
+    parseResponseHeaders(headersString) {
+        const headersObject = {};
+        if (headersString) {
+            const headerPairs = headersString.trim().split(/[\r\n]+/);
+            headerPairs.forEach((headerPair) => {
+                const [key, value] = headerPair.split(": ");
+                headersObject[key] = value;
+            });
+        }
+        return headersObject;
+    }
+    parseResponseBody(response, responseType) {
+        if (responseType === "json") {
+            try {
+                return JSON.stringify(JSON.parse(response), null, 2);
+            }
+            catch (error) {
+                this.logger.warn("Failed to parse JSON response", error);
+            }
+        }
+        return response;
+    }
+    sendHTTPEvent(httpRequestInfo) {
+        if (this.client?.debugger) {
+            this.client.debugger.send("NETWORK_HTTP_REQUEST", httpRequestInfo);
+        }
+    }
+}
+exports.HTTPPlugin = HTTPPlugin;

package/{src/plugins/index.ts → dist/plugins/index.d.ts}

@@ -1,3 +1,2 @@
 export * from './http.plugin';
-// export * from './websocket.plugin';
 export * from './logging.plugin';

package/dist/plugins/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http.plugin"), exports);
+// export * from './websocket.plugin';
+__exportStar(require("./logging.plugin"), exports);

package/dist/plugins/logging.plugin.d.ts

@@ -0,0 +1,9 @@
+import type { IPlugin, TeardownClient } from "../teardown.client";
+export declare class LoggingPlugin implements IPlugin {
+    private client;
+    private originalConsoleMethods;
+    private createConsoleProxy;
+    constructor();
+    install(client: TeardownClient<any>): void;
+    uninstall(): void;
+}