index.esm.js

/// <reference types="@dcloudio/uni-app-x/types/uni/global" />
function initRuntimeSocket(hosts, port, id) {
    if (hosts == '' || port == '' || id == '')
        return Promise.resolve(null);
    return hosts
        .split(',')
        .reduce((promise, host) => {
        return promise.then((socket) => {
            if (socket != null)
                return Promise.resolve(socket);
            return tryConnectSocket(host, port, id);
        });
    }, Promise.resolve(null));
}
const SOCKET_TIMEOUT = 500;
function tryConnectSocket(host, port, id) {
    return new Promise((resolve, reject) => {
        const socket = uni.connectSocket({
            url: `ws://${host}:${port}/${id}`,
            multiple: true, // 支付宝小程序 是否开启多实例
            fail() {
                resolve(null);
            },
        });
        const timer = setTimeout(() => {
            // @ts-expect-error
            socket.close({
                code: 1006,
                reason: 'connect timeout',
            });
            resolve(null);
        }, SOCKET_TIMEOUT);
        socket.onOpen((e) => {
            clearTimeout(timer);
            resolve(socket);
        });
        socket.onClose((e) => {
            clearTimeout(timer);
            resolve(null);
        });
        socket.onError((e) => {
            clearTimeout(timer);
            resolve(null);
        });
    });
}

const CONSOLE_TYPES = ['log', 'warn', 'error', 'info', 'debug'];
const originalConsole = /*@__PURE__*/ CONSOLE_TYPES.reduce((methods, type) => {
    methods[type] = console[type].bind(console);
    return methods;
}, {});

let sendError = null;
// App.onError会监听到两类错误，一类是小程序自身抛出的，一类是 vue 的 errorHandler 触发的
// uni.onError 和 App.onError 会同时监听到错误(主要是App.onError监听之前的错误)，所以需要用 Set 来去重
// uni.onError 会在 App.onError 上边同时增加监听，因为要监听 vue 的errorHandler
// 目前 vue 的 errorHandler 仅会callHook('onError')，所以需要把uni.onError的也挂在 App.onError 上
const errorQueue = new Set();
const errorExtra = {};
function sendErrorMessages(errors) {
    if (sendError == null) {
        errors.forEach((error) => {
            errorQueue.add(error);
        });
        return;
    }
    const data = errors
        .map((err) => {
        if (typeof err === 'string') {
            return err;
        }
        const isPromiseRejection = err && 'promise' in err && 'reason' in err;
        const prefix = isPromiseRejection ? 'UnhandledPromiseRejection: ' : '';
        if (isPromiseRejection) {
            err = err.reason;
        }
        if (err instanceof Error && err.stack) {
            if (err.message && !err.stack.includes(err.message)) {
                return `${prefix}${err.message}
${err.stack}`;
            }
            return `${prefix}${err.stack}`;
        }
        if (typeof err === 'object' && err !== null) {
            try {
                return prefix + JSON.stringify(err);
            }
            catch (err) {
                return prefix + String(err);
            }
        }
        return prefix + String(err);
    })
        .filter(Boolean);
    if (data.length > 0) {
        sendError(JSON.stringify(Object.assign({
            type: 'error',
            data,
        }, errorExtra)));
    }
}
function setSendError(value, extra = {}) {
    sendError = value;
    Object.assign(errorExtra, extra);
    if (value != null && errorQueue.size > 0) {
        const errors = Array.from(errorQueue);
        errorQueue.clear();
        sendErrorMessages(errors);
    }
}
function initOnError() {
    function onError(error) {
        try {
            // 小红书小程序 socket.send 时，会报错，onError错误信息为：
            // Cannot create property 'errMsg' on string 'taskId'
            // 导致陷入死循环
            if (typeof PromiseRejectionEvent !== 'undefined' &&
                error instanceof PromiseRejectionEvent &&
                error.reason instanceof Error &&
                error.reason.message &&
                error.reason.message.includes(`Cannot create property 'errMsg' on string 'taskId`)) {
                return;
            }
            if (process.env.UNI_CONSOLE_KEEP_ORIGINAL) {
                originalConsole.error(error);
            }
            sendErrorMessages([error]);
        }
        catch (err) {
            originalConsole.error(err);
        }
    }
    if (typeof uni.onError === 'function') {
        uni.onError(onError);
    }
    if (typeof uni.onUnhandledRejection === 'function') {
        uni.onUnhandledRejection(onError);
    }
    return function offError() {
        if (typeof uni.offError === 'function') {
            uni.offError(onError);
        }
        if (typeof uni.offUnhandledRejection === 'function') {
            uni.offUnhandledRejection(onError);
        }
    };
}

