tarojs-plugin-chucker 1.0.0

package/dist/runtime/interceptor.js

@@ -0,0 +1,491 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initInterceptors = initInterceptors;
+const taro_1 = __importDefault(require("@tarojs/taro"));
+const store_1 = require("./store");
+const completedIds = new Set();
+function markCompleted(id) {
+    if (completedIds.has(id)) {
+        return false;
+    }
+    completedIds.add(id);
+    // Clean up completed IDs list after 30 seconds to prevent leaks
+    setTimeout(() => completedIds.delete(id), 30000);
+    return true;
+}
+/**
+ * Chucker interceptor for Taro.addInterceptor.
+ * Uses the official onion-model chain to intercept Taro.request calls.
+ */
+const chuckerRequestInterceptor = (chain) => {
+    const requestParams = chain.requestParams;
+    const { method = "GET", url, header, data } = requestParams;
+    const id = "req_" + Math.random().toString(36).substring(2, 9);
+    const startTime = Date.now();
+    store_1.chuckerStore.handleRequestStart({
+        id,
+        type: "network",
+        method: method.toUpperCase(),
+        url,
+        requestHeaders: header || {},
+        requestData: data,
+        startTime,
+    });
+    return chain.proceed(requestParams).then((res) => {
+        if (markCompleted(id)) {
+            const duration = Date.now() - startTime;
+            store_1.chuckerStore.handleRequestComplete({
+                id,
+                status: res.statusCode || 200,
+                responseHeaders: res.header || {},
+                responseData: res.data,
+                duration,
+            });
+        }
+        return res;
+    }, (err) => {
+        if (markCompleted(id)) {
+            const duration = Date.now() - startTime;
+            store_1.chuckerStore.handleRequestComplete({
+                id,
+                status: "fail",
+                error: err ? err.errMsg || JSON.stringify(err) : "Request failed",
+                duration,
+            });
+        }
+        throw err;
+    });
+};
+// Helper to proxy custom methods/properties (like abort, progress callbacks)
+// from the original request/upload/download task to the hijacked Promise
+function proxyTask(target, source) {
+    if (!source)
+        return target;
+    const keys = [
+        ...Object.keys(source),
+        ...Object.getOwnPropertyNames(Object.getPrototypeOf(source) || {}),
+    ];
+    keys.forEach((key) => {
+        if (key === "constructor" || key === "then" || key === "catch" || key === "finally")
+            return;
+        try {
+            if (typeof source[key] === "function") {
+                target[key] = source[key].bind(source);
+            }
+            else {
+                Object.defineProperty(target, key, {
+                    get: () => source[key],
+                    set: (val) => {
+                        source[key] = val;
+                    },
+                    configurable: true,
+                });
+            }
+        }
+        catch (e) { }
+    });
+    return target;
+}
+function initInterceptors() {
+    // 1. Intercept Taro.request via Taro.addInterceptor (official API)
+    taro_1.default.addInterceptor(chuckerRequestInterceptor);
+    // 2. Intercept Taro.uploadFile (addInterceptor doesn't cover uploadFile)
+    const originalUploadFile = taro_1.default.uploadFile;
+    if (typeof originalUploadFile === "function") {
+        taro_1.default.uploadFile = function (options) {
+            if (!options)
+                return originalUploadFile.apply(this, arguments);
+            const id = "upl_" + Math.random().toString(36).substring(2, 9);
+            const startTime = Date.now();
+            const { url, filePath, name, header, formData } = options;
+            store_1.chuckerStore.handleRequestStart({
+                id,
+                type: "network",
+                method: "UPLOAD",
+                url,
+                requestHeaders: header || {},
+                requestData: { filePath, name, formData },
+                startTime,
+            });
+            const clonedOptions = { ...options };
+            const originalSuccess = options.success;
+            const originalFail = options.fail;
+            clonedOptions.success = function (res) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    let responseData = res.data;
+                    try {
+                        if (typeof responseData === "string" && responseData.trim().startsWith("{")) {
+                            responseData = JSON.parse(responseData);
+                        }
+                    }
+                    catch (e) { }
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: res.statusCode || 200,
+                        responseHeaders: res.header || res.headers || {},
+                        responseData,
+                        duration,
+                    });
+                }
+                if (originalSuccess)
+                    return originalSuccess.apply(this, arguments);
+            };
+            clonedOptions.fail = function (err) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: "fail",
+                        error: err ? err.errMsg || JSON.stringify(err) : "Upload failed",
+                        duration,
+                    });
+                }
+                if (originalFail)
+                    return originalFail.apply(this, arguments);
+            };
+            try {
+                const args = [clonedOptions, ...Array.prototype.slice.call(arguments, 1)];
+                const promise = originalUploadFile.apply(this, args);
+                if (promise && typeof promise.then === "function") {
+                    const hijackedPromise = promise.then((res) => {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            let responseData = res.data;
+                            try {
+                                if (typeof responseData === "string" && responseData.trim().startsWith("{")) {
+                                    responseData = JSON.parse(responseData);
+                                }
+                            }
+                            catch (e) { }
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: res.statusCode || 200,
+                                responseHeaders: res.header || res.headers || {},
+                                responseData,
+                                duration,
+                            });
+                        }
+                        return res;
+                    }, (err) => {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: "fail",
+                                error: err ? err.errMsg || JSON.stringify(err) : "Upload failed",
+                                duration,
+                            });
+                        }
+                        throw err;
+                    });
+                    return proxyTask(hijackedPromise, promise);
+                }
+                return promise;
+            }
+            catch (e) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: "fail",
+                        error: e ? e.message || String(e) : "Upload error",
+                        duration,
+                    });
+                }
+                throw e;
+            }
+        };
+    }
+    // 3. Intercept Taro.downloadFile (addInterceptor doesn't cover downloadFile)
+    const originalDownloadFile = taro_1.default.downloadFile;
+    if (typeof originalDownloadFile === "function") {
+        taro_1.default.downloadFile = function (options) {
+            if (!options)
+                return originalDownloadFile.apply(this, arguments);
+            const id = "dwl_" + Math.random().toString(36).substring(2, 9);
+            const startTime = Date.now();
+            const { url, header } = options;
+            store_1.chuckerStore.handleRequestStart({
+                id,
+                type: "network",
+                method: "DOWNLOAD",
+                url,
+                requestHeaders: header || {},
+                startTime,
+            });
+            const clonedOptions = { ...options };
+            const originalSuccess = options.success;
+            const originalFail = options.fail;
+            clonedOptions.success = function (res) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: res.statusCode || 200,
+                        responseHeaders: res.header || res.headers || {},
+                        responseData: { tempFilePath: res.tempFilePath, apFilePath: res.apFilePath },
+                        duration,
+                    });
+                }
+                if (originalSuccess)
+                    return originalSuccess.apply(this, arguments);
+            };
+            clonedOptions.fail = function (err) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: "fail",
+                        error: err ? err.errMsg || JSON.stringify(err) : "Download failed",
+                        duration,
+                    });
+                }
+                if (originalFail)
+                    return originalFail.apply(this, arguments);
+            };
+            try {
+                const args = [clonedOptions, ...Array.prototype.slice.call(arguments, 1)];
+                const promise = originalDownloadFile.apply(this, args);
+                if (promise && typeof promise.then === "function") {
+                    const hijackedPromise = promise.then((res) => {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: res.statusCode || 200,
+                                responseHeaders: res.header || res.headers || {},
+                                responseData: { tempFilePath: res.tempFilePath, apFilePath: res.apFilePath },
+                                duration,
+                            });
+                        }
+                        return res;
+                    }, (err) => {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: "fail",
+                                error: err ? err.errMsg || JSON.stringify(err) : "Download failed",
+                                duration,
+                            });
+                        }
+                        throw err;
+                    });
+                    return proxyTask(hijackedPromise, promise);
+                }
+                return promise;
+            }
+            catch (e) {
+                if (markCompleted(id)) {
+                    const duration = Date.now() - startTime;
+                    store_1.chuckerStore.handleRequestComplete({
+                        id,
+                        status: "fail",
+                        error: e ? e.message || String(e) : "Download error",
+                        duration,
+                    });
+                }
+                throw e;
+            }
+        };
+    }
+    // 4. Intercept wx.invokeNativePlugin (not part of Taro's interceptor chain)
+    // @ts-ignore
+    const globalObj = typeof wx !== "undefined" ? wx : typeof my !== "undefined" ? my : null;
+    if (globalObj) {
+        const setupNativeInterceptor = (original) => {
+            if (typeof original !== "function" || original.isChuckerOverridden)
+                return original;
+            const fn = function (name, args, ...rest) {
+                const id = "nat_" + Math.random().toString(36).substring(2, 9);
+                const startTime = Date.now();
+                let actualName = "NATIVE_CALL";
+                let actualArgs = args;
+                let finalArgs = args;
+                if (typeof name === "string") {
+                    actualName = name;
+                    if (args && typeof args === "object") {
+                        finalArgs = { ...args };
+                        const originalSuccess = args.success;
+                        const originalFail = args.fail;
+                        finalArgs.success = function (res) {
+                            if (markCompleted(id)) {
+                                const duration = Date.now() - startTime;
+                                store_1.chuckerStore.handleRequestComplete({
+                                    id,
+                                    status: "success",
+                                    responseData: res,
+                                    duration,
+                                });
+                            }
+                            if (originalSuccess)
+                                return originalSuccess.apply(this, arguments);
+                        };
+                        finalArgs.fail = function (err) {
+                            if (markCompleted(id)) {
+                                const duration = Date.now() - startTime;
+                                store_1.chuckerStore.handleRequestComplete({
+                                    id,
+                                    status: "fail",
+                                    error: err
+                                        ? typeof err === "object"
+                                            ? JSON.stringify(err)
+                                            : String(err)
+                                        : "Native call failed",
+                                    duration,
+                                });
+                            }
+                            if (originalFail)
+                                return originalFail.apply(this, arguments);
+                        };
+                    }
+                }
+                else if (name && typeof name === "object") {
+                    actualName = name.api_name || "NATIVE_CALL";
+                    actualArgs = name.data || name;
+                    const clonedObj = { ...name };
+                    const originalSuccess = name.success;
+                    const originalFail = name.fail;
+                    clonedObj.success = function (res) {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: "success",
+                                responseData: res,
+                                duration,
+                            });
+                        }
+                        if (originalSuccess)
+                            return originalSuccess.apply(this, arguments);
+                    };
+                    clonedObj.fail = function (err) {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: "fail",
+                                error: err
+                                    ? typeof err === "object"
+                                        ? JSON.stringify(err)
+                                        : String(err)
+                                    : "Native call failed",
+                                duration,
+                            });
+                        }
+                        if (originalFail)
+                            return originalFail.apply(this, arguments);
+                    };
+                    name = clonedObj;
+                }
+                store_1.chuckerStore.handleRequestStart({
+                    id,
+                    type: "native",
+                    method: "NATIVE",
+                    url: actualName,
+                    requestData: actualArgs,
+                    startTime,
+                });
+                // Hook callback function if passed directly as argument
+                const lastArg = rest[rest.length - 1];
+                if (typeof lastArg === "function") {
+                    rest[rest.length - 1] = function (res) {
+                        if (markCompleted(id)) {
+                            const duration = Date.now() - startTime;
+                            store_1.chuckerStore.handleRequestComplete({
+                                id,
+                                status: res && (res.errCode === 0 || res.errorCode === 0 || !res.errCode)
+                                    ? "success"
+                                    : "fail",
+                                responseData: res,
+                                duration,
+                            });
+                        }
+                        return lastArg.apply(this, arguments);
+                    };
+                }
+                try {
+                    const result = original.apply(this, [name, finalArgs, ...rest]);
+                    if (result && typeof result.then === "function") {
+                        return result.then((res) => {
+                            if (markCompleted(id)) {
+                                const duration = Date.now() - startTime;
+                                store_1.chuckerStore.handleRequestComplete({
+                                    id,
+                                    status: "success",
+                                    responseData: res,
+                                    duration,
+                                });
+                            }
+                            return res;
+                        }, (err) => {
+                            if (markCompleted(id)) {
+                                const duration = Date.now() - startTime;
+                                store_1.chuckerStore.handleRequestComplete({
+                                    id,
+                                    status: "fail",
+                                    error: err
+                                        ? typeof err === "object"
+                                            ? JSON.stringify(err)
+                                            : String(err)
+                                        : "Native call failed",
+                                    duration,
+                                });
+                            }
+                            throw err;
+                        });
+                    }
+                    return result;
+                }
+                catch (error) {
+                    if (markCompleted(id)) {
+                        const duration = Date.now() - startTime;
+                        store_1.chuckerStore.handleRequestComplete({
+                            id,
+                            status: "fail",
+                            error: error ? error.message || String(error) : "Synchronous native error",
+                            duration,
+                        });
+                    }
+                    throw error;
+                }
+            };
+            fn.isChuckerOverridden = true;
+            return fn;
+        };
+        let currentVal = globalObj.invokeNativePlugin;
+        let interceptedVal = setupNativeInterceptor(currentVal);
+        if (currentVal) {
+            try {
+                Object.defineProperty(globalObj, "invokeNativePlugin", {
+                    value: interceptedVal,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            catch (e) {
+                try {
+                    globalObj.invokeNativePlugin = interceptedVal;
+                }
+                catch (err) { }
+            }
+        }
+        try {
+            Object.defineProperty(globalObj, "invokeNativePlugin", {
+                get() {
+                    return interceptedVal;
+                },
+                set(newVal) {
+                    currentVal = newVal;
+                    interceptedVal = setupNativeInterceptor(newVal);
+                },
+                configurable: true,
+            });
+        }
+        catch (e) { }
+    }
+}

package/dist/runtime/page.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export default function ChuckerPage(): React.JSX.Element;

package/dist/runtime/page.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ChuckerPage;
+const react_1 = __importDefault(require("react"));
+const Chucker_1 = require("./components/Chucker");
+function ChuckerPage() {
+    return react_1.default.createElement(Chucker_1.Chucker, null);
+}

package/dist/runtime/store.d.ts

@@ -0,0 +1,95 @@
+import { ChuckerLog } from "./interceptor";
+export type Listener = (logs: ChuckerLog[]) => void;
+/** Input type for user-created log entries. `id` and `startTime` are auto-generated if omitted. */
+export interface CustomLogInput {
+    /** Custom identifier. Auto-generated if omitted. */
+    id?: string;
+    /** Log category. Use built-in "network"/"native" or any custom string like "websocket", "graphql", etc. */
+    type: ChuckerLog["type"];
+    /** Label for the operation (e.g. "GET", "SUBSCRIBE", "QUERY"). */
+    method: string;
+    /** URL or identifier for the operation. */
+    url: string;
+    requestHeaders?: Record<string, string>;
+    requestData?: any;
+    status?: string | number;
+    responseHeaders?: Record<string, string>;
+    responseData?: any;
+    error?: string;
+    /** Epoch timestamp in ms. Defaults to Date.now(). */
+    startTime?: number;
+    duration?: number;
+}
+/** Payload to finalize a tracked operation started with `startTracking()`. */
+export interface TrackingCompleteInput {
+    status?: string | number;
+    responseHeaders?: Record<string, string>;
+    responseData?: any;
+    error?: string;
+    /** If omitted, duration is calculated from startTime automatically. */
+    duration?: number;
+}
+declare class ChuckerStore {
+    private logs;
+    private listeners;
+    private maxLogs;
+    private isInitialized;
+    private lastNotifyTime;
+    private notifyTimeout;
+    init(maxLogs?: number): void;
+    handleRequestStart(log: ChuckerLog): void;
+    handleRequestComplete(payload: Partial<ChuckerLog> & {
+        id: string;
+    }): void;
+    /**
+     * Add a complete log entry in one call.
+     * Useful for logging one-shot events that don't need async tracking.
+     *
+     * @example
+     * ```ts
+     * chuckerStore.log({
+     *   type: "websocket",
+     *   method: "MESSAGE",
+     *   url: "wss://example.com/ws",
+     *   requestData: { event: "ping" },
+     *   status: "success",
+     *   responseData: { event: "pong" },
+     * });
+     * ```
+     */
+    log(input: CustomLogInput): string;
+    /**
+     * Start tracking an async operation. Returns the generated log `id`.
+     * Call `completeTracking(id, result)` when the operation finishes.
+     *
+     * @example
+     * ```ts
+     * const id = chuckerStore.startTracking({
+     *   type: "graphql",
+     *   method: "QUERY",
+     *   url: "https://api.example.com/graphql",
+     *   requestData: { query: "{ users { id name } }" },
+     * });
+     *
+     * // ... later when response arrives
+     * chuckerStore.completeTracking(id, {
+     *   status: 200,
+     *   responseData: { users: [...] },
+     * });
+     * ```
+     */
+    startTracking(input: CustomLogInput): string;
+    /**
+     * Complete a previously tracked operation.
+     * Duration is calculated automatically if not provided.
+     */
+    completeTracking(id: string, result?: TrackingCompleteInput): void;
+    private trimLogs;
+    getLogs(): ChuckerLog[];
+    clear(): void;
+    subscribe(listener: Listener): () => void;
+    private executeNotify;
+    private notify;
+}
+export declare const chuckerStore: ChuckerStore;
+export {};