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