function formatMessage(type, args) {
    try {
        return {
            type,
            args: formatArgs(args),
        };
    }
    catch (e) {
        // originalConsole.error(e)
    }
    return {
        type,
        args: [],
    };
}
function formatArgs(args) {
    return args.map((arg) => formatArg(arg));
}
function formatArg(arg, depth = 0) {
    if (depth >= 7) {
        return {
            type: 'object',
            value: '[Maximum depth reached]',
        };
    }
    const type = typeof arg;
    switch (type) {
        case 'string':
            return formatString(arg);
        case 'number':
            return formatNumber(arg);
        case 'boolean':
            return formatBoolean(arg);
        case 'object':
            try {
                // 鸿蒙里边 object 可能包含 nativePtr 指针，该指针 typeof 是 object
                // 但是又不能访问上边的任意属性，否则会报：TypeError: Can not get Prototype on non ECMA Object
                // 所以这里需要捕获异常，防止报错
                return formatObject(arg, depth);
            }
            catch (e) {
                return {
                    type: 'object',
                    value: {
                        properties: [],
                    },
                };
            }
        case 'undefined':
            return formatUndefined();
        case 'function':
            return formatFunction(arg);
        case 'symbol':
            {
                return formatSymbol(arg);
            }
        case 'bigint':
            return formatBigInt(arg);
    }
}
function formatFunction(value) {
    return {
        type: 'function',
        value: `function ${value.name}() {}`,
    };
}
function formatUndefined() {
    return {
        type: 'undefined',
    };
}
function formatBoolean(value) {
    return {
        type: 'boolean',
        value: String(value),
    };
}
function formatNumber(value) {
    return {
        type: 'number',
        value: String(value),
    };
}
function formatBigInt(value) {
    return {
        type: 'bigint',
        value: String(value),
    };
}
function formatString(value) {
    return {
        type: 'string',
        value,
    };
}
function formatSymbol(value) {
    return {
        type: 'symbol',
        value: value.description,
    };
}
function formatObject(value, depth) {
    if (value === null) {
        return {
            type: 'null',
        };
    }
    {
        if (isComponentPublicInstance(value)) {
            return formatComponentPublicInstance(value, depth);
        }
        if (isComponentInternalInstance(value)) {
            return formatComponentInternalInstance(value, depth);
        }
        if (isUniElement(value)) {
            return formatUniElement(value, depth);
        }
        if (isCSSStyleDeclaration(value)) {
            return formatCSSStyleDeclaration(value, depth);
        }
    }
    if (Array.isArray(value)) {
        return {
            type: 'object',
            subType: 'array',
            value: {
                properties: value.map((v, i) => formatArrayElement(v, i, depth + 1)),
            },
        };
    }
    if (value instanceof Set) {
        return {
            type: 'object',
            subType: 'set',
            className: 'Set',
            description: `Set(${value.size})`,
            value: {
                entries: Array.from(value).map((v) => formatSetEntry(v, depth + 1)),
            },
        };
    }
    if (value instanceof Map) {
        return {
            type: 'object',
            subType: 'map',
            className: 'Map',
            description: `Map(${value.size})`,
            value: {
                entries: Array.from(value.entries()).map((v) => formatMapEntry(v, depth + 1)),
            },
        };
    }
    if (value instanceof Promise) {
        return {
            type: 'object',
            subType: 'promise',
            value: {
                properties: [],
            },
        };
    }
    if (value instanceof RegExp) {
        return {
            type: 'object',
            subType: 'regexp',
            value: String(value),
            className: 'Regexp',
        };
    }
    if (value instanceof Date) {
        return {
            type: 'object',
            subType: 'date',
            value: String(value),
            className: 'Date',
        };
    }
    if (value instanceof Error) {
        return {
            type: 'object',
            subType: 'error',
            value: value.message || String(value),
            className: value.name || 'Error',
        };
    }
    let className = undefined;
    {
        const constructor = value.constructor;
        if (constructor) {
            // @ts-expect-error
            if (constructor.get$UTSMetadata$) {
                // @ts-expect-error
                className = constructor.get$UTSMetadata$().name;
            }
        }
    }
    let entries = Object.entries(value);
    if (isHarmonyBuilderParams(value)) {
        entries = entries.filter(([key]) => key !== 'modifier' && key !== 'nodeContent');
    }
    return {
        type: 'object',
        className,
        value: {
            properties: entries.map((entry) => formatObjectProperty(entry[0], entry[1], depth + 1)),
        },
    };
}
function isHarmonyBuilderParams(value) {
    return value.modifier && value.modifier._attribute && value.nodeContent;
}
function isComponentPublicInstance(value) {
    return value.$ && isComponentInternalInstance(value.$);
}
function isComponentInternalInstance(value) {
    return value.type && value.uid != null && value.appContext;
}
function formatComponentPublicInstance(value, depth) {
    return {
        type: 'object',
        className: 'ComponentPublicInstance',
        value: {
            properties: Object.entries(value.$.type).map(([name, value]) => formatObjectProperty(name, value, depth + 1)),
        },
    };
}
function formatComponentInternalInstance(value, depth) {
    return {
        type: 'object',
        className: 'ComponentInternalInstance',
        value: {
            properties: Object.entries(value.type).map(([name, value]) => formatObjectProperty(name, value, depth + 1)),
        },
    };
}
function isUniElement(value) {
    return value.style && value.tagName != null && value.nodeName != null;
}
function formatUniElement(value, depth) {
    return {
        type: 'object',
        // 非 x 没有 UniElement 的概念
        // className: 'UniElement',
        value: {
            properties: Object.entries(value)
                .filter(([name]) => [
                'id',
                'tagName',
                'nodeName',
                'dataset',
                'offsetTop',
                'offsetLeft',
                'style',
            ].includes(name))
                .map(([name, value]) => formatObjectProperty(name, value, depth + 1)),
        },
    };
}
function isCSSStyleDeclaration(value) {
    return (typeof value.getPropertyValue === 'function' &&
        typeof value.setProperty === 'function' &&
        value.$styles);
}
function formatCSSStyleDeclaration(style, depth) {
    return {
        type: 'object',
        value: {
            properties: Object.entries(style.$styles).map(([name, value]) => formatObjectProperty(name, value, depth + 1)),
        },
    };
}
function formatObjectProperty(name, value, depth) {
    const result = formatArg(value, depth);
    result.name = name;
    return result;
}
function formatArrayElement(value, index, depth) {
    const result = formatArg(value, depth);
    result.name = `${index}`;
    return result;
}
function formatSetEntry(value, depth) {
    return {
        value: formatArg(value, depth),
    };
}
function formatMapEntry(value, depth) {
    return {
        key: formatArg(value[0], depth),
        value: formatArg(value[1], depth),
    };
}

