404 lines
12 KiB
JavaScript
404 lines
12 KiB
JavaScript
// Module ID: 481
|
|
// Function ID: 6192
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: []
|
|
// Exports: analyticsTrackingStoreMaker
|
|
|
|
// Module 481 (_isNativeReflectConstruct)
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function incrementMetric(arg0) {
|
|
let num = arg1;
|
|
if (arg1 === undefined) {
|
|
num = 1;
|
|
}
|
|
return arg0 + num;
|
|
}
|
|
let closure_3 = importDefault(dependencyMap[0]);
|
|
let closure_4 = importDefault(dependencyMap[1]);
|
|
let closure_5 = importDefault(dependencyMap[2]);
|
|
let closure_6 = importDefault(dependencyMap[3]);
|
|
let closure_7 = importDefault(dependencyMap[4]);
|
|
({ TelemetryEndpoints: closure_8, TelemetryEvents: closure_9 } = arg1(dependencyMap[5]));
|
|
({ FREQUENCY: closure_10, MIN_DELAY: closure_11, MAX_DELAY: closure_12 } = {});
|
|
let closure_13 = 1500;
|
|
let closure_14 = 0;
|
|
let closure_15 = 0;
|
|
let closure_16 = 0;
|
|
let closure_17 = 0;
|
|
let closure_18 = 0;
|
|
let closure_19 = null;
|
|
let closure_20 = 0;
|
|
let closure_22 = 0;
|
|
let closure_23 = 0;
|
|
let closure_24 = null;
|
|
let closure_25 = false;
|
|
let closure_26 = null;
|
|
let closure_27 = null;
|
|
let fn = window.requestIdleCallback;
|
|
if (null == fn) {
|
|
fn = (arg0) => {
|
|
const arg1 = arg0;
|
|
return setImmediate(() => arg0());
|
|
};
|
|
}
|
|
const idGenerator = new arg1(dependencyMap[6]).IdGenerator();
|
|
const obj = {
|
|
handleConnectionOpen() {
|
|
|
|
},
|
|
handleConnectionClosed() {
|
|
|
|
},
|
|
handleFingerprint() {
|
|
|
|
},
|
|
handleTrack() {
|
|
|
|
},
|
|
handleSetAnalyticsToken(arg0) {
|
|
|
|
}
|
|
};
|
|
let closure_33 = [];
|
|
let closure_34 = null;
|
|
function defaultGetSessionId() {
|
|
return Promise.resolve({ sessionId: undefined });
|
|
}
|
|
const tmp2 = arg1(dependencyMap[5]);
|
|
const result = arg1(dependencyMap[11]).fileFinishedImporting("../discord_common/js/packages/analytics-utils/AnalyticsTrackingStore.tsx");
|
|
|
|
export const AnalyticsActionHandlers = obj;
|
|
export const analyticsTrackingStoreMaker = (getLaunchSignature) => {
|
|
let actionHandler;
|
|
let dispatcher;
|
|
let drainTimeoutOverride;
|
|
let getSessionId;
|
|
let scheduleWhenIdle;
|
|
({ dispatcher, actionHandler, getFingerprint: closure_0, getSessionId } = getLaunchSignature);
|
|
if (getSessionId === undefined) {
|
|
getSessionId = defaultGetSessionId;
|
|
}
|
|
const importDefault = getSessionId;
|
|
({ TRACKING_URL: closure_2, drainTimeoutOverride, waitFor: closure_3, scheduleWhenIdle } = getLaunchSignature);
|
|
if (scheduleWhenIdle === undefined) {
|
|
scheduleWhenIdle = fn;
|
|
}
|
|
let closure_4 = scheduleWhenIdle;
|
|
const B = getLaunchSignature.getLaunchSignature;
|
|
if (B === undefined) {
|
|
class B {
|
|
constructor() {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
let closure_5 = B;
|
|
const submitEvents = getLaunchSignature.submitEvents;
|
|
function canDrain(AnalyticsTrackingStore, Store) {
|
|
if (0 === arr.length) {
|
|
return tmp;
|
|
} else if (null != closure_29) {
|
|
let tmp5 = null != closure_28;
|
|
} else {
|
|
tmp5 = null != callback();
|
|
}
|
|
}
|
|
function scheduleDrain(shouldFlushOnNextTick) {
|
|
let flag = shouldFlushOnNextTick.shouldFlushOnNextTick;
|
|
if (flag === undefined) {
|
|
flag = false;
|
|
}
|
|
let tmp = null == timerId;
|
|
if (tmp) {
|
|
tmp = canDrain();
|
|
}
|
|
if (tmp) {
|
|
if (flag) {
|
|
const _setTimeout = setTimeout;
|
|
let timerId = setTimeout(drainEventsQueue, 0);
|
|
} else {
|
|
const obj = { timeout: closure_13 };
|
|
timerId = scheduleWhenIdle(drainEventsQueue, obj);
|
|
}
|
|
}
|
|
}
|
|
function drainEventsQueue() {
|
|
let closure_34 = null;
|
|
if (canDrain()) {
|
|
const substr = arr.slice();
|
|
const arr = [];
|
|
closure_20 = callback2(closure_20);
|
|
const _Math = Math;
|
|
closure_21 = Math.min(closure_21, length);
|
|
const _Math2 = Math;
|
|
closure_22 = Math.max(closure_22, length);
|
|
closure_23 = callback2(closure_23, length);
|
|
const promise = submitEventsImmediately(substr);
|
|
promise.then(() => {
|
|
const item = substr.forEach((resolve) => {
|
|
if (null != resolve.resolve) {
|
|
resolve.resolve();
|
|
}
|
|
});
|
|
closure_16 = callback(closure_16);
|
|
}, (body) => {
|
|
const items = [...closure_0];
|
|
unshift.unshift.apply(items);
|
|
closure_17 = callback(closure_17);
|
|
});
|
|
return promise;
|
|
} else {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
function submitEventsImmediately(items, CLIENT_TELEMETRY) {
|
|
let tmp = CLIENT_TELEMETRY;
|
|
const callback = Date.now();
|
|
const mapped = items.map((properties) => {
|
|
let obj = {};
|
|
const merged = Object.assign(properties);
|
|
obj = {};
|
|
const merged1 = Object.assign(properties.properties);
|
|
obj["client_send_timestamp"] = closure_0;
|
|
obj["properties"] = obj;
|
|
return obj;
|
|
});
|
|
if (null != submitEvents) {
|
|
return submitEvents(mapped, closure_28);
|
|
} else {
|
|
if (null == tmp) {
|
|
tmp = closure_2;
|
|
}
|
|
let obj = {};
|
|
const getSessionId = obj;
|
|
if (!closure_25) {
|
|
const v4Result = callback(closure_2[8]).v4();
|
|
obj.x-science-test = v4Result;
|
|
closure_25 = true;
|
|
const obj2 = callback(closure_2[8]);
|
|
}
|
|
const HTTP = callback(closure_2[9]).HTTP;
|
|
obj = { url: tmp };
|
|
obj.headers = obj;
|
|
obj = { token: closure_28, events: mapped };
|
|
obj.body = obj;
|
|
obj.retries = 3;
|
|
obj.rejectWithError = false;
|
|
return HTTP.post(obj).then((headers) => {
|
|
if (obj.x-science-test) {
|
|
let prop;
|
|
if (null != headers) {
|
|
headers = headers.headers;
|
|
if (null != headers) {
|
|
prop = headers.x-science-test;
|
|
}
|
|
}
|
|
let tmp3 = null;
|
|
if (null != prop) {
|
|
tmp3 = prop;
|
|
}
|
|
}
|
|
return headers;
|
|
});
|
|
}
|
|
}
|
|
function sendTelemetryEvent() {
|
|
let obj = { type: drainEventsQueue.CLIENT_TELEMETRY };
|
|
obj = { client_track_timestamp: Date.now(), rpc_success_count: closure_16, rpc_failure_count: closure_17, first_seen_event_sequence_number: closure_18, last_seen_event_sequence_number: closure_14, telemetry_period_start_timestamp: closure_19, telemetry_period_end_timestamp: Date.now(), event_queue_rejection_count: closure_15, event_queue_batch_count: closure_20 };
|
|
let num = 0;
|
|
if (MAX_SAFE_INTEGER !== Number.MAX_SAFE_INTEGER) {
|
|
num = MAX_SAFE_INTEGER;
|
|
}
|
|
obj.event_queue_batch_min_size = num;
|
|
obj.event_queue_batch_max_size = closure_22;
|
|
let num2 = 0;
|
|
if (closure_20 > 0) {
|
|
num2 = closure_23 / closure_20;
|
|
}
|
|
obj.event_queue_batch_avg_size = num2;
|
|
obj.science_request_id = closure_27;
|
|
obj.science_response = closure_26;
|
|
obj.launch_signature = B();
|
|
obj.properties = obj;
|
|
closure_15 = 0;
|
|
closure_16 = 0;
|
|
closure_17 = 0;
|
|
closure_20 = 0;
|
|
closure_22 = 0;
|
|
closure_23 = 0;
|
|
closure_19 = Date.now();
|
|
closure_18 = closure_14;
|
|
const items = [obj];
|
|
return submitEventsImmediately(items, scheduleDrain.CLIENT_TELEMETRY);
|
|
}
|
|
function stopTelemetryHeartbeat() {
|
|
if (null != user) {
|
|
const type = user.type;
|
|
if ("timeout" === type) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(user.id);
|
|
const user = null;
|
|
} else if ("interval" !== type) {
|
|
const type2 = user.type;
|
|
}
|
|
const _clearInterval = clearInterval;
|
|
clearInterval(user.id);
|
|
}
|
|
}
|
|
if (null != drainTimeoutOverride) {
|
|
class B {
|
|
constructor() {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
let closure_13 = 1500;
|
|
obj.handleConnectionOpen = (arg0) => {
|
|
let analyticsToken;
|
|
let user;
|
|
({ analyticsToken, user } = arg0);
|
|
if (null != user.id) {
|
|
const id = user.id;
|
|
}
|
|
function startTelemetryHeartbeat() {
|
|
if (null == obj) {
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
function scheduleNextHeartbeat() {
|
|
const result = 0.1 * closure_10;
|
|
const obj = {
|
|
type: "timeout",
|
|
id: setTimeout(() => {
|
|
callback2();
|
|
callback();
|
|
}, Math.max(closure_10 + (Math.floor(Math.random() * result * 2) - result), closure_11))
|
|
};
|
|
}
|
|
const obj = { type: "timeout" };
|
|
const _setTimeout = setTimeout;
|
|
obj.id = setTimeout(() => {
|
|
callback();
|
|
scheduleNextHeartbeat();
|
|
}, Math.floor(Math.random() * (closure_12 - closure_11) + closure_11));
|
|
}
|
|
}();
|
|
scheduleDrain({ shouldFlushOnNextTick: false });
|
|
return false;
|
|
};
|
|
obj.handleConnectionClosed = () => {
|
|
drainEventsQueue();
|
|
stopTelemetryHeartbeat();
|
|
let closure_28 = null;
|
|
let closure_29 = null;
|
|
return false;
|
|
};
|
|
obj.handleFingerprint = () => {
|
|
drainEventsQueue();
|
|
return false;
|
|
};
|
|
obj.handleTrack = (arg0) => {
|
|
({ event: closure_0, properties: closure_1, flush: closure_2, fingerprint: closure_3, resolve: closure_4 } = arg0);
|
|
getSessionId().then((client_heartbeat_session_id) => {
|
|
let obj = { type: callback, fingerprint: closure_3 };
|
|
obj = { client_track_timestamp: Date.now(), client_heartbeat_session_id: client_heartbeat_session_id.sessionId, event_sequence_number: sum };
|
|
const sum = sum + 1;
|
|
const merged = Object.assign(closure_1);
|
|
obj.properties = obj;
|
|
obj.resolve = closure_4;
|
|
if (null != closure_29) {
|
|
let extractIdResult = closure_29;
|
|
} else {
|
|
let fingerprint = obj.fingerprint;
|
|
if (null == fingerprint) {
|
|
fingerprint = callback();
|
|
}
|
|
extractIdResult = null;
|
|
if (null != fingerprint) {
|
|
extractIdResult = callback(closure_2[7]).extractId(fingerprint);
|
|
const obj3 = callback(closure_2[7]);
|
|
}
|
|
}
|
|
if (null != extractIdResult) {
|
|
obj.properties.client_uuid = closure_31.generate(extractIdResult);
|
|
}
|
|
let arr = arr.push(obj);
|
|
if (arr.length > 10000) {
|
|
closure_15 = callback2(closure_15, arr.length - 10000);
|
|
arr = arr.slice(-10000);
|
|
}
|
|
obj = {};
|
|
if (closure_2) {
|
|
obj.shouldFlushOnNextTick = true;
|
|
let tmp14 = obj;
|
|
} else {
|
|
obj.shouldFlushOnNextTick = false;
|
|
tmp14 = obj;
|
|
}
|
|
closure_8(tmp14);
|
|
});
|
|
return false;
|
|
};
|
|
obj.handleSetAnalyticsToken = (analyticsToken) => {
|
|
analyticsToken = analyticsToken.analyticsToken;
|
|
let tmp = null == analyticsToken;
|
|
if (tmp) {
|
|
tmp = null != analyticsToken;
|
|
}
|
|
if (tmp) {
|
|
const userId = analyticsToken.userId;
|
|
const obj = { shouldFlushOnNextTick: false };
|
|
scheduleDrain(obj);
|
|
}
|
|
return false;
|
|
};
|
|
let tmp = (Store) => {
|
|
class AnalyticsTrackingStore {
|
|
constructor(arg0) {
|
|
self = this;
|
|
items = [...arguments];
|
|
tmp = closure_3(this, AnalyticsTrackingStore);
|
|
items1 = [...items];
|
|
obj = closure_6(AnalyticsTrackingStore);
|
|
tmp2 = closure_5;
|
|
if (closure_36()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = closure_6;
|
|
constructResult = Reflect.construct(obj, items1, closure_6(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items1);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
tmp2Result.submitEventsImmediately = closure_10;
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
canDrain(AnalyticsTrackingStore, Store);
|
|
const items = [
|
|
{
|
|
key: "initialize",
|
|
value: function initialize() {
|
|
const self = this;
|
|
if (null != closure_3) {
|
|
const waitFor = self.waitFor;
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(closure_3, 0);
|
|
HermesBuiltin.apply(items, self);
|
|
}
|
|
}
|
|
}
|
|
];
|
|
return scheduleWhenIdle(AnalyticsTrackingStore, items);
|
|
}(importDefault(dependencyMap[10]).Store);
|
|
tmp.displayName = "AnalyticsTrackingStore";
|
|
tmp = new tmp(dispatcher, actionHandler);
|
|
return tmp;
|
|
};
|