1809 lines
50 KiB
JavaScript
1809 lines
50 KiB
JavaScript
import EventEmitter from 'eventemitter3'
|
||
import axios from 'axios'
|
||
|
||
var request$1 = function (_a) {
|
||
var _b = _a.method,
|
||
method = _b === void 0 ? 'POST' : _b,
|
||
url = _a.url,
|
||
data = _a.data,
|
||
headers = _a.headers
|
||
return new Promise(function (resolve, reject) {
|
||
uni.request({
|
||
url: url,
|
||
method: method,
|
||
data: data,
|
||
header: headers,
|
||
success: function (res) {
|
||
var data = res.data
|
||
if (data.code !== 200) {
|
||
return reject(data.msg)
|
||
}
|
||
resolve(data)
|
||
},
|
||
fail: function (err) {
|
||
reject(err)
|
||
},
|
||
})
|
||
})
|
||
}
|
||
var uniappRequestHelper = request$1
|
||
|
||
/******************************************************************************
|
||
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 */
|
||
|
||
var extendStatics = function (d, b) {
|
||
extendStatics =
|
||
Object.setPrototypeOf ||
|
||
({ __proto__: [] } instanceof Array &&
|
||
function (d, b) {
|
||
d.__proto__ = b
|
||
}) ||
|
||
function (d, b) {
|
||
for (var p in b)
|
||
if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]
|
||
}
|
||
return extendStatics(d, b)
|
||
}
|
||
|
||
function __extends(d, b) {
|
||
if (typeof b !== 'function' && b !== null)
|
||
throw new TypeError(
|
||
'Class extends value ' + String(b) + ' is not a constructor or null'
|
||
)
|
||
extendStatics(d, b)
|
||
function __() {
|
||
this.constructor = d
|
||
}
|
||
d.prototype =
|
||
b === null ? Object.create(b) : ((__.prototype = b.prototype), new __())
|
||
}
|
||
|
||
var __assign = function () {
|
||
__assign =
|
||
Object.assign ||
|
||
function __assign(t) {
|
||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||
s = arguments[i]
|
||
for (var p in s)
|
||
if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]
|
||
}
|
||
return t
|
||
}
|
||
return __assign.apply(this, arguments)
|
||
}
|
||
|
||
function __awaiter(thisArg, _arguments, P, generator) {
|
||
function adopt(value) {
|
||
return value instanceof P
|
||
? value
|
||
: new P(function (resolve) {
|
||
resolve(value)
|
||
})
|
||
}
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) {
|
||
try {
|
||
step(generator.next(value))
|
||
} catch (e) {
|
||
reject(e)
|
||
}
|
||
}
|
||
function rejected(value) {
|
||
try {
|
||
step(generator['throw'](value))
|
||
} catch (e) {
|
||
reject(e)
|
||
}
|
||
}
|
||
function step(result) {
|
||
result.done
|
||
? resolve(result.value)
|
||
: adopt(result.value).then(fulfilled, rejected)
|
||
}
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next())
|
||
})
|
||
}
|
||
|
||
function __generator(thisArg, body) {
|
||
var _ = {
|
||
label: 0,
|
||
sent: function () {
|
||
if (t[0] & 1) throw t[1]
|
||
return t[1]
|
||
},
|
||
trys: [],
|
||
ops: [],
|
||
},
|
||
f,
|
||
y,
|
||
t,
|
||
g
|
||
return (
|
||
(g = { next: verb(0), throw: verb(1), return: verb(2) }),
|
||
typeof Symbol === 'function' &&
|
||
(g[Symbol.iterator] = function () {
|
||
return this
|
||
}),
|
||
g
|
||
)
|
||
function verb(n) {
|
||
return function (v) {
|
||
return step([n, v])
|
||
}
|
||
}
|
||
function step(op) {
|
||
if (f) throw new TypeError('Generator is already executing.')
|
||
while ((g && ((g = 0), op[0] && (_ = 0)), _))
|
||
try {
|
||
if (
|
||
((f = 1),
|
||
y &&
|
||
(t =
|
||
op[0] & 2
|
||
? y['return']
|
||
: op[0]
|
||
? y['throw'] || ((t = y['return']) && t.call(y), 0)
|
||
: y.next) &&
|
||
!(t = t.call(y, op[1])).done)
|
||
)
|
||
return t
|
||
if (((y = 0), t)) op = [op[0] & 2, t.value]
|
||
switch (op[0]) {
|
||
case 0:
|
||
case 1:
|
||
t = op
|
||
break
|
||
case 4:
|
||
_.label++
|
||
return { value: op[1], done: false }
|
||
case 5:
|
||
_.label++
|
||
y = op[1]
|
||
op = [0]
|
||
continue
|
||
case 7:
|
||
op = _.ops.pop()
|
||
_.trys.pop()
|
||
continue
|
||
default:
|
||
if (
|
||
!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
|
||
(op[0] === 6 || op[0] === 2)
|
||
) {
|
||
_ = 0
|
||
continue
|
||
}
|
||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
|
||
_.label = op[1]
|
||
break
|
||
}
|
||
if (op[0] === 6 && _.label < t[1]) {
|
||
_.label = t[1]
|
||
t = op
|
||
break
|
||
}
|
||
if (t && _.label < t[2]) {
|
||
_.label = t[2]
|
||
_.ops.push(op)
|
||
break
|
||
}
|
||
if (t[2]) _.ops.pop()
|
||
_.trys.pop()
|
||
continue
|
||
}
|
||
op = body.call(thisArg, _)
|
||
} catch (e) {
|
||
op = [6, e]
|
||
y = 0
|
||
} finally {
|
||
f = t = 0
|
||
}
|
||
if (op[0] & 5) throw op[1]
|
||
return { value: op[0] ? op[1] : void 0, done: true }
|
||
}
|
||
}
|
||
|
||
function __values(o) {
|
||
var s = typeof Symbol === 'function' && Symbol.iterator,
|
||
m = s && o[s],
|
||
i = 0
|
||
if (m) return m.call(o)
|
||
if (o && typeof o.length === 'number')
|
||
return {
|
||
next: function () {
|
||
if (o && i >= o.length) o = void 0
|
||
return { value: o && o[i++], done: !o }
|
||
},
|
||
}
|
||
throw new TypeError(
|
||
s ? 'Object is not iterable.' : 'Symbol.iterator is not defined.'
|
||
)
|
||
}
|
||
|
||
function __read(o, n) {
|
||
var m = typeof Symbol === 'function' && o[Symbol.iterator]
|
||
if (!m) return o
|
||
var i = m.call(o),
|
||
r,
|
||
ar = [],
|
||
e
|
||
try {
|
||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value)
|
||
} catch (error) {
|
||
e = { error: error }
|
||
} finally {
|
||
try {
|
||
if (r && !r.done && (m = i['return'])) m.call(i)
|
||
} finally {
|
||
if (e) throw e.error
|
||
}
|
||
}
|
||
return ar
|
||
}
|
||
|
||
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 request = uniappRequestHelper
|
||
var Storage = /** @class */ (function () {
|
||
function Storage(type, salt) {
|
||
this.store = new Map()
|
||
this.type = 'memory'
|
||
this.salt = '__salt__'
|
||
type && (this.type = type)
|
||
salt && (this.salt = salt)
|
||
}
|
||
Storage.prototype.get = function (key) {
|
||
var value
|
||
switch (this.type) {
|
||
case 'memory':
|
||
return this.store.get(key)
|
||
case 'localStorage':
|
||
case 'sessionStorage':
|
||
value = uni.getStorageSync(''.concat(this.salt).concat(key))
|
||
return value
|
||
}
|
||
}
|
||
Storage.prototype.set = function (key, value) {
|
||
switch (this.type) {
|
||
case 'memory':
|
||
this.store.set(key, value)
|
||
break
|
||
case 'localStorage':
|
||
case 'sessionStorage':
|
||
uni.setStorageSync(''.concat(this.salt).concat(key), value)
|
||
break
|
||
}
|
||
}
|
||
Storage.prototype.remove = function (key) {
|
||
switch (this.type) {
|
||
case 'memory':
|
||
this.store.delete(key)
|
||
break
|
||
case 'localStorage':
|
||
case 'sessionStorage':
|
||
uni.removeStorageSync(''.concat(this.salt).concat(key))
|
||
break
|
||
}
|
||
}
|
||
return Storage
|
||
})()
|
||
var uniappStorage = Storage
|
||
|
||
var index = uniappStorage
|
||
var url$1 = 'https://statistic.live.126.net/statics/report/xkit/action'
|
||
var EventTracking = /** @class */ (function () {
|
||
function EventTracking(_a) {
|
||
var appKey = _a.appKey,
|
||
version = _a.version,
|
||
component = _a.component,
|
||
nertcVersion = _a.nertcVersion,
|
||
imVersion = _a.imVersion,
|
||
_b = _a.os,
|
||
os = _b === void 0 ? '' : _b,
|
||
_c = _a.framework,
|
||
framework = _c === void 0 ? '' : _c,
|
||
_d = _a.language,
|
||
language = _d === void 0 ? '' : _d,
|
||
_e = _a.container,
|
||
container = _e === void 0 ? '' : _e,
|
||
_f = _a.platform,
|
||
platform = _f === void 0 ? 'Web' : _f,
|
||
_g = _a.channel,
|
||
channel = _g === void 0 ? 'netease' : _g
|
||
this.platform = platform
|
||
this.appKey = appKey
|
||
this.version = version
|
||
this.component = component
|
||
this.nertcVersion = nertcVersion
|
||
this.imVersion = imVersion
|
||
this.channel = channel
|
||
this.os = os
|
||
this.framework = framework
|
||
this.language = language
|
||
this.container = container
|
||
}
|
||
EventTracking.prototype.track = function (reportType, data) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _a,
|
||
appKey,
|
||
version,
|
||
component,
|
||
nertcVersion,
|
||
imVersion,
|
||
platform,
|
||
channel,
|
||
os,
|
||
framework,
|
||
language,
|
||
container,
|
||
timeStamp
|
||
return __generator(this, function (_c) {
|
||
switch (_c.label) {
|
||
case 0:
|
||
;(_a = this),
|
||
(appKey = _a.appKey),
|
||
(version = _a.version),
|
||
(component = _a.component),
|
||
(nertcVersion = _a.nertcVersion),
|
||
(imVersion = _a.imVersion),
|
||
(platform = _a.platform),
|
||
(channel = _a.channel),
|
||
(os = _a.os),
|
||
(framework = _a.framework),
|
||
(language = _a.language),
|
||
(container = _a.container)
|
||
timeStamp = Date.now()
|
||
_c.label = 1
|
||
case 1:
|
||
_c.trys.push([1, 3, , 4])
|
||
return [
|
||
4 /*yield*/,
|
||
request({
|
||
method: 'POST',
|
||
url: url$1,
|
||
data: {
|
||
appKey: appKey,
|
||
version: version,
|
||
component: component,
|
||
timeStamp: timeStamp,
|
||
nertcVersion: nertcVersion,
|
||
imVersion: imVersion,
|
||
platform: platform,
|
||
reportType: reportType,
|
||
data: data,
|
||
channel: channel,
|
||
os: os,
|
||
framework: framework,
|
||
language: language,
|
||
container: container,
|
||
},
|
||
}),
|
||
]
|
||
case 2:
|
||
_c.sent()
|
||
return [3 /*break*/, 4]
|
||
case 3:
|
||
_c.sent()
|
||
return [3 /*break*/, 4]
|
||
case 4:
|
||
return [2 /*return*/]
|
||
}
|
||
})
|
||
})
|
||
}
|
||
return EventTracking
|
||
})()
|
||
var EventTracking$1 = EventTracking
|
||
|
||
/**
|
||
* 判断元素是否可见
|
||
* 融合了 IntersectionObserver 与 visibilityChange 事件
|
||
*/
|
||
var VisibilityObserver = /** @class */ (function (_super) {
|
||
__extends(VisibilityObserver, _super)
|
||
// 入参说明参考：https://developer.mozilla.org/zh-CN/docs/Web/API/Intersection_Observer_API
|
||
function VisibilityObserver(options) {
|
||
var _this = _super.call(this) || this
|
||
_this.visibilityState = document.visibilityState
|
||
_this.entries = []
|
||
_this._visibilitychange = function () {
|
||
_this.visibilityState = document.visibilityState
|
||
_this._trigger()
|
||
}
|
||
_this.intersectionObserver = new IntersectionObserver(
|
||
_this._intersectionObserverHandler.bind(_this),
|
||
options
|
||
)
|
||
document.addEventListener('visibilitychange', _this._visibilitychange)
|
||
return _this
|
||
}
|
||
VisibilityObserver.prototype.observe = function (target) {
|
||
return this.intersectionObserver.observe(target)
|
||
}
|
||
VisibilityObserver.prototype.unobserve = function (target) {
|
||
return this.intersectionObserver.unobserve(target)
|
||
}
|
||
VisibilityObserver.prototype.destroy = function () {
|
||
this.intersectionObserver.disconnect()
|
||
document.removeEventListener('visibilitychange', this._visibilitychange)
|
||
this.entries = []
|
||
}
|
||
VisibilityObserver.prototype._intersectionObserverHandler = function (
|
||
entries
|
||
) {
|
||
this.entries = entries
|
||
this._trigger()
|
||
}
|
||
VisibilityObserver.prototype._trigger = function () {
|
||
var _this = this
|
||
this.entries.forEach(function (item) {
|
||
if (_this.visibilityState !== 'visible' || item.intersectionRatio <= 0) {
|
||
_this.emit('visibleChange', {
|
||
visible: false,
|
||
target: item.target,
|
||
})
|
||
return
|
||
}
|
||
_this.emit('visibleChange', {
|
||
visible: true,
|
||
target: item.target,
|
||
})
|
||
})
|
||
}
|
||
return VisibilityObserver
|
||
})(EventEmitter)
|
||
var VisibilityObserver$1 = VisibilityObserver
|
||
|
||
var commonjsGlobal =
|
||
typeof globalThis !== 'undefined'
|
||
? globalThis
|
||
: typeof window !== 'undefined'
|
||
? window
|
||
: typeof global !== 'undefined'
|
||
? global
|
||
: typeof self !== 'undefined'
|
||
? self
|
||
: {}
|
||
|
||
function createCommonjsModule(fn, module) {
|
||
return (module = { exports: {} }), fn(module, module.exports), module.exports
|
||
}
|
||
|
||
var loglevel = createCommonjsModule(function (module) {
|
||
/*
|
||
* loglevel - https://github.com/pimterry/loglevel
|
||
*
|
||
* Copyright (c) 2013 Tim Perry
|
||
* Licensed under the MIT license.
|
||
*/
|
||
;(function (root, definition) {
|
||
if (module.exports) {
|
||
module.exports = definition()
|
||
} else {
|
||
root.log = definition()
|
||
}
|
||
})(commonjsGlobal, function () {
|
||
// Slightly dubious tricks to cut down minimized file size
|
||
var noop = function () {}
|
||
var undefinedType = 'undefined'
|
||
var isIE =
|
||
typeof window !== undefinedType &&
|
||
typeof window.navigator !== undefinedType &&
|
||
/Trident\/|MSIE /.test(window.navigator.userAgent)
|
||
|
||
var logMethods = ['trace', 'debug', 'info', 'warn', 'error']
|
||
|
||
var _loggersByName = {}
|
||
var defaultLogger = null
|
||
|
||
// Cross-browser bind equivalent that works at least back to IE6
|
||
function bindMethod(obj, methodName) {
|
||
var method = obj[methodName]
|
||
if (typeof method.bind === 'function') {
|
||
return method.bind(obj)
|
||
} else {
|
||
try {
|
||
return Function.prototype.bind.call(method, obj)
|
||
} catch (e) {
|
||
// Missing bind shim or IE8 + Modernizr, fallback to wrapping
|
||
return function () {
|
||
return Function.prototype.apply.apply(method, [obj, arguments])
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Trace() doesn't print the message in IE, so for that case we need to wrap it
|
||
function traceForIE() {
|
||
if (console.log) {
|
||
if (console.log.apply) {
|
||
console.log.apply(console, arguments)
|
||
} else {
|
||
// In old IE, native console methods themselves don't have apply().
|
||
Function.prototype.apply.apply(console.log, [console, arguments])
|
||
}
|
||
}
|
||
if (console.trace) console.trace()
|
||
}
|
||
|
||
// Build the best logging method possible for this env
|
||
// Wherever possible we want to bind, not wrap, to preserve stack traces
|
||
function realMethod(methodName) {
|
||
if (methodName === 'debug') {
|
||
methodName = 'log'
|
||
}
|
||
|
||
if (typeof console === undefinedType) {
|
||
return false // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives
|
||
} else if (methodName === 'trace' && isIE) {
|
||
return traceForIE
|
||
} else if (console[methodName] !== undefined) {
|
||
return bindMethod(console, methodName)
|
||
} else if (console.log !== undefined) {
|
||
return bindMethod(console, 'log')
|
||
} else {
|
||
return noop
|
||
}
|
||
}
|
||
|
||
// These private functions always need `this` to be set properly
|
||
|
||
function replaceLoggingMethods() {
|
||
/*jshint validthis:true */
|
||
var level = this.getLevel()
|
||
|
||
// Replace the actual methods.
|
||
for (var i = 0; i < logMethods.length; i++) {
|
||
var methodName = logMethods[i]
|
||
this[methodName] =
|
||
i < level ? noop : this.methodFactory(methodName, level, this.name)
|
||
}
|
||
|
||
// Define log.log as an alias for log.debug
|
||
this.log = this.debug
|
||
|
||
// Return any important warnings.
|
||
if (typeof console === undefinedType && level < this.levels.SILENT) {
|
||
return 'No console available for logging'
|
||
}
|
||
}
|
||
|
||
// In old IE versions, the console isn't present until you first open it.
|
||
// We build realMethod() replacements here that regenerate logging methods
|
||
function enableLoggingWhenConsoleArrives(methodName) {
|
||
return function () {
|
||
if (typeof console !== undefinedType) {
|
||
replaceLoggingMethods.call(this)
|
||
this[methodName].apply(this, arguments)
|
||
}
|
||
}
|
||
}
|
||
|
||
// By default, we use closely bound real methods wherever possible, and
|
||
// otherwise we wait for a console to appear, and then try again.
|
||
function defaultMethodFactory(methodName, _level, _loggerName) {
|
||
/*jshint validthis:true */
|
||
return (
|
||
realMethod(methodName) ||
|
||
enableLoggingWhenConsoleArrives.apply(this, arguments)
|
||
)
|
||
}
|
||
|
||
function Logger(name, factory) {
|
||
// Private instance variables.
|
||
var self = this
|
||
/**
|
||
* The level inherited from a parent logger (or a global default). We
|
||
* cache this here rather than delegating to the parent so that it stays
|
||
* in sync with the actual logging methods that we have installed (the
|
||
* parent could change levels but we might not have rebuilt the loggers
|
||
* in this child yet).
|
||
* @type {number}
|
||
*/
|
||
var inheritedLevel
|
||
/**
|
||
* The default level for this logger, if any. If set, this overrides
|
||
* `inheritedLevel`.
|
||
* @type {number|null}
|
||
*/
|
||
var defaultLevel
|
||
/**
|
||
* A user-specific level for this logger. If set, this overrides
|
||
* `defaultLevel`.
|
||
* @type {number|null}
|
||
*/
|
||
var userLevel
|
||
|
||
var storageKey = 'loglevel'
|
||
if (typeof name === 'string') {
|
||
storageKey += ':' + name
|
||
} else if (typeof name === 'symbol') {
|
||
storageKey = undefined
|
||
}
|
||
|
||
function persistLevelIfPossible(levelNum) {
|
||
var levelName = (logMethods[levelNum] || 'silent').toUpperCase()
|
||
|
||
if (typeof window === undefinedType || !storageKey) return
|
||
|
||
// Use localStorage if available
|
||
try {
|
||
window.localStorage[storageKey] = levelName
|
||
return
|
||
} catch (ignore) {}
|
||
|
||
// Use session cookie as fallback
|
||
try {
|
||
window.document.cookie =
|
||
encodeURIComponent(storageKey) + '=' + levelName + ';'
|
||
} catch (ignore) {}
|
||
}
|
||
|
||
function getPersistedLevel() {
|
||
var storedLevel
|
||
|
||
if (typeof window === undefinedType || !storageKey) return
|
||
|
||
try {
|
||
storedLevel = window.localStorage[storageKey]
|
||
} catch (ignore) {}
|
||
|
||
// Fallback to cookies if local storage gives us nothing
|
||
if (typeof storedLevel === undefinedType) {
|
||
try {
|
||
var cookie = window.document.cookie
|
||
var cookieName = encodeURIComponent(storageKey)
|
||
var location = cookie.indexOf(cookieName + '=')
|
||
if (location !== -1) {
|
||
storedLevel = /^([^;]+)/.exec(
|
||
cookie.slice(location + cookieName.length + 1)
|
||
)[1]
|
||
}
|
||
} catch (ignore) {}
|
||
}
|
||
|
||
// If the stored level is not valid, treat it as if nothing was stored.
|
||
if (self.levels[storedLevel] === undefined) {
|
||
storedLevel = undefined
|
||
}
|
||
|
||
return storedLevel
|
||
}
|
||
|
||
function clearPersistedLevel() {
|
||
if (typeof window === undefinedType || !storageKey) return
|
||
|
||
// Use localStorage if available
|
||
try {
|
||
window.localStorage.removeItem(storageKey)
|
||
} catch (ignore) {}
|
||
|
||
// Use session cookie as fallback
|
||
try {
|
||
window.document.cookie =
|
||
encodeURIComponent(storageKey) +
|
||
'=; expires=Thu, 01 Jan 1970 00:00:00 UTC'
|
||
} catch (ignore) {}
|
||
}
|
||
|
||
function normalizeLevel(input) {
|
||
var level = input
|
||
if (
|
||
typeof level === 'string' &&
|
||
self.levels[level.toUpperCase()] !== undefined
|
||
) {
|
||
level = self.levels[level.toUpperCase()]
|
||
}
|
||
if (
|
||
typeof level === 'number' &&
|
||
level >= 0 &&
|
||
level <= self.levels.SILENT
|
||
) {
|
||
return level
|
||
} else {
|
||
throw new TypeError(
|
||
'log.setLevel() called with invalid level: ' + input
|
||
)
|
||
}
|
||
}
|
||
|
||
/*
|
||
*
|
||
* Public logger API - see https://github.com/pimterry/loglevel for details
|
||
*
|
||
*/
|
||
|
||
self.name = name
|
||
|
||
self.levels = {
|
||
TRACE: 0,
|
||
DEBUG: 1,
|
||
INFO: 2,
|
||
WARN: 3,
|
||
ERROR: 4,
|
||
SILENT: 5,
|
||
}
|
||
|
||
self.methodFactory = factory || defaultMethodFactory
|
||
|
||
self.getLevel = function () {
|
||
if (userLevel != null) {
|
||
return userLevel
|
||
} else if (defaultLevel != null) {
|
||
return defaultLevel
|
||
} else {
|
||
return inheritedLevel
|
||
}
|
||
}
|
||
|
||
self.setLevel = function (level, persist) {
|
||
userLevel = normalizeLevel(level)
|
||
if (persist !== false) {
|
||
// defaults to true
|
||
persistLevelIfPossible(userLevel)
|
||
}
|
||
|
||
// NOTE: in v2, this should call rebuild(), which updates children.
|
||
return replaceLoggingMethods.call(self)
|
||
}
|
||
|
||
self.setDefaultLevel = function (level) {
|
||
defaultLevel = normalizeLevel(level)
|
||
if (!getPersistedLevel()) {
|
||
self.setLevel(level, false)
|
||
}
|
||
}
|
||
|
||
self.resetLevel = function () {
|
||
userLevel = null
|
||
clearPersistedLevel()
|
||
replaceLoggingMethods.call(self)
|
||
}
|
||
|
||
self.enableAll = function (persist) {
|
||
self.setLevel(self.levels.TRACE, persist)
|
||
}
|
||
|
||
self.disableAll = function (persist) {
|
||
self.setLevel(self.levels.SILENT, persist)
|
||
}
|
||
|
||
self.rebuild = function () {
|
||
if (defaultLogger !== self) {
|
||
inheritedLevel = normalizeLevel(defaultLogger.getLevel())
|
||
}
|
||
replaceLoggingMethods.call(self)
|
||
|
||
if (defaultLogger === self) {
|
||
for (var childName in _loggersByName) {
|
||
_loggersByName[childName].rebuild()
|
||
}
|
||
}
|
||
}
|
||
|
||
// Initialize all the internal levels.
|
||
inheritedLevel = normalizeLevel(
|
||
defaultLogger ? defaultLogger.getLevel() : 'WARN'
|
||
)
|
||
var initialLevel = getPersistedLevel()
|
||
if (initialLevel != null) {
|
||
userLevel = normalizeLevel(initialLevel)
|
||
}
|
||
replaceLoggingMethods.call(self)
|
||
}
|
||
|
||
/*
|
||
*
|
||
* Top-level API
|
||
*
|
||
*/
|
||
|
||
defaultLogger = new Logger()
|
||
|
||
defaultLogger.getLogger = function getLogger(name) {
|
||
if (
|
||
(typeof name !== 'symbol' && typeof name !== 'string') ||
|
||
name === ''
|
||
) {
|
||
throw new TypeError('You must supply a name when creating a logger.')
|
||
}
|
||
|
||
var logger = _loggersByName[name]
|
||
if (!logger) {
|
||
logger = _loggersByName[name] = new Logger(
|
||
name,
|
||
defaultLogger.methodFactory
|
||
)
|
||
}
|
||
return logger
|
||
}
|
||
|
||
// Grab the current global log variable in case of overwrite
|
||
var _log = typeof window !== undefinedType ? window.log : undefined
|
||
defaultLogger.noConflict = function () {
|
||
if (typeof window !== undefinedType && window.log === defaultLogger) {
|
||
window.log = _log
|
||
}
|
||
|
||
return defaultLogger
|
||
}
|
||
|
||
defaultLogger.getLoggers = function getLoggers() {
|
||
return _loggersByName
|
||
}
|
||
|
||
// ES6 default export, for compatibility
|
||
defaultLogger['default'] = defaultLogger
|
||
|
||
return defaultLogger
|
||
})
|
||
})
|
||
|
||
var log = loglevel
|
||
|
||
function createLoggerDecorator(MODULE_NAME, logger) {
|
||
return function (__, propKey, descriptor) {
|
||
var method = descriptor.value
|
||
descriptor.value = function () {
|
||
var args = []
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i]
|
||
}
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var methodName, res, err_1
|
||
return __generator(this, function (_a) {
|
||
switch (_a.label) {
|
||
case 0:
|
||
if (!logger) {
|
||
// @ts-ignore
|
||
logger = this.logger
|
||
}
|
||
if (
|
||
['log', 'error'].some(function (item) {
|
||
return !logger[item]
|
||
})
|
||
) {
|
||
console.warn(
|
||
'loggerDecorator warning: your logger is not complete'
|
||
)
|
||
}
|
||
methodName = method.name || propKey || ''
|
||
_a.label = 1
|
||
case 1:
|
||
_a.trys.push([1, 3, , 4])
|
||
logger === null || logger === void 0
|
||
? void 0
|
||
: logger.log.apply(
|
||
logger,
|
||
__spreadArray(
|
||
[MODULE_NAME, methodName],
|
||
__read(args),
|
||
false
|
||
)
|
||
)
|
||
return [4 /*yield*/, method.apply(this, args)]
|
||
case 2:
|
||
res = _a.sent()
|
||
logger === null || logger === void 0
|
||
? void 0
|
||
: logger.log(
|
||
MODULE_NAME,
|
||
''.concat(methodName, ' success: '),
|
||
res
|
||
)
|
||
return [2 /*return*/, res]
|
||
case 3:
|
||
err_1 = _a.sent()
|
||
logger === null || logger === void 0
|
||
? void 0
|
||
: logger.error(
|
||
MODULE_NAME,
|
||
''.concat(methodName, ' failed: '),
|
||
err_1
|
||
)
|
||
throw err_1
|
||
case 4:
|
||
return [2 /*return*/]
|
||
}
|
||
})
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
function sensitiveInfoFilter(content) {
|
||
var regexs = [
|
||
'scene/apps/[a-z0-9]{32}/',
|
||
'"rtcKey":"[a-z0-9]{32}"',
|
||
'"imKey":"[a-z0-9]{32}"',
|
||
'"appkey":"[a-z0-9]{32}"',
|
||
'"appkey": "[a-z0-9]{32}"',
|
||
'appkey:"[a-z0-9]{32}"',
|
||
'appkey: "[a-z0-9]{32}"',
|
||
'"appkey":[a-z0-9]{32}',
|
||
'"appkey": [a-z0-9]{32}',
|
||
'appkey:[a-z0-9]{32}',
|
||
'appkey: [a-z0-9]{32}',
|
||
]
|
||
var templates = [
|
||
'scene/apps/***/',
|
||
'"rtcKey":"***"',
|
||
'"imKey":"***"',
|
||
'"appkey":"***"',
|
||
'"appkey": "***"',
|
||
'appkey:"***"',
|
||
'appkey: "***"',
|
||
'"appkey":***',
|
||
'"appkey": ***',
|
||
'appkey:***',
|
||
'appkey: ***',
|
||
]
|
||
regexs.forEach(function (regex, index) {
|
||
var reg = new RegExp(regex, 'gi')
|
||
content = content.replace(reg, templates[index])
|
||
})
|
||
return content
|
||
}
|
||
var logDebug = function (_a) {
|
||
var _b =
|
||
_a === void 0
|
||
? {
|
||
appName: '',
|
||
version: '',
|
||
storeWindow: false,
|
||
needStringify: true,
|
||
}
|
||
: _a,
|
||
level = _b.level,
|
||
_c = _b.appName,
|
||
appName = _c === void 0 ? '' : _c,
|
||
_d = _b.storeWindow,
|
||
storeWindow = _d === void 0 ? false : _d,
|
||
_e = _b.needStringify,
|
||
needStringify = _e === void 0 ? true : _e
|
||
var genTime = function () {
|
||
var now = new Date()
|
||
var year = now.getFullYear()
|
||
var month = now.getMonth() + 1
|
||
var day = now.getDate()
|
||
var hour = now.getHours() < 10 ? '0'.concat(now.getHours()) : now.getHours()
|
||
var min =
|
||
now.getMinutes() < 10 ? '0'.concat(now.getMinutes()) : now.getMinutes()
|
||
var s =
|
||
now.getSeconds() < 10 ? '0'.concat(now.getSeconds()) : now.getSeconds()
|
||
var nowString = ''
|
||
.concat(year, '-')
|
||
.concat(month, '-')
|
||
.concat(day, ' ')
|
||
.concat(hour, ':')
|
||
.concat(min, ':')
|
||
.concat(s)
|
||
return nowString
|
||
}
|
||
var genUserAgent = function () {
|
||
try {
|
||
var ua = navigator.userAgent.toLocaleLowerCase()
|
||
var re = /(msie|firefox|chrome|opera|version).*?([\d.]+)/
|
||
var m = ua.match(re) || []
|
||
var browser = m[1].replace(/version/, 'safari')
|
||
var ver = m[2]
|
||
return {
|
||
browser: browser,
|
||
ver: ver,
|
||
}
|
||
} catch (error) {
|
||
return null
|
||
}
|
||
}
|
||
var proxyLog = function () {
|
||
var _log = new Proxy(log, {
|
||
get: function (target, prop) {
|
||
var _a, _b
|
||
if (!(prop in target)) {
|
||
return
|
||
}
|
||
var func = target[prop]
|
||
if (
|
||
!['log', 'info', 'warn', 'error', 'trace', 'debug'].includes(prop)
|
||
) {
|
||
return func
|
||
}
|
||
var prefix = genTime()
|
||
if (genUserAgent()) {
|
||
prefix += '['
|
||
.concat(
|
||
(_a = genUserAgent()) === null || _a === void 0
|
||
? void 0
|
||
: _a.browser,
|
||
' '
|
||
)
|
||
.concat(
|
||
(_b = genUserAgent()) === null || _b === void 0 ? void 0 : _b.ver,
|
||
']'
|
||
)
|
||
}
|
||
prefix +=
|
||
'['.concat(
|
||
{
|
||
log: 'L',
|
||
info: 'I',
|
||
warn: 'W',
|
||
error: 'E',
|
||
trace: 'E',
|
||
debug: 'D',
|
||
}[prop],
|
||
']'
|
||
) +
|
||
'['.concat(appName, ']') +
|
||
':'
|
||
// eslint-disable-next-line @typescript-eslint/no-this-alias
|
||
var that = this
|
||
return function () {
|
||
var args = []
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i]
|
||
}
|
||
if (needStringify) {
|
||
for (var i = 0; i < args.length; i++) {
|
||
if (typeof args[i] === 'object') {
|
||
try {
|
||
args[i] = JSON.stringify(args[i])
|
||
} catch (_a) {
|
||
console.warn('[日志打印对象无法序列化]', args[i])
|
||
}
|
||
}
|
||
if (typeof args[i] === 'string') {
|
||
args[i] = sensitiveInfoFilter(args[i])
|
||
}
|
||
}
|
||
}
|
||
return func.apply(that, __spreadArray([prefix], __read(args), false))
|
||
}
|
||
},
|
||
})
|
||
return _log
|
||
}
|
||
var logger = proxyLog()
|
||
if (level) {
|
||
logger.setLevel(level)
|
||
}
|
||
if (storeWindow) {
|
||
// @ts-ignore
|
||
window.__LOGGER__ = logger
|
||
}
|
||
return logger
|
||
}
|
||
var logDebug$1 = logDebug
|
||
|
||
var EventPriority
|
||
;(function (EventPriority) {
|
||
EventPriority[(EventPriority['LOW'] = 0)] = 'LOW'
|
||
EventPriority[(EventPriority['NORMAL'] = 1)] = 'NORMAL'
|
||
EventPriority[(EventPriority['HIGH'] = 2)] = 'HIGH'
|
||
})(EventPriority || (EventPriority = {}))
|
||
var ReportEvent = /** @class */ (function () {
|
||
// private _report: XKitReporter
|
||
function ReportEvent(options) {
|
||
// static appInfo: AppInfo
|
||
this.appKey = ''
|
||
this.component = ''
|
||
this.data = {}
|
||
this.framework = ''
|
||
this.version = ''
|
||
this.startTime = 0
|
||
this.endTime = 0
|
||
this.duration = 0
|
||
this.data.startTime = new Date().getTime()
|
||
this.data.timeStamp = this.data.startTime
|
||
this.eventId = options.eventId
|
||
this.priority = options.priority
|
||
}
|
||
ReportEvent.prototype.end = function () {
|
||
// 如果已经end过 不再end
|
||
if (this.data.endTime && this.data.duration) {
|
||
return
|
||
}
|
||
this.data.endTime = this.data.endTime || new Date().getTime()
|
||
this.data.duration =
|
||
this.data.duration || this.data.endTime - this.data.startTime
|
||
}
|
||
ReportEvent.prototype.setAppInfo = function (appInfo) {
|
||
this.appKey = appInfo.appKey
|
||
this.component = appInfo.component
|
||
this.version = appInfo.version
|
||
if (appInfo.framework) {
|
||
this.framework = appInfo.framework
|
||
}
|
||
}
|
||
ReportEvent.prototype.endWith = function (data) {
|
||
var code = data.code,
|
||
msg = data.msg,
|
||
requestId = data.requestId,
|
||
serverCost = data.serverCost
|
||
// 过滤code非number类型
|
||
if (typeof code != 'number') {
|
||
this.data.code = -2
|
||
} else {
|
||
this.data.code = code
|
||
}
|
||
this.data.message = msg
|
||
this.data.requestId = requestId
|
||
this.data.serverCost = serverCost
|
||
this.end()
|
||
}
|
||
ReportEvent.prototype.endWithSuccess = function (data) {
|
||
if (data) {
|
||
var requestId = data.requestId,
|
||
serverCost = data.serverCost
|
||
this.data.requestId = requestId
|
||
this.data.serverCost = serverCost
|
||
}
|
||
this.data.code = 0
|
||
this.data.message = 'success'
|
||
this.end()
|
||
}
|
||
ReportEvent.prototype.endWithFailure = function (data) {
|
||
if (data) {
|
||
var requestId = data.requestId,
|
||
serverCost = data.serverCost
|
||
this.data.requestId = requestId
|
||
this.data.serverCost = serverCost
|
||
}
|
||
this.data.code = -1
|
||
this.data.message = 'failure'
|
||
this.end()
|
||
}
|
||
ReportEvent.prototype.setParams = function (params) {
|
||
this.data.params = __assign({}, params)
|
||
return this
|
||
}
|
||
ReportEvent.prototype.addParams = function (params) {
|
||
this.data.params = __assign(__assign({}, this.data.params), params)
|
||
return this
|
||
}
|
||
ReportEvent.prototype.setData = function (data) {
|
||
this.data = __assign(__assign({}, this.data), data)
|
||
}
|
||
ReportEvent.prototype.setUserId = function (userId) {
|
||
this.data.userId = userId
|
||
}
|
||
return ReportEvent
|
||
})()
|
||
var EventStep = /** @class */ (function (_super) {
|
||
__extends(EventStep, _super)
|
||
function EventStep(options) {
|
||
return _super.call(this, options) || this
|
||
}
|
||
return EventStep
|
||
})(ReportEvent)
|
||
var IntervalEvent = /** @class */ (function (_super) {
|
||
__extends(IntervalEvent, _super)
|
||
function IntervalEvent(options) {
|
||
var _this = _super.call(this, options) || this
|
||
_this._stepMap = new Map()
|
||
return _this
|
||
}
|
||
IntervalEvent.prototype.beginStep = function (name) {
|
||
if (this._stepMap.has(name)) {
|
||
return this._stepMap[name]
|
||
}
|
||
var step = new EventStep({ eventId: name, priority: this.priority })
|
||
step.setData({ step: name })
|
||
this._stepMap.set(name, step)
|
||
return step
|
||
}
|
||
IntervalEvent.prototype.addStep = function (data) {
|
||
this._stepMap.set(data.eventId, data)
|
||
}
|
||
IntervalEvent.prototype.removeStep = function (eventId) {
|
||
this._stepMap.delete(eventId)
|
||
}
|
||
IntervalEvent.prototype.endWith = function (data) {
|
||
_super.prototype.endWith.call(this, data)
|
||
this.end()
|
||
}
|
||
IntervalEvent.prototype.endWithSuccess = function (data) {
|
||
_super.prototype.endWithSuccess.call(this, data)
|
||
this.end()
|
||
}
|
||
IntervalEvent.prototype.endWithFailure = function (data) {
|
||
_super.prototype.endWithFailure.call(this, data)
|
||
this.end()
|
||
}
|
||
IntervalEvent.prototype.end = function () {
|
||
var e_1, _a
|
||
var steps = []
|
||
_super.prototype.end.call(this)
|
||
try {
|
||
for (
|
||
var _b = __values(this._stepMap.values()), _c = _b.next();
|
||
!_c.done;
|
||
_c = _b.next()
|
||
) {
|
||
var step = _c.value
|
||
// step.end()
|
||
step.data.index = steps.length
|
||
steps.push(step.data)
|
||
}
|
||
} catch (e_1_1) {
|
||
e_1 = { error: e_1_1 }
|
||
} finally {
|
||
try {
|
||
if (_c && !_c.done && (_a = _b.return)) _a.call(_b)
|
||
} finally {
|
||
if (e_1) throw e_1.error
|
||
}
|
||
}
|
||
if (steps.length > 0) {
|
||
this.data.steps = steps
|
||
}
|
||
}
|
||
return IntervalEvent
|
||
})(EventStep)
|
||
|
||
/**
|
||
* 异步频率控制
|
||
* 一段时间内只请求一次，多余的用这一次执行的结果做为结果
|
||
* @param fn
|
||
* @param delay
|
||
*/
|
||
var frequencyControl = function (fn, delay) {
|
||
var queue = []
|
||
var last = 0
|
||
var timer
|
||
return function () {
|
||
var _this = this
|
||
var args = []
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i]
|
||
}
|
||
return new Promise(function (resolve, reject) {
|
||
queue.push({ resolve: resolve, reject: reject })
|
||
var cur = Date.now()
|
||
var consumer = function (success, res) {
|
||
while (queue.length) {
|
||
var _a = queue.shift(),
|
||
resolve_1 = _a.resolve,
|
||
reject_1 = _a.reject
|
||
success ? resolve_1(res) : reject_1(res)
|
||
}
|
||
}
|
||
var excute = function () {
|
||
last = cur
|
||
if (!queue.length) return
|
||
// @ts-ignore
|
||
fn.apply(_this, args).then(
|
||
function (res) {
|
||
consumer(true, res)
|
||
},
|
||
function (err) {
|
||
consumer(false, err)
|
||
}
|
||
)
|
||
}
|
||
if (cur - last > delay) {
|
||
excute()
|
||
} else {
|
||
clearTimeout(timer)
|
||
timer = setTimeout(function () {
|
||
excute()
|
||
}, delay)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
function getFileType(filename) {
|
||
var fileMap = {
|
||
img: /(png|gif|jpg)/i,
|
||
pdf: /pdf$/i,
|
||
word: /(doc|docx)$/i,
|
||
excel: /(xls|xlsx)$/i,
|
||
ppt: /(ppt|pptx)$/i,
|
||
zip: /(zip|rar|7z)$/i,
|
||
audio: /(mp3|wav|wmv)$/i,
|
||
video: /(mp4|mkv|rmvb|wmv|avi|flv|mov)$/i,
|
||
}
|
||
return (
|
||
Object.keys(fileMap).find(function (type) {
|
||
return fileMap[type].test(filename)
|
||
}) || ''
|
||
)
|
||
}
|
||
/**
|
||
* 解析输入的文件大小
|
||
* @param size 文件大小，单位b
|
||
* @param level 递归等级，对应fileSizeMap
|
||
*/
|
||
var parseFileSize = function (size, level) {
|
||
if (level === void 0) {
|
||
level = 0
|
||
}
|
||
var fileSizeMap = {
|
||
0: 'B',
|
||
1: 'KB',
|
||
2: 'MB',
|
||
3: 'GB',
|
||
4: 'TB',
|
||
}
|
||
var handler = function (size, level) {
|
||
if (level >= Object.keys(fileSizeMap).length) {
|
||
return 'the file is too big'
|
||
}
|
||
if (size < 1024) {
|
||
return ''.concat(size).concat(fileSizeMap[level])
|
||
}
|
||
return handler(Math.round(size / 1024), level + 1)
|
||
}
|
||
return handler(size, level)
|
||
}
|
||
var addUrlSearch = function (url, search) {
|
||
var urlObj = new URL(url)
|
||
urlObj.search += (urlObj.search.startsWith('?') ? '&' : '?') + search
|
||
return urlObj.href
|
||
}
|
||
function debounce(fn, wait) {
|
||
var timer = null
|
||
return function () {
|
||
var _this = this
|
||
var args = []
|
||
for (var _i = 0; _i < arguments.length; _i++) {
|
||
args[_i] = arguments[_i]
|
||
}
|
||
if (timer) {
|
||
clearTimeout(timer)
|
||
timer = null
|
||
}
|
||
timer = setTimeout(function () {
|
||
// @ts-ignore
|
||
fn.apply(_this, args)
|
||
}, wait)
|
||
}
|
||
}
|
||
function getOperatingSystem() {
|
||
try {
|
||
var userAgent = navigator.userAgent
|
||
if (userAgent.includes('Windows')) {
|
||
return 'Windows'
|
||
} else if (userAgent.includes('Mac OS')) {
|
||
return 'Mac OS'
|
||
} else if (userAgent.includes('Linux')) {
|
||
return 'Linux'
|
||
} else if (userAgent.includes('Android')) {
|
||
return 'Android'
|
||
} else if (userAgent.includes('iOS')) {
|
||
return 'iOS'
|
||
} else {
|
||
return 'Unknown'
|
||
}
|
||
} catch (_a) {
|
||
return 'Unknown'
|
||
}
|
||
}
|
||
function getBrowserInfo() {
|
||
var browserName = 'Unknown'
|
||
var browserVersion = ''
|
||
try {
|
||
var userAgent = navigator.userAgent
|
||
// 判断是否为Chrome浏览器
|
||
if (userAgent.indexOf('Chrome') !== -1) {
|
||
browserName = 'Chrome'
|
||
var start = userAgent.indexOf('Chrome') + 7
|
||
var end = userAgent.indexOf(' ', start)
|
||
browserVersion = userAgent.substring(start, end)
|
||
}
|
||
// 判断是否为Firefox浏览器
|
||
else if (userAgent.indexOf('Firefox') !== -1) {
|
||
browserName = 'Firefox'
|
||
var start = userAgent.indexOf('Firefox') + 8
|
||
browserVersion = userAgent.substring(start)
|
||
}
|
||
// 判断是否为Safari浏览器
|
||
else if (userAgent.indexOf('Safari') !== -1) {
|
||
browserName = 'Safari'
|
||
var start = userAgent.indexOf('Version') + 8
|
||
var end = userAgent.indexOf(' ', start)
|
||
browserVersion = userAgent.substring(start, end)
|
||
}
|
||
// 判断是否为Edge浏览器
|
||
else if (userAgent.indexOf('Edg') !== -1) {
|
||
browserName = 'Edge'
|
||
var start = userAgent.indexOf('Edg') + 4
|
||
browserVersion = userAgent.substring(start)
|
||
}
|
||
// 判断是否为IE浏览器（IE11及以下版本）
|
||
else if (userAgent.indexOf('MSIE') !== -1) {
|
||
browserName = 'Internet Explorer'
|
||
var start = userAgent.indexOf('MSIE') + 5
|
||
var end = userAgent.indexOf(';', start)
|
||
browserVersion = userAgent.substring(start, end)
|
||
}
|
||
} catch (error) {
|
||
console.error('getBrowserInfo error:', error)
|
||
}
|
||
return {
|
||
name: browserName,
|
||
version: browserVersion,
|
||
}
|
||
}
|
||
|
||
var url = 'https://statistic.live.126.net/statics/report/common/form'
|
||
var HEADER_VALUE_SDK_TYPE = 'NEXKitStatistics'
|
||
var HEADER_VALUE_REPORTER_VERSION = '1.0.0'
|
||
var HEADER_VALUE_CONTENT_TYPE = 'application/json;charset=utf-8'
|
||
var EVENT_REPORT_INTERVAL = 5000
|
||
var MAX_EVENT_CACHE_SIZE = 100
|
||
var LOW_PRIORITY_RETRY = 0
|
||
var NORMAL_PRIORITY_RETRY = 2
|
||
var HIGH_PRIORITY_RETRY = 5
|
||
var MAX_RETRY_COUNT = 3
|
||
var XKitReporter = /** @class */ (function () {
|
||
function XKitReporter(options) {
|
||
this._eventsCache = []
|
||
this._noReport = false // 是否上报数据
|
||
this._configMap = new Map()
|
||
this._retryCount = 0
|
||
var browserInfo = getBrowserInfo()
|
||
var appInfo = window.__XKitReporter__
|
||
var userAgent = ''
|
||
try {
|
||
userAgent = navigator.userAgent
|
||
} catch (_a) {
|
||
console.log('navigator is not defined')
|
||
}
|
||
this.common = {
|
||
imVersion: options.imVersion,
|
||
nertcVersion: options.nertcVersion,
|
||
platform: 'Web',
|
||
osVer: browserInfo.version,
|
||
userAgent: userAgent,
|
||
manufacturer: '',
|
||
model: browserInfo.name,
|
||
packageId:
|
||
(appInfo === null || appInfo === void 0 ? void 0 : appInfo.packageId) ||
|
||
'',
|
||
appVer:
|
||
(appInfo === null || appInfo === void 0 ? void 0 : appInfo.appVer) ||
|
||
'',
|
||
appName:
|
||
(appInfo === null || appInfo === void 0 ? void 0 : appInfo.appName) ||
|
||
'',
|
||
deviceId: options.deviceId,
|
||
}
|
||
this._logger = logDebug$1({
|
||
level: 'debug',
|
||
appName: 'XKitReporter',
|
||
version: '2.0.0',
|
||
})
|
||
}
|
||
XKitReporter.prototype.getConfig = function (appKey) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var _this = this
|
||
return __generator(this, function (_a) {
|
||
return [
|
||
2 /*return*/,
|
||
axios({
|
||
method: 'GET',
|
||
url: 'https://yiyong.netease.im/report_conf',
|
||
headers: {
|
||
platform: 'web',
|
||
appKey: appKey,
|
||
},
|
||
})
|
||
.then(function (res) {
|
||
_this._configMap.set(appKey, res.data)
|
||
})
|
||
.catch(function () {
|
||
_this._retryCount += 1
|
||
if (_this._retryCount > MAX_RETRY_COUNT) {
|
||
_this._retryCount = 0
|
||
return
|
||
}
|
||
_this.getConfig(appKey)
|
||
}),
|
||
]
|
||
})
|
||
})
|
||
}
|
||
XKitReporter.prototype.setNoReport = function (noReport) {
|
||
this._noReport = noReport
|
||
}
|
||
XKitReporter.prototype.reportEvent = function (event, options) {
|
||
// 如果禁止上包则返回
|
||
if (this._noReport) {
|
||
return
|
||
}
|
||
if (this._eventsCache.length >= MAX_EVENT_CACHE_SIZE) {
|
||
this._evictEvent(event)
|
||
} else {
|
||
this._eventsCache.push(event)
|
||
}
|
||
this._scheduleReportEventsTask(
|
||
options === null || options === void 0 ? void 0 : options.immediate
|
||
)
|
||
}
|
||
XKitReporter.prototype._evictEvent = function (event) {
|
||
var index = this._eventsCache.findIndex(function (item) {
|
||
return item.priority < event.priority
|
||
})
|
||
this._eventsCache.push(event)
|
||
if (index !== -1) {
|
||
this._evictEvent(this._eventsCache[index])
|
||
} else {
|
||
this._logger.debug('Full event cache, evict event:', event)
|
||
this._eventsCache = this._eventsCache.filter(function (item) {
|
||
return item !== event
|
||
})
|
||
}
|
||
}
|
||
XKitReporter.prototype._scheduleReportEventsTask = function (immediate) {
|
||
var _this = this
|
||
if (immediate === void 0) {
|
||
immediate = false
|
||
}
|
||
var execute = function () {
|
||
return __awaiter(_this, void 0, void 0, function () {
|
||
var groupByAppKey, _a, _b, _i, appKey, config
|
||
return __generator(this, function (_c) {
|
||
switch (_c.label) {
|
||
case 0:
|
||
groupByAppKey = this._eventsCache.reduce(function (acc, obj) {
|
||
var key = obj.appKey
|
||
if (!acc[key]) {
|
||
acc[key] = []
|
||
}
|
||
acc[key].push(obj)
|
||
return acc
|
||
}, {})
|
||
_a = []
|
||
for (_b in groupByAppKey) _a.push(_b)
|
||
_i = 0
|
||
_c.label = 1
|
||
case 1:
|
||
if (!(_i < _a.length)) return [3 /*break*/, 5]
|
||
appKey = _a[_i]
|
||
if (!!this._configMap.has(appKey)) return [3 /*break*/, 3]
|
||
return [4 /*yield*/, this.getConfig(appKey)]
|
||
case 2:
|
||
_c.sent()
|
||
_c.label = 3
|
||
case 3:
|
||
if (this._configMap.has(appKey)) {
|
||
config = this._configMap.get(appKey)
|
||
if (
|
||
!(config === null || config === void 0
|
||
? void 0
|
||
: config.enabled)
|
||
) {
|
||
return [2 /*return*/]
|
||
}
|
||
}
|
||
this._reportEventsToServer(appKey, groupByAppKey[appKey])
|
||
_c.label = 4
|
||
case 4:
|
||
_i++
|
||
return [3 /*break*/, 1]
|
||
case 5:
|
||
this._eventsCache = []
|
||
return [2 /*return*/]
|
||
}
|
||
})
|
||
})
|
||
}
|
||
if (immediate) {
|
||
execute()
|
||
}
|
||
if (this._queueTimer) {
|
||
return
|
||
}
|
||
this._queueTimer = setInterval(function () {
|
||
if (_this._eventsCache.length === 0) {
|
||
_this._queueTimer && clearInterval(_this._queueTimer)
|
||
_this._queueTimer = undefined
|
||
return
|
||
}
|
||
execute()
|
||
}, EVENT_REPORT_INTERVAL)
|
||
}
|
||
XKitReporter.prototype._determineMaxRetry = function (events) {
|
||
var e_1, _a
|
||
var retry = LOW_PRIORITY_RETRY
|
||
try {
|
||
for (
|
||
var events_1 = __values(events), events_1_1 = events_1.next();
|
||
!events_1_1.done;
|
||
events_1_1 = events_1.next()
|
||
) {
|
||
var event_1 = events_1_1.value
|
||
if (event_1.priority === EventPriority.HIGH) {
|
||
retry = HIGH_PRIORITY_RETRY
|
||
break
|
||
}
|
||
if (event_1.priority === EventPriority.NORMAL) {
|
||
retry = NORMAL_PRIORITY_RETRY
|
||
}
|
||
}
|
||
} catch (e_1_1) {
|
||
e_1 = { error: e_1_1 }
|
||
} finally {
|
||
try {
|
||
if (events_1_1 && !events_1_1.done && (_a = events_1.return))
|
||
_a.call(events_1)
|
||
} finally {
|
||
if (e_1) throw e_1.error
|
||
}
|
||
}
|
||
return retry
|
||
}
|
||
XKitReporter.prototype._reportEventsToServer = function (appKey, events) {
|
||
return __awaiter(this, void 0, void 0, function () {
|
||
var config, groupByEventId, maxRetry, retry, data, networkRequest
|
||
var _this = this
|
||
return __generator(this, function (_a) {
|
||
if (!this._configMap.has(appKey)) {
|
||
return [2 /*return*/]
|
||
}
|
||
config = this._configMap.get(appKey)
|
||
groupByEventId = events.reduce(function (acc, obj) {
|
||
var _a, _b, _c, _d
|
||
if (
|
||
((_a =
|
||
config === null || config === void 0
|
||
? void 0
|
||
: config.blacklist) === null || _a === void 0
|
||
? void 0
|
||
: _a.length) > 0 &&
|
||
((_b =
|
||
config === null || config === void 0
|
||
? void 0
|
||
: config.blacklist) === null || _b === void 0
|
||
? void 0
|
||
: _b.includes(obj.component))
|
||
) {
|
||
return acc
|
||
}
|
||
//blacklist 不包含A，whitelist 为空 ： 允许 A 上报
|
||
if (
|
||
((_c =
|
||
config === null || config === void 0
|
||
? void 0
|
||
: config.whitelist) === null || _c === void 0
|
||
? void 0
|
||
: _c.length) > 0 &&
|
||
!((_d =
|
||
config === null || config === void 0
|
||
? void 0
|
||
: config.whitelist) === null || _d === void 0
|
||
? void 0
|
||
: _d.includes(obj.component))
|
||
) {
|
||
return acc
|
||
}
|
||
var key = obj.eventId
|
||
if (!acc[key]) {
|
||
acc[key] = []
|
||
}
|
||
acc[key].push(
|
||
__assign(__assign({}, obj.data), {
|
||
appKey: obj.appKey,
|
||
component: obj.component,
|
||
version: obj.version,
|
||
framework: obj.framework,
|
||
})
|
||
)
|
||
return acc
|
||
}, {})
|
||
maxRetry = this._determineMaxRetry(events)
|
||
retry = 0
|
||
data = {
|
||
common: this.common,
|
||
event: groupByEventId,
|
||
}
|
||
networkRequest = function () {
|
||
request({
|
||
method: 'POST',
|
||
url: url,
|
||
headers: {
|
||
appkey: appKey,
|
||
sdktype: HEADER_VALUE_SDK_TYPE,
|
||
ver: HEADER_VALUE_REPORTER_VERSION,
|
||
'Content-Type': HEADER_VALUE_CONTENT_TYPE,
|
||
},
|
||
data: data,
|
||
}).catch(function () {
|
||
if (retry <= maxRetry) {
|
||
setTimeout(networkRequest, 2000 * retry)
|
||
} else {
|
||
_this._logger.debug(
|
||
'Failed to report events to server after '.concat(
|
||
retry,
|
||
' retries.'
|
||
),
|
||
data
|
||
)
|
||
}
|
||
retry++
|
||
})
|
||
}
|
||
networkRequest()
|
||
return [2 /*return*/]
|
||
})
|
||
})
|
||
}
|
||
XKitReporter.setAppInfo = function (info) {
|
||
window.__XKitReporter__ = {
|
||
packageId: info === null || info === void 0 ? void 0 : info.packageId,
|
||
appName: info === null || info === void 0 ? void 0 : info.appName,
|
||
appVer: info === null || info === void 0 ? void 0 : info.appVer,
|
||
}
|
||
}
|
||
XKitReporter.getInstance = function (options) {
|
||
if (!options) {
|
||
if (!this.instance) {
|
||
throw new Error('XKitReporter not initialized')
|
||
}
|
||
return this.instance
|
||
}
|
||
if (!this.instance) {
|
||
this.instance = new XKitReporter(options)
|
||
}
|
||
return this.instance
|
||
}
|
||
return XKitReporter
|
||
})()
|
||
var XKitReporter$1 = XKitReporter
|
||
|
||
export {
|
||
EventPriority,
|
||
EventStep,
|
||
EventTracking$1 as EventTracking,
|
||
IntervalEvent,
|
||
ReportEvent,
|
||
index as Storage,
|
||
VisibilityObserver$1 as VisibilityObserver,
|
||
XKitReporter$1 as XKitReporter,
|
||
addUrlSearch,
|
||
createLoggerDecorator,
|
||
debounce,
|
||
frequencyControl,
|
||
getBrowserInfo,
|
||
getFileType,
|
||
getOperatingSystem,
|
||
logDebug$1 as logDebug,
|
||
parseFileSize,
|
||
request,
|
||
}
|