let sendConsole = null;
const messageQueue = [];
const messageExtra = {};
const EXCEPTION_BEGIN_MARK = '---BEGIN:EXCEPTION---';
const EXCEPTION_END_MARK = '---END:EXCEPTION---';
function sendConsoleMessages(messages) {
    if (sendConsole == null) {
        messageQueue.push(...messages);
        return;
    }
    sendConsole(JSON.stringify(Object.assign({
        type: 'console',
        data: messages,
    }, messageExtra)));
}
function setSendConsole(value, extra = {}) {
    sendConsole = value;
    Object.assign(messageExtra, extra);
    if (value != null && messageQueue.length > 0) {
        const messages = messageQueue.slice();
        messageQueue.length = 0;
        sendConsoleMessages(messages);
    }
}
const atFileRegex = /^\s*at\s+[\w/./-]+:\d+$/;
function rewriteConsole() {
    function wrapConsole(type) {
        return function (...args) {
            const originalArgs = [...args];
            if (originalArgs.length) {
                const maybeAtFile = originalArgs[originalArgs.length - 1];
                // 移除最后的 at pages/index/index.uvue:6
                if (typeof maybeAtFile === 'string' && atFileRegex.test(maybeAtFile)) {
                    originalArgs.pop();
                }
            }
            if (process.env.UNI_CONSOLE_KEEP_ORIGINAL) {
                originalConsole[type](...originalArgs);
            }
            if (type === 'error' && args.length === 1) {
                const arg = args[0];
                if (typeof arg === 'string' && arg.startsWith(EXCEPTION_BEGIN_MARK)) {
                    const startIndex = EXCEPTION_BEGIN_MARK.length;
                    const endIndex = arg.length - EXCEPTION_END_MARK.length;
                    sendErrorMessages([arg.slice(startIndex, endIndex)]);
                    return;
                }
                else if (arg instanceof Error) {
                    sendErrorMessages([arg]);
                    return;
                }
            }
            sendConsoleMessages([formatMessage(type, args)]);
        };
    }
    // 百度小程序不允许赋值，所以需要判断是否可写
    if (isConsoleWritable()) {
        CONSOLE_TYPES.forEach((type) => {
            console[type] = wrapConsole(type);
        });
        return function restoreConsole() {
            CONSOLE_TYPES.forEach((type) => {
                console[type] = originalConsole[type];
            });
        };
    }
    else {
        {
            if (typeof uni !== 'undefined' && uni.__f__) {
                const oldLog = uni.__f__;
                if (oldLog) {
                    // 重写 uni.__f__ 方法，这样的话，仅能打印开发者代码里的日志，其他没有被重写为__f__的日志将无法打印（比如uni-app框架、小程序框架等）
                    uni.__f__ = function (...args) {
                        const [type, filename, ...rest] = args;
                        // 原始日志移除 filename
                        oldLog(type, '', ...rest);
                        sendConsoleMessages([formatMessage(type, [...rest, filename])]);
                    };
                    return function restoreConsole() {
                        uni.__f__ = oldLog;
                    };
                }
            }
        }
    }
    return function restoreConsole() {
    };
}
function isConsoleWritable() {
    const value = console.log;
    const sym = Symbol();
    try {
        // @ts-expect-error
        console.log = sym;
    }
    catch (ex) {
        return false;
    }
    // @ts-expect-error
    const isWritable = console.log === sym;
    console.log = value;
    return isWritable;
}

