@lark-apaas/client-toolkit 1.0.20 → 1.1.0

package/lib/components/PagePlaceholder/index.js

@@ -1,16 +1,14 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import "react";
-const PagePlaceholder = ({ title = '页面待开发', description = '页面暂未开发，请耐心等待...' })=>/*#__PURE__*/ jsxs("center", {
-        className: "pt-10 md:pt-9 bg-background p-6 text-center",
+const PagePlaceholder = ({ title = '页面待开发', description = '页面暂未开发，请耐心等待...' })=>/*#__PURE__*/ jsxs("div", {
+        className: "flex flex-col items-center justify-center px-6 w-full h-[calc(100vh-64px)] text-center",
         children: [
-            /*#__PURE__*/ jsx("center", {
-                children: /*#__PURE__*/ jsx("img", {
-                    className: "rounded-md",
-                    width: "320",
-                    height: "200",
-                    src: "https://lf3-static.bytednsdoc.com/obj/eden-cn/LMfspH/ljhwZthlaukjlkulzlp/miao/welcome.svg",
-                    alt: "Welcome"
-                })
+            /*#__PURE__*/ jsx("img", {
+                className: "rounded-md mb-6",
+                width: "320",
+                height: "200",
+                src: "https://lf3-static.bytednsdoc.com/obj/eden-cn/LMfspH/ljhwZthlaukjlkulzlp/miao/welcome.svg",
+                alt: "Welcome"
             }),
             /*#__PURE__*/ jsx("div", {
                 className: "text-center text-foreground text-base font-medium mb-1 leading-6",

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 };