__uniwebview.dev.js

(function () {
    'use strict';

    /******************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */


    function __spreadArray(to, from, pack) {
        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
            if (ar || !(i in from)) {
                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
                ar[i] = from[i];
            }
        }
        return to.concat(ar || Array.prototype.slice.call(from));
    }

    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
        var e = new Error(message);
        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
    };

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

    var 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 上
    var errorQueue = new Set();
    var errorExtra = {};
    function sendErrorMessages(errors) {
        if (sendError == null) {
            errors.forEach(function (error) {
                errorQueue.add(error);
            });
            return;
        }
        var data = errors
            .map(function (err) {
            if (typeof err === 'string') {
                return err;
            }
            var isPromiseRejection = err && 'promise' in err && 'reason' in err;
            var prefix = isPromiseRejection ? 'UnhandledPromiseRejection: ' : '';
            if (isPromiseRejection) {
                err = err.reason;
            }
            if (err instanceof Error && err.stack) {
                if (err.message && !err.stack.includes(err.message)) {
                    return "".concat(prefix).concat(err.message, "\n").concat(err.stack);
                }
                return "".concat(prefix).concat(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: data,
            }, errorExtra)));
        }
    }
    function setSendError(value, extra) {
        if (extra === void 0) { extra = {}; }
        sendError = value;
        Object.assign(errorExtra, extra);
        if (value != null && errorQueue.size > 0) {
            var errors = Array.from(errorQueue);
            errorQueue.clear();
            sendErrorMessages(errors);
        }
    }

    function formatMessage(type, args) {
        try {
            return {
                type: type,
                args: formatArgs(args),
            };
        }
        catch (e) {
            // originalConsole.error(e)
        }
        return {
            type: type,
            args: [],
        };
    }
    function formatArgs(args) {
        return args.map(function (arg) { return formatArg(arg); });
    }
    function formatArg(arg, depth) {
        if (depth === void 0) { depth = 0; }
        if (depth >= 7) {
            return {
                type: 'object',
                value: '[Maximum depth reached]',
            };
        }
        var 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 ".concat(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: 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(function (v, i) {
                        return formatArrayElement(v, i, depth + 1);
                    }),
                },
            };
        }
        if (value instanceof Set) {
            return {
                type: 'object',
                subType: 'set',
                className: 'Set',
                description: "Set(".concat(value.size, ")"),
                value: {
                    entries: Array.from(value).map(function (v) { return formatSetEntry(v, depth + 1); }),
                },
            };
        }
        if (value instanceof Map) {
            return {
                type: 'object',
                subType: 'map',
                className: 'Map',
                description: "Map(".concat(value.size, ")"),
                value: {
                    entries: Array.from(value.entries()).map(function (v) { return 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',
            };
        }
        var className = undefined;
        {
            var constructor = value.constructor;
            if (constructor) {
                // @ts-expect-error
                if (constructor.get$UTSMetadata$) {
                    // @ts-expect-error
                    className = constructor.get$UTSMetadata$().name;
                }
            }
        }
        var entries = Object.entries(value);
        if (isHarmonyBuilderParams(value)) {
            entries = entries.filter(function (_a) {
                var key = _a[0];
                return key !== 'modifier' && key !== 'nodeContent';
            });
        }
        return {
            type: 'object',
            className: className,
            value: {
                properties: entries.map(function (entry) {
                    return 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(function (_a) {
                    var name = _a[0], value = _a[1];
                    return formatObjectProperty(name, value, depth + 1);
                }),
            },
        };
    }
    function formatComponentInternalInstance(value, depth) {
        return {
            type: 'object',
            className: 'ComponentInternalInstance',
            value: {
                properties: Object.entries(value.type).map(function (_a) {
                    var name = _a[0], value = _a[1];
                    return 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(function (_a) {
                    var name = _a[0];
                    return [
                        'id',
                        'tagName',
                        'nodeName',
                        'dataset',
                        'offsetTop',
                        'offsetLeft',
                        'style',
                    ].includes(name);
                })
                    .map(function (_a) {
                    var name = _a[0], value = _a[1];
                    return 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(function (_a) {
                    var name = _a[0], value = _a[1];
                    return formatObjectProperty(name, value, depth + 1);
                }),
            },
        };
    }
    function formatObjectProperty(name, value, depth) {
        var result = formatArg(value, depth);
        result.name = name;
        return result;
    }
    function formatArrayElement(value, index, depth) {
        var result = formatArg(value, depth);
        result.name = "".concat(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),
        };
    }

    var sendConsole = null;
    var messageQueue = [];
    var messageExtra = {};
    var EXCEPTION_BEGIN_MARK = '---BEGIN:EXCEPTION---';
    var EXCEPTION_END_MARK = '---END:EXCEPTION---';
    function sendConsoleMessages(messages) {
        if (sendConsole == null) {
            messageQueue.push.apply(messageQueue, messages);
            return;
        }
        sendConsole(JSON.stringify(Object.assign({
            type: 'console',
            data: messages,
        }, messageExtra)));
    }
    function setSendConsole(value, extra) {
        if (extra === void 0) { extra = {}; }
        sendConsole = value;
        Object.assign(messageExtra, extra);
        if (value != null && messageQueue.length > 0) {
            var messages = messageQueue.slice();
            messageQueue.length = 0;
            sendConsoleMessages(messages);
        }
    }
    var atFileRegex = /^\s*at\s+[\w/./-]+:\d+$/;
    function rewriteConsole() {
        function wrapConsole(type) {
            return function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                var originalArgs = __spreadArray([], args, true);
                if (originalArgs.length) {
                    var maybeAtFile = originalArgs[originalArgs.length - 1];
                    // 移除最后的 at pages/index/index.uvue:6
                    if (typeof maybeAtFile === 'string' && atFileRegex.test(maybeAtFile)) {
                        originalArgs.pop();
                    }
                }
                {
                    originalConsole[type].apply(originalConsole, originalArgs);
                }
                if (type === 'error' && args.length === 1) {
                    var arg = args[0];
                    if (typeof arg === 'string' && arg.startsWith(EXCEPTION_BEGIN_MARK)) {
                        var startIndex = EXCEPTION_BEGIN_MARK.length;
                        var 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(function (type) {
                console[type] = wrapConsole(type);
            });
            return function restoreConsole() {
                CONSOLE_TYPES.forEach(function (type) {
                    console[type] = originalConsole[type];
                });
            };
        }
        return function restoreConsole() {
        };
    }
    function isConsoleWritable() {
        var value = console.log;
        var sym = Symbol();
        try {
            // @ts-expect-error
            console.log = sym;
        }
        catch (ex) {
            return false;
        }
        // @ts-expect-error
        var isWritable = console.log === sym;
        console.log = value;
        return isWritable;
    }

    function initUniWebviewRuntimeService() {
        if (window.__UNI_CONSOLE_WEBVIEW__)
            return;
        window.__UNI_CONSOLE_WEBVIEW__ = true;
        var channel = "[web-view]".concat(window.__UNI_PAGE_ROUTE__ ? "[".concat(window.__UNI_PAGE_ROUTE__, "]") : '');
        rewriteConsole();
        setSendConsole(function (data) {
            sendToService(data);
        }, {
            channel: channel,
        });
        setSendError(function (data) {
            sendToService(data);
        }, {
            channel: channel,
        });
        // 监听同步错误
        window.addEventListener('error', function (event) {
            sendErrorMessages([event.error]);
        });
        // 监听Promise未处理的异步错误
        window.addEventListener('unhandledrejection', function (event) {
            sendErrorMessages([event]);
        });
    }
    function sendToService(data) {
        // 发送数据到 service 层
        var serviceMessage = {
            type: 'WEB_INVOKE_APPSERVICE',
            args: {
                data: {
                    name: 'console',
                    arg: data,
                },
            },
        };
        // @ts-expect-error
        if (window.__uniapp_x_postMessageToService) {
            // @ts-expect-error
            return window.__uniapp_x_postMessageToService(serviceMessage);
        }
        else {
            // @ts-expect-error
            return window.__uniapp_x_.postMessageToService(JSON.stringify(serviceMessage));
        }
    }
    initUniWebviewRuntimeService();

})();