function initRuntimeSocketService() {
    const hosts = process.env.UNI_SOCKET_HOSTS;
    const port = process.env.UNI_SOCKET_PORT;
    const id = process.env.UNI_SOCKET_ID;
    if (!hosts || !port || !id)
        return Promise.resolve(false);
    // 百度小程序需要延迟初始化，不然会存在循环引用问题vendor.js
    const lazy = typeof swan !== 'undefined';
    // 重写需要同步，避免丢失早期日志信息
    let restoreError = lazy ? () => { } : initOnError();
    let restoreConsole = lazy ? () => { } : rewriteConsole();
    // 百度小程序需要异步初始化，不然调用 uni.connectSocket 会循环引入vendor.js
    return Promise.resolve().then(() => {
        if (lazy) {
            restoreError = initOnError();
            restoreConsole = rewriteConsole();
        }
        return initRuntimeSocket(hosts, port, id).then((socket) => {
            if (!socket) {
                restoreError();
                restoreConsole();
                originalConsole.error(wrapError('开发模式下日志通道建立 socket 连接失败。'));
                originalConsole.error(wrapError('如果是运行到真机，请确认手机与电脑处于同一网络。'));
                return false;
            }
            socket.onClose(() => {
                if (process.env.UNI_DEBUG) {
                    originalConsole.log(`uni-app:[${Date.now()}][socket]`, 'connect close and restore');
                }
                // @ts-expect-error
                {
                    originalConsole.error(wrapError('手机端日志通道 socket 连接已断开，请重启基座应用或重新运行。'));
                }
                restoreError();
                restoreConsole();
            });
            setSendConsole((data) => {
                if (process.env.UNI_DEBUG) {
                    originalConsole.log(`uni-app:[${Date.now()}][console]`, data);
                }
                socket.send({
                    data,
                });
            });
            setSendError((data) => {
                if (process.env.UNI_DEBUG) {
                    originalConsole.log(`uni-app:[${Date.now()}][error]`, data);
                }
                socket.send({
                    data,
                });
            });
            return true;
        });
    });
}
const ERROR_CHAR = '\u200C';
function wrapError(error) {
    return `${ERROR_CHAR}${error}${ERROR_CHAR}`;
}
initRuntimeSocketService();

export { initRuntimeSocketService };