@lark-apaas/client-toolkit 1.0.21 → 1.1.1

package/lib/components/AppContainer/safety.js

@@ -3,8 +3,14 @@ import { useEffect, useRef, useState } from "react";
 import { Popover, PopoverContent, PopoverTrigger } from "../ui/popover.js";
 import { getCsrfToken } from "../../utils/getCsrfToken.js";
 import { getAppId } from "../../utils/getAppId.js";
+import { useIsMobile } from "../../hooks/index.js";
+import { X } from "lucide-react";
+import { Button } from "../ui/button.js";
 const Component = ()=>{
+    const HasClosedKey = `miaoda-creatByMiaoda-has-closed-${getAppId(window.location.pathname)}`;
+    const [visible, setVisible] = useState(!window.localStorage?.getItem(HasClosedKey));
     const [open, setOpen] = useState(false);
+    const isMobile = useIsMobile();
     const [userinfo, setUserinfo] = useState(null);
     const [isInternetVisible, setIsInternetVisible] = useState(false);
     const timeoutRef = useRef(null);
@@ -19,7 +25,7 @@ const Component = ()=>{
         });
     }, []);
     if ('production' !== process.env.NODE_ENV) return null;
-    if (!userinfo) return null;
+    if (isMobile || !visible || !userinfo) return null;
     return /*#__PURE__*/ jsxs(Popover, {
         open: open,
         onOpenChange: setOpen,
@@ -43,12 +49,27 @@ const Component = ()=>{
                         /*#__PURE__*/ jsx("p", {
                             className: "shrink-0 min-w-[92px]",
                             children: "由妙搭 AI 搭建"
+                        }),
+                        /*#__PURE__*/ jsx(Button, {
+                            size: "icon",
+                            variant: "ghost",
+                            className: "cursor-pointer rounded-full w-4 h-4",
+                            onClick: (e)=>{
+                                e.stopPropagation();
+                                e.preventDefault();
+                                setVisible(false);
+                                window.localStorage?.setItem(HasClosedKey, 'true');
+                            },
+                            children: /*#__PURE__*/ jsx(X, {
+                                size: 10,
+                                className: "text-[#646A73]"
+                            })
                         })
                     ]
                 })
             }),
             /*#__PURE__*/ jsxs(PopoverContent, {
-                className: "w-80 pt-2 bg-white rounded-xl shadow-[0px_10px_36px_10px_rgba(31,35,41,0.04)] shadow-[0px_8px_24px_0px_rgba(31,35,41,0.04)] shadow-[0px_6px_12px_-10px_rgba(31,35,41,0.06)] outline outline-[0.50px] outline-offset-[-0.50px] outline-[#DEE0E3] inline-flex flex-col justify-center items-start overflow-hidden p-0",
+                className: "w-80 border-0 pt-2 bg-white rounded-xl shadow-[0px_10px_36px_10px_rgba(31,35,41,0.04)] shadow-[0px_8px_24px_0px_rgba(31,35,41,0.04)] shadow-[0px_6px_12px_-10px_rgba(31,35,41,0.06)] outline outline-[0.50px] outline-offset-[-0.50px] outline-[#DEE0E3] inline-flex flex-col justify-center items-start overflow-hidden p-0",
                 side: "top",
                 align: "end",
                 sideOffset: 8,

package/lib/components/ui/button.js

@@ -3,15 +3,15 @@ import "react";
 import { Slot } from "@radix-ui/react-slot";
 import { cva } from "class-variance-authority";
 import { clsxWithTw } from "../../utils/utils.js";
-const buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", {
+const buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-normal transition-all disabled:cursor-not-allowed disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/20 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", {
     variants: {
         variant: {
-            default: "bg-primary text-primary-foreground hover:bg-primary/90",
-            destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
-            outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
-            secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
-            ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
-            link: "text-primary underline-offset-4 hover:underline"
+            default: "bg-primary text-primary-foreground not-disabled:hover:bg-primary/90",
+            destructive: "bg-destructive text-white not-disabled:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+            outline: "border bg-background not-disabled:hover:bg-accent not-disabled:hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:not-disabled:hover:bg-input/50",
+            secondary: "bg-secondary text-secondary-foreground not-disabled:hover:bg-secondary/80",
+            ghost: "not-disabled:hover:bg-accent not-disabled:hover:text-accent-foreground dark:not-disabled:hover:bg-accent/50",
+            link: "text-primary underline-offset-4 not-disabled:hover:underline"
         },
         size: {
             default: "h-9 px-4 py-2 has-[>svg]:px-3",

package/lib/logger/index.d.ts

@@ -1,6 +1 @@
-export declare const logger: {
-    debug(message: any, ...args: any[]): void;
-    info(message: any, ...args: any[]): void;
-    warn(message: any, ...args: any[]): void;
-    error(message: any, ...args: any[]): void;
-};
+export { logger } from './logger';

package/lib/logger/index.js

@@ -1,54 +1,2 @@
-const LOG_LEVELS = [
-    'debug',
-    'info',
-    'warn',
-    'error'
-];
-const defaultConfig = {
-    showLevel: false,
-    showTimestamp: false,
-    level: 'info',
-    prefix: ''
-};
-let config = {
-    ...defaultConfig
-};
-function configureLogger(options) {
-    config = {
-        ...defaultConfig,
-        ...options
-    };
-}
-function getLogLevel() {
-    return config.level;
-}
-function shouldLog(level) {
-    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(getLogLevel());
-}
-function getFormattedPrefix(level) {
-    const parts = [];
-    if (config.prefix) parts.push(`[${config.prefix}]`);
-    if (config.showLevel) parts.push(`[${level.toUpperCase()}]`);
-    return parts;
-}
-configureLogger({
-    showLevel: true,
-    showTimestamp: false,
-    level: 'development' === process.env.NODE_ENV ? 'debug' : 'error',
-    prefix: 'MiaoDa'
-});
-const logger = {
-    debug (message, ...args) {
-        if (shouldLog('debug')) console.log(...getFormattedPrefix('debug'), message, ...args);
-    },
-    info (message, ...args) {
-        if (shouldLog('info')) console.log(...getFormattedPrefix('info'), message, ...args);
-    },
-    warn (message, ...args) {
-        if (shouldLog('warn')) console.log(...getFormattedPrefix('warn'), message, ...args);
-    },
-    error (message, ...args) {
-        if (shouldLog('error')) console.error(...getFormattedPrefix('error'), message, ...args);
-    }
-};
+import { logger } from "./logger.js";
 export { logger };

package/lib/logger/intercept-global-error.d.ts

@@ -0,0 +1 @@
+export declare function interceptGlobalError(): void;

package/lib/logger/intercept-global-error.js

@@ -0,0 +1,10 @@
+import { logger } from "./logger.js";
+function interceptGlobalError() {
+    window.addEventListener('error', (event)=>{
+        logger.error('global error', event);
+    });
+    window.addEventListener('unhandledrejection', (event)=>{
+        logger.error('global unhandledrejection', event);
+    });
+}
+export { interceptGlobalError };

package/lib/logger/log-types.d.ts

@@ -0,0 +1,113 @@
+import z from 'zod';
+export declare const networkRequestLogSchema: z.ZodObject<{
+    method: z.ZodString;
+    status: z.ZodInt;
+    statusText: z.ZodString;
+    path: z.ZodString;
+    requestData: z.ZodOptional<z.ZodUnknown>;
+    requestParams: z.ZodOptional<z.ZodUnknown>;
+    responseData: z.ZodOptional<z.ZodUnknown>;
+    traceID: z.ZodString;
+}, z.core.$strip>;
+export declare const genericErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    stack: z.ZodString;
+}, z.core.$strip>;
+export declare const routerErrorSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+export declare const noCategoryLogSchema: z.ZodObject<{
+    message: z.ZodUnknown;
+    args: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const levelSchema: z.ZodEnum<{
+    info: "info";
+    warn: "warn";
+    error: "error";
+    debug: "debug";
+}>;
+export declare const selectedLogSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"networkRequest">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        method: z.ZodString;
+        status: z.ZodInt;
+        statusText: z.ZodString;
+        path: z.ZodString;
+        requestData: z.ZodOptional<z.ZodUnknown>;
+        requestParams: z.ZodOptional<z.ZodUnknown>;
+        responseData: z.ZodOptional<z.ZodUnknown>;
+        traceID: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"routerError">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"renderError">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"globalError">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"unhandledRejectionError">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"noCategory">;
+    level: z.ZodEnum<{
+        info: "info";
+        warn: "warn";
+        error: "error";
+        debug: "debug";
+    }>;
+    id: z.ZodString;
+    data: z.ZodObject<{
+        message: z.ZodUnknown;
+        args: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type SelectedLog = z.infer<typeof selectedLogSchema>;

package/lib/logger/log-types.js

@@ -0,0 +1,67 @@
+import zod from "zod";
+const networkRequestLogSchema = zod.object({
+    method: zod.string(),
+    status: zod.int(),
+    statusText: zod.string(),
+    path: zod.string(),
+    requestData: zod.optional(zod.unknown()),
+    requestParams: zod.optional(zod.unknown()),
+    responseData: zod.optional(zod.unknown()),
+    traceID: zod.string()
+});
+const genericErrorSchema = zod.object({
+    message: zod.string(),
+    stack: zod.string()
+});
+const routerErrorSchema = zod.object({
+    path: zod.string()
+});
+const noCategoryLogSchema = zod.object({
+    message: zod.unknown(),
+    args: zod.array(zod.unknown())
+});
+const levelSchema = zod["enum"]([
+    'info',
+    'warn',
+    'error',
+    'debug'
+]);
+const selectedLogSchema = zod.discriminatedUnion('type', [
+    zod.object({
+        type: zod.literal('networkRequest'),
+        level: levelSchema,
+        id: zod.string(),
+        data: networkRequestLogSchema
+    }),
+    zod.object({
+        type: zod.literal('routerError'),
+        level: levelSchema,
+        id: zod.string(),
+        data: routerErrorSchema
+    }),
+    zod.object({
+        type: zod.literal('renderError'),
+        level: levelSchema,
+        id: zod.string(),
+        data: genericErrorSchema
+    }),
+    zod.object({
+        type: zod.literal('globalError'),
+        level: levelSchema,
+        id: zod.string(),
+        data: genericErrorSchema
+    }),
+    zod.object({
+        type: zod.literal('unhandledRejectionError'),
+        level: levelSchema,
+        id: zod.string(),
+        data: genericErrorSchema
+    }),
+    zod.object({
+        type: zod.literal('noCategory'),
+        level: levelSchema,
+        id: zod.string(),
+        data: noCategoryLogSchema
+    })
+]);
+export { genericErrorSchema, levelSchema, networkRequestLogSchema, noCategoryLogSchema, routerErrorSchema, selectedLogSchema };

package/lib/logger/logger.d.ts

@@ -0,0 +1,7 @@
+export type LogInterceptor = (originLogger: typeof logger) => typeof logger;
+export declare let logger: {
+    debug(message: any, ...args: any[]): void;
+    info(message: any, ...args: any[]): void;
+    warn(message: any, ...args: any[]): void;
+    error(message: any, ...args: any[]): void;
+};

package/lib/logger/logger.js

@@ -0,0 +1,58 @@
+import { interceptors } from "./selected-logs.js";
+import { interceptGlobalError } from "./intercept-global-error.js";
+const LOG_LEVELS = [
+    'debug',
+    'info',
+    'warn',
+    'error'
+];
+const defaultConfig = {
+    showLevel: false,
+    showTimestamp: false,
+    level: 'info',
+    prefix: ''
+};
+let config = {
+    ...defaultConfig
+};
+function configureLogger(options) {
+    config = {
+        ...defaultConfig,
+        ...options
+    };
+}
+function getLogLevel() {
+    return config.level;
+}
+function shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(getLogLevel());
+}
+function getFormattedPrefix(level) {
+    const parts = [];
+    if (config.prefix) parts.push(`[${config.prefix}]`);
+    if (config.showLevel) parts.push(`[${level.toUpperCase()}]`);
+    return parts;
+}
+configureLogger({
+    showLevel: true,
+    showTimestamp: false,
+    level: 'development' === process.env.NODE_ENV ? 'debug' : 'error',
+    prefix: 'MiaoDa'
+});
+let logger = {
+    debug (message, ...args) {
+        if (shouldLog('debug')) console.log(...getFormattedPrefix('debug'), message, ...args);
+    },
+    info (message, ...args) {
+        if (shouldLog('info')) console.log(...getFormattedPrefix('info'), message, ...args);
+    },
+    warn (message, ...args) {
+        if (shouldLog('warn')) console.log(...getFormattedPrefix('warn'), message, ...args);
+    },
+    error (message, ...args) {
+        if (shouldLog('error')) console.error(...getFormattedPrefix('error'), message, ...args);
+    }
+};
+for (const interceptor of interceptors)logger = interceptor(logger);
+interceptGlobalError();
+export { logger };

package/lib/logger/selected-logs.d.ts

@@ -0,0 +1,2 @@
+import { type LogInterceptor } from './logger';
+export declare const interceptors: LogInterceptor[];

package/lib/logger/selected-logs.js

@@ -0,0 +1,260 @@
+import { logger as external_logger_js_logger } from "./logger.js";
+import { SourceMapConsumer } from "source-map";
+import { normalizeBasePath } from "../utils/utils.js";
+import { mappingText } from "./source-map-mappings-wasm.js";
+import { genericErrorSchema, networkRequestLogSchema, noCategoryLogSchema, routerErrorSchema } from "./log-types.js";
+function hexToBuffer(hexString) {
+    const hex = hexString.replace(/\s/g, '').toUpperCase();
+    if (!/^[0-9A-F]+$/.test(hex)) throw new Error('Invalid hex string');
+    if (hex.length % 2 !== 0) throw new Error('Hex string length must be even');
+    const buffer = new ArrayBuffer(hex.length / 2);
+    const uint8Array = new Uint8Array(buffer);
+    for(let i = 0; i < hex.length; i += 2){
+        const byteValue = parseInt(hex.substr(i, 2), 16);
+        uint8Array[i / 2] = byteValue;
+    }
+    return buffer;
+}
+SourceMapConsumer.initialize({
+    'lib/mappings.wasm': hexToBuffer(mappingText)
+});
+async function getSourceMap() {
+    let sourceMapContent = '';
+    try {
+        const basePath = normalizeBasePath(process.env.CLIENT_BASE_PATH);
+        const res = await fetch(`${basePath}/main.js.map`);
+        sourceMapContent = await res.text();
+    } catch (e) {
+        external_logger_js_logger.warn('get main.js.map error', e);
+    }
+    return sourceMapContent;
+}
+async function parseSourceMap(stack) {
+    try {
+        const sourceMapContent = await getSourceMap();
+        if (!sourceMapContent) return stack;
+        const consumer = await new SourceMapConsumer(JSON.parse(sourceMapContent));
+        const lines = stack.split('\n');
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i];
+            const match = line.match(/\((.*main\.js):(\d+):(\d+)\)/);
+            if (match) {
+                const [fullMatch, , lineNum, colNum] = match;
+                const originalPosition = consumer.originalPositionFor({
+                    line: Number(lineNum),
+                    column: Number(colNum)
+                });
+                if (originalPosition.source) {
+                    let originalPositionStr = `(${originalPosition.source}:${originalPosition.line}:${originalPosition.column})`;
+                    originalPositionStr = originalPositionStr.replace('webpack://fullstack-nestjs-template/', '');
+                    lines[i] = line.replace(fullMatch, originalPositionStr);
+                }
+            }
+        }
+        return lines.join('\n');
+    } catch (e) {
+        external_logger_js_logger.warn('recover code position error', e);
+        return stack;
+    }
+}
+function sendSelectedLog(log) {
+    const logWithID = {
+        ...log,
+        id: crypto.randomUUID()
+    };
+    try {
+        const logJSON = JSON.stringify(logWithID);
+        console.log(logJSON);
+        if (window.parent !== window) try {
+            window.parent.postMessage({
+                type: 'SELECTED_LOG',
+                payload: logJSON
+            }, '*');
+        } catch (e) {
+            external_logger_js_logger.warn('post selected log to parent iframe error', e);
+        }
+    } catch (e) {
+        external_logger_js_logger.warn('send selected log error', e);
+    }
+}
+const comprehensiveInterceptor = (logger)=>({
+        info: (message, ...args)=>{
+            try {
+                logger.info(message, ...args);
+            } catch (e) {
+                logger.warn('info log error', e);
+            }
+            if (message && 'object' == typeof message && 'HTTP Request' === message.type) return;
+            if (message && 'object' == typeof message && 'HTTP Response' === message.type) {
+                let requestData = message.data;
+                if ('string' == typeof requestData) try {
+                    requestData = JSON.parse(requestData);
+                } catch (e) {
+                    logger.warn('parse request data error', e);
+                }
+                const info = networkRequestLogSchema.safeParse({
+                    method: message.method || '',
+                    status: message.status || 0,
+                    statusText: message.statusText || '',
+                    path: message.url || '',
+                    requestData,
+                    requestParams: message.params,
+                    responseData: message.responseData,
+                    traceID: message.headers?.['X-Trace-ID'] || ''
+                });
+                if (info.success) sendSelectedLog({
+                    type: 'networkRequest',
+                    level: 'info',
+                    data: info.data
+                });
+                return;
+            }
+            sendSelectedLog({
+                type: 'noCategory',
+                level: 'info',
+                data: {
+                    message,
+                    args
+                }
+            });
+        },
+        error: (message, ...args)=>{
+            try {
+                logger.error(message, ...args);
+            } catch (e) {
+                logger.warn('error log error', e);
+            }
+            if (message && 'object' == typeof message && 'HTTP Request' === message.type) return;
+            if (message && 'object' == typeof message && 'HTTP Response' === message.type) {
+                let requestData = message.data;
+                if ('string' == typeof requestData) try {
+                    requestData = JSON.parse(requestData);
+                } catch (e) {
+                    logger.warn('parse request data error', e);
+                }
+                const info = networkRequestLogSchema.safeParse({
+                    method: message.method || '',
+                    status: message.status || 0,
+                    statusText: message.statusText || '',
+                    path: message.url || '',
+                    requestData,
+                    requestParams: message.params,
+                    responseData: message.responseData,
+                    traceID: message.headers?.['X-Trace-ID'] || ''
+                });
+                if (info.success) sendSelectedLog({
+                    type: 'networkRequest',
+                    level: 'error',
+                    data: info.data
+                });
+                return;
+            }
+            if ('RenderError' === message) return void (async ()=>{
+                const error = args[0];
+                if (error && error instanceof Error) {
+                    const stack = await parseSourceMap(error.stack || '');
+                    sendSelectedLog({
+                        type: 'renderError',
+                        level: 'error',
+                        data: {
+                            message: error.message,
+                            stack
+                        }
+                    });
+                }
+            })();
+            if ('404 Error: User attempted to access non-existent route:' === message) {
+                const path = args[0] || '';
+                const data = routerErrorSchema.safeParse({
+                    path
+                });
+                if (data.success) return void sendSelectedLog({
+                    level: 'error',
+                    type: 'routerError',
+                    data: data.data
+                });
+            }
+            if ('global error' === message) {
+                const error = args[0];
+                if (error && error instanceof ErrorEvent) {
+                    const data = genericErrorSchema.safeParse({
+                        message: error?.error?.message || '',
+                        stack: error?.error?.stack || ''
+                    });
+                    if (data.success) return void (async ()=>{
+                        const stack = await parseSourceMap(data.data.stack || '');
+                        sendSelectedLog({
+                            type: 'globalError',
+                            level: 'error',
+                            data: {
+                                ...data.data,
+                                stack
+                            }
+                        });
+                    })();
+                }
+            }
+            if ('global unhandledrejection' === message) {
+                const error = args[0];
+                if (error && error instanceof PromiseRejectionEvent) {
+                    const data = genericErrorSchema.safeParse({
+                        message: error?.reason?.message || '',
+                        stack: error?.reason?.stack || ''
+                    });
+                    if (data.success) return void (async ()=>{
+                        const stack = await parseSourceMap(data.data.stack || '');
+                        sendSelectedLog({
+                            type: 'unhandledRejectionError',
+                            level: 'error',
+                            data: {
+                                ...data.data,
+                                stack
+                            }
+                        });
+                    })();
+                }
+            }
+            sendSelectedLog({
+                type: 'noCategory',
+                level: 'error',
+                data: noCategoryLogSchema.parse({
+                    message,
+                    args
+                })
+            });
+        },
+        warn: (message, ...args)=>{
+            try {
+                logger.warn(message, ...args);
+            } catch (e) {
+                logger.warn('warn log error', e);
+            }
+            sendSelectedLog({
+                type: 'noCategory',
+                level: 'warn',
+                data: {
+                    message,
+                    args
+                }
+            });
+        },
+        debug: (message, ...args)=>{
+            try {
+                logger.debug(message, ...args);
+            } catch (e) {
+                logger.warn('debug log error', e);
+            }
+            sendSelectedLog({
+                type: 'noCategory',
+                level: 'debug',
+                data: {
+                    message,
+                    args
+                }
+            });
+        }
+    });
+const interceptors = [
+    comprehensiveInterceptor
+];
+export { interceptors };