925 lines
29 KiB
JavaScript
925 lines
29 KiB
JavaScript
// Module ID: 1189
|
|
// Function ID: 13568
|
|
// Name: _toPropertyKey
|
|
// Dependencies: []
|
|
|
|
// Module 1189 (_toPropertyKey)
|
|
function _toPropertyKey(arg0) {
|
|
let StringResult = arg0;
|
|
if ("object" === typeof arg0) {
|
|
StringResult = arg0;
|
|
if (arg0) {
|
|
const _Symbol = Symbol;
|
|
if (undefined !== arg0[Symbol.toPrimitive]) {
|
|
const callResult = obj.call(arg0, "string");
|
|
StringResult = callResult;
|
|
if ("object" === typeof callResult) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("@@toPrimitive must return a primitive value.");
|
|
throw typeError;
|
|
}
|
|
} else {
|
|
const _String = String;
|
|
StringResult = String(arg0);
|
|
}
|
|
}
|
|
}
|
|
let text = StringResult;
|
|
if ("symbol" !== typeof StringResult) {
|
|
text = `${tmp}`;
|
|
}
|
|
return text;
|
|
}
|
|
function _createForOfIteratorHelperLoose(@@iterator) {
|
|
let arg1 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
arg1 = tmp;
|
|
}
|
|
let closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
function _arrayLikeToArray(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const ArrayResult = Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
ArrayResult[num] = arg0[num];
|
|
}
|
|
return ArrayResult;
|
|
}
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function _getHash(arg0) {
|
|
let tmp = closure_24[arg0];
|
|
if (null == tmp) {
|
|
const v3Result = importDefault(dependencyMap[11]).v3(arg0);
|
|
closure_24[arg0] = v3Result;
|
|
tmp = v3Result;
|
|
const obj = importDefault(dependencyMap[11]);
|
|
}
|
|
return tmp;
|
|
}
|
|
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]);
|
|
let closure_8 = importDefault(dependencyMap[5]);
|
|
let closure_9 = importDefault(dependencyMap[6]);
|
|
const WebAnalyticsEvents = arg1(dependencyMap[7]).WebAnalyticsEvents;
|
|
const logger = new arg1(dependencyMap[8]).Logger("ApexExperimentStore");
|
|
let tmp3 = "undefined" === typeof window;
|
|
if (!tmp3) {
|
|
const _window = window;
|
|
let tmp5 = null != window.TextEncoder;
|
|
if (tmp5) {
|
|
const _window2 = window;
|
|
tmp5 = null != window.TextDecoder;
|
|
}
|
|
tmp3 = tmp5;
|
|
}
|
|
if (!tmp3) {
|
|
arg1(dependencyMap[9]);
|
|
}
|
|
const items = [arg1(dependencyMap[10]).UnitType.User, arg1(dependencyMap[10]).UnitType.Installation];
|
|
let closure_13 = { user: {}, guild: {}, installation: {} };
|
|
let closure_14 = {};
|
|
let closure_15 = {};
|
|
let closure_16 = {};
|
|
let closure_17 = {};
|
|
let closure_18 = {};
|
|
const set = new Set();
|
|
const set1 = new Set();
|
|
let closure_21 = "apexTrackedExposures";
|
|
let closure_22 = 604800000;
|
|
let closure_23 = {};
|
|
let closure_24 = {};
|
|
const tmp9 = (PersistedStore) => {
|
|
class BaseApexExperimentStore {
|
|
constructor(arg0) {
|
|
self = this;
|
|
items = [...arguments];
|
|
tmp = closure_5(this, BaseApexExperimentStore);
|
|
items1 = [...items];
|
|
obj = closure_8(BaseApexExperimentStore);
|
|
tmp2 = closure_7;
|
|
if (closure_28()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = closure_8;
|
|
constructResult = Reflect.construct(obj, items1, closure_8(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items1);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
tmp2Result.track = () => Promise.resolve();
|
|
tmp2Result.surface = "unset";
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
const arg1 = BaseApexExperimentStore;
|
|
callback2(BaseApexExperimentStore, PersistedStore);
|
|
let obj = {
|
|
key: "loadStoredState",
|
|
value(version, obj) {
|
|
const self = this;
|
|
if (null != version) {
|
|
if (3 === version.version) {
|
|
({ clientOverrides: closure_15, evaluatedExperiments: closure_13 } = version);
|
|
}
|
|
let closure_17 = {};
|
|
for (const key10022 in arg1) {
|
|
let tmp5 = key10022;
|
|
let tmp6 = closure_29;
|
|
let tmp7 = closure_17;
|
|
obj = { -9223372036854775808: true, 0: true, 9223372036854775807: true, 0: true, 9223372036854775807: true, hashedName: closure_29(key10022), variantId: arg1[key10022] };
|
|
closure_17[key10022] = obj;
|
|
}
|
|
let closure_23 = self.loadTrackedExposures();
|
|
}
|
|
let tmp = null != version;
|
|
if (tmp) {
|
|
tmp = 2 === version.version;
|
|
}
|
|
if (tmp) {
|
|
const clientOverrides = version.clientOverrides;
|
|
obj = {};
|
|
const merged = Object.assign(version.evaluatedExperiments);
|
|
obj["installation"] = {};
|
|
}
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ];
|
|
obj = {
|
|
key: "getState",
|
|
value() {
|
|
return { version: 3, evaluatedExperiments: closure_13, clientOverrides: closure_15 };
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "setExperimentAssignments",
|
|
value(arg0, arg1) {
|
|
let assignments;
|
|
let evaluation_id;
|
|
let num;
|
|
let tmp32;
|
|
let tmp33;
|
|
let tmp34;
|
|
let tmp35;
|
|
const self = this;
|
|
if (null == arg0) {
|
|
if (null == arg1) {
|
|
return false;
|
|
}
|
|
}
|
|
const result = self.clearSessionOverrides();
|
|
if (null != arg0) {
|
|
let num2 = 0;
|
|
if (0 < length.length) {
|
|
do {
|
|
let tmp3 = arr[num2];
|
|
let tmp4 = closure_0;
|
|
let tmp5 = closure_2;
|
|
let tmp6 = closure_0(closure_2[10]).UnitTypeToKind[tmp3];
|
|
let tmp7 = arg0.assignments[tmp3];
|
|
let tmp8 = tmp38;
|
|
let tmp9 = tmp39;
|
|
let tmp10 = tmp40;
|
|
let tmp11 = tmp41;
|
|
let tmp12 = tmp42;
|
|
let tmp13 = tmp43;
|
|
let tmp14 = tmp44;
|
|
let tmp15 = tmp45;
|
|
let tmp16 = tmp46;
|
|
let tmp17 = tmp47;
|
|
let tmp18 = tmp48;
|
|
let tmp19 = tmp49;
|
|
if (null != tmp7) {
|
|
tmp8 = tmp38;
|
|
tmp9 = tmp39;
|
|
tmp10 = tmp40;
|
|
tmp11 = tmp41;
|
|
tmp12 = tmp42;
|
|
tmp13 = tmp43;
|
|
tmp14 = tmp44;
|
|
tmp15 = tmp45;
|
|
tmp16 = tmp46;
|
|
tmp17 = tmp47;
|
|
tmp18 = tmp48;
|
|
tmp19 = tmp49;
|
|
if (null != tmp6) {
|
|
let tmp51 = closure_13;
|
|
let tmp52 = closure_13[tmp6];
|
|
let tmp53 = tmp7;
|
|
let tmp24 = tmp39;
|
|
let tmp25 = tmp40;
|
|
let tmp26 = tmp41;
|
|
let tmp27 = tmp42;
|
|
let tmp28 = tmp43;
|
|
let tmp29 = tmp44;
|
|
tmp32 = tmp45;
|
|
tmp33 = tmp46;
|
|
num = tmp47;
|
|
tmp34 = tmp48;
|
|
tmp35 = tmp49;
|
|
tmp8 = tmp52;
|
|
tmp9 = tmp39;
|
|
tmp10 = tmp40;
|
|
tmp11 = tmp41;
|
|
tmp12 = tmp42;
|
|
tmp13 = tmp43;
|
|
tmp14 = tmp44;
|
|
tmp15 = tmp45;
|
|
tmp16 = tmp46;
|
|
tmp17 = tmp47;
|
|
tmp18 = tmp48;
|
|
tmp19 = tmp49;
|
|
let keys = Object.keys();
|
|
if (keys !== undefined) {
|
|
tmp9 = tmp24;
|
|
tmp10 = tmp25;
|
|
tmp11 = tmp26;
|
|
tmp12 = tmp27;
|
|
tmp13 = tmp28;
|
|
tmp14 = tmp29;
|
|
tmp8 = tmp52;
|
|
tmp15 = tmp32;
|
|
tmp16 = tmp33;
|
|
tmp17 = num;
|
|
tmp18 = tmp34;
|
|
tmp19 = tmp35;
|
|
let tmp20 = keys[tmp];
|
|
while (tmp20 !== undefined) {
|
|
let tmp55 = tmp20;
|
|
let tmp56 = closure_20;
|
|
let addResult = closure_20.add(tmp20);
|
|
({ evaluation_id, assignments } = tmp7[tmp20]);
|
|
let obj = {};
|
|
let tmp21;
|
|
if (null != evaluation_id) {
|
|
tmp21 = evaluation_id;
|
|
}
|
|
obj.evaluationId = tmp21;
|
|
obj.assignments = {};
|
|
tmp52[tmp20] = obj;
|
|
let tmp22 = closure_26;
|
|
let tmp23 = closure_26(assignments);
|
|
let iter = tmp23();
|
|
tmp24 = tmp20;
|
|
tmp25 = evaluation_id;
|
|
tmp26 = assignments;
|
|
tmp27 = obj;
|
|
tmp28 = iter;
|
|
tmp29 = tmp23;
|
|
let iter2 = iter;
|
|
if (iter.done) {
|
|
continue;
|
|
} else {
|
|
while (true) {
|
|
let tmp30 = closure_4;
|
|
let tmp31 = closure_4(iter2.value, 5);
|
|
[tmp32, tmp33, num, tmp34, tmp35] = tmp31;
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
obj = { hashedName: tmp32, variantId: tmp33, trackedVariantId: tmp35 };
|
|
let tmp36 = closure_0;
|
|
let tmp37 = closure_2;
|
|
obj.isOverride = num & closure_0(closure_2[10]).ExperimentFlags.IsOverride;
|
|
obj.revision = tmp34;
|
|
obj.exposureTrackingEnabled = num & closure_0(closure_2[10]).ExperimentFlags.ExposureTrackingEnabled;
|
|
obj.useAsEligibility = num & closure_0(closure_2[10]).ExperimentFlags.UseAsEligibility;
|
|
obj.assignments[tmp32] = obj;
|
|
let iter3 = tmp23();
|
|
tmp24 = tmp20;
|
|
tmp25 = evaluation_id;
|
|
tmp26 = assignments;
|
|
tmp27 = obj;
|
|
tmp28 = iter3;
|
|
tmp29 = tmp23;
|
|
iter2 = iter3;
|
|
if (iter3.done) {
|
|
break;
|
|
} else {
|
|
// continue
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
num2 = num2 + 1;
|
|
let tmp38 = tmp8;
|
|
let tmp39 = tmp9;
|
|
let tmp40 = tmp10;
|
|
let tmp41 = tmp11;
|
|
let tmp42 = tmp12;
|
|
let tmp43 = tmp13;
|
|
let tmp44 = tmp14;
|
|
let tmp45 = tmp15;
|
|
let tmp46 = tmp16;
|
|
let tmp47 = tmp17;
|
|
let tmp48 = tmp18;
|
|
let tmp49 = tmp19;
|
|
} while (num2 < arr.length);
|
|
}
|
|
}
|
|
if (null != arg1) {
|
|
const result1 = self.setGuildExperimentAssignments(arg1);
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "setGuildExperimentAssignments",
|
|
value(arg0) {
|
|
let num2;
|
|
let tmp10;
|
|
let tmp11;
|
|
let tmp12;
|
|
let tmp13;
|
|
let obj = arg0;
|
|
if (null == arg0) {
|
|
obj = {};
|
|
}
|
|
const entries = Object.entries(obj);
|
|
for (let num = 0; num < entries.length; num = num + 1) {
|
|
let tmp2 = callback2;
|
|
let tmp3 = callback2(entries[num], 2);
|
|
let tmp4 = tmp3[1];
|
|
let evaluation_id = tmp4.evaluation_id;
|
|
obj = {};
|
|
let tmp5;
|
|
if (null != evaluation_id) {
|
|
tmp5 = evaluation_id;
|
|
}
|
|
obj.evaluationId = tmp5;
|
|
obj.assignments = {};
|
|
tmp[tmp3[0]] = obj;
|
|
let tmp6 = callback5;
|
|
let tmp7 = callback5(tmp4.assignments);
|
|
let iter = tmp7();
|
|
if (!iter.done) {
|
|
do {
|
|
let tmp8 = closure_4;
|
|
let tmp9 = closure_4(iter.value, 5);
|
|
[tmp10, tmp11, num2, tmp12, tmp13] = tmp9;
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
obj = { hashedName: tmp10, variantId: tmp11, trackedVariantId: tmp13 };
|
|
let tmp14 = closure_0;
|
|
let tmp15 = closure_2;
|
|
obj.isOverride = num2 & closure_0(closure_2[10]).ExperimentFlags.IsOverride;
|
|
obj.revision = tmp12;
|
|
obj.exposureTrackingEnabled = num2 & closure_0(closure_2[10]).ExperimentFlags.ExposureTrackingEnabled;
|
|
obj.useAsEligibility = num2 & closure_0(closure_2[10]).ExperimentFlags.UseAsEligibility;
|
|
obj.assignments[tmp10] = obj;
|
|
let iter2 = tmp7();
|
|
let tmp16 = num2;
|
|
iter = iter2;
|
|
let tmp17 = tmp10;
|
|
let tmp18 = tmp11;
|
|
let tmp19 = tmp12;
|
|
let tmp20 = tmp13;
|
|
} while (!iter2.done);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "createOverride",
|
|
value(name, variantId) {
|
|
let obj = {};
|
|
const merged = Object.assign(obj);
|
|
obj = { hashedName: callback7(name), variantId, isOverride: true, exposureTrackingEnabled: false };
|
|
obj[name] = obj;
|
|
const result = this.trackExposureSuppression(name, "client_override");
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "deleteOverride",
|
|
value(arg0) {
|
|
const items = [arg0];
|
|
closure_15 = callback(closure_15, items.map(closure_25));
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "createSessionOverride",
|
|
value(arg0, variantId) {
|
|
let obj = {};
|
|
const merged = Object.assign(obj);
|
|
obj = { hashedName: callback7(arg0), variantId, isOverride: true, exposureTrackingEnabled: false };
|
|
obj[arg0] = obj;
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "deleteSessionOverride",
|
|
value(arg0) {
|
|
const items = [arg0];
|
|
closure_16 = callback(closure_16, items.map(closure_25));
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "setExperimentsMetadata",
|
|
value(arr) {
|
|
const obj = {};
|
|
const merged = Object.assign(obj);
|
|
const merged1 = Object.assign(Object.fromEntries(arr.map((name) => {
|
|
const items = [name.name, name];
|
|
return items;
|
|
})));
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "getExperimentsMetadata",
|
|
value() {
|
|
return closure_18;
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "getClientOverrides",
|
|
value() {
|
|
return closure_15;
|
|
}
|
|
};
|
|
items[11] = {
|
|
key: "getSessionOverrides",
|
|
value() {
|
|
return closure_16;
|
|
}
|
|
};
|
|
items[12] = {
|
|
key: "getExperimentClientOverride",
|
|
value(arg0) {
|
|
return closure_15[arg0];
|
|
}
|
|
};
|
|
items[13] = {
|
|
key: "getExperimentSessionOverride",
|
|
value(arg0) {
|
|
return closure_16[arg0];
|
|
}
|
|
};
|
|
items[14] = {
|
|
key: "handleLogout",
|
|
value(arg0) {
|
|
const self = this;
|
|
if (!arg0) {
|
|
const result = self.clearUserServerAssignments();
|
|
const result1 = self.clearSessionOverrides();
|
|
}
|
|
const Storage = BaseApexExperimentStore(closure_2[12]).Storage;
|
|
Storage.remove(closure_21);
|
|
const result2 = self.clearAllTrackedExposures();
|
|
}
|
|
};
|
|
items[15] = {
|
|
key: "registerExperiment",
|
|
value(name) {
|
|
const self = this;
|
|
closure_14[name.name] = name;
|
|
if (null != closure_17[name.name]) {
|
|
const result = self.trackExposureSuppression(name.name, "cookie_override");
|
|
}
|
|
}
|
|
};
|
|
items[16] = {
|
|
key: "getRegisteredExperiments",
|
|
value() {
|
|
return closure_14;
|
|
}
|
|
};
|
|
items[17] = {
|
|
key: "getAssignment",
|
|
value(arg0, arg1, animateEmoji) {
|
|
const self = this;
|
|
let override = this.getOverride(animateEmoji);
|
|
if (null == override) {
|
|
override = self.getServerAssignment(arg0, arg1, animateEmoji);
|
|
}
|
|
return override;
|
|
}
|
|
};
|
|
items[18] = {
|
|
key: "getServerAssignment",
|
|
value(arg0, arg1, arg2) {
|
|
return null != closure_13[arg0][arg1] ? closure_13[arg0][arg1].assignments[tmp] : undefined;
|
|
}
|
|
};
|
|
items[19] = {
|
|
key: "getEvaluation",
|
|
value(arg0, arg1) {
|
|
let evaluationId;
|
|
if (null != closure_13[arg0][arg1]) {
|
|
evaluationId = tmp.evaluationId;
|
|
}
|
|
return evaluationId;
|
|
}
|
|
};
|
|
items[20] = {
|
|
key: "getEvaluationAndAssignmentInner",
|
|
value(arg0, arg1, animateEmoji) {
|
|
const override = this.getOverride(animateEmoji);
|
|
if (null != override) {
|
|
const items = [undefined, override];
|
|
return items;
|
|
} else {
|
|
if (null == closure_13[arg0][arg1]) {
|
|
const items1 = [undefined, undefined];
|
|
let items2 = items1;
|
|
} else {
|
|
items2 = [tmp5.evaluationId, tmp5.assignments[closure_29(undefined, animateEmoji)]];
|
|
}
|
|
return items2;
|
|
}
|
|
}
|
|
};
|
|
items[21] = {
|
|
key: "getEvaluationAndAssignment",
|
|
value(arg0, arg1, arg2, arg3) {
|
|
let tmp8;
|
|
let LOGGED_OUT_USER_ID_SENTINEL = arg3;
|
|
const self = this;
|
|
const tmp = callback2(this.getEvaluationAndAssignmentInner(arg0, arg1, arg2), 2);
|
|
const first = tmp[0];
|
|
if ("guild" !== arg0) {
|
|
const items = [first, tmp3];
|
|
return items;
|
|
} else {
|
|
if (null == LOGGED_OUT_USER_ID_SENTINEL) {
|
|
LOGGED_OUT_USER_ID_SENTINEL = BaseApexExperimentStore(closure_2[10]).LOGGED_OUT_USER_ID_SENTINEL;
|
|
}
|
|
[r10026, tmp8] = callback2(self.getEvaluationAndAssignmentInner("user", LOGGED_OUT_USER_ID_SENTINEL, arg2), 2);
|
|
if (null == tmp8) {
|
|
const items1 = [undefined, undefined];
|
|
let items6 = items1;
|
|
} else if (tmp8.isOverride) {
|
|
const items2 = [first, tmp8];
|
|
items6 = items2;
|
|
} else if (tmp8.useAsEligibility) {
|
|
if (null == tmp3) {
|
|
const items3 = [undefined, undefined];
|
|
let items5 = items3;
|
|
} else if (null != tmp3.variantId) {
|
|
const items4 = [first, tmp3];
|
|
items5 = items4;
|
|
} else {
|
|
items5 = [undefined, undefined];
|
|
}
|
|
} else {
|
|
items6 = [undefined, undefined];
|
|
}
|
|
return items6;
|
|
}
|
|
}
|
|
};
|
|
items[22] = {
|
|
key: "trackExperimentExposure",
|
|
value(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
const self = this;
|
|
const BaseApexExperimentStore = this;
|
|
const tmp = callback7("" + arg1 + "|" + arg4 + "|" + arg5 + "|" + arg2 + "|" + arg6 + "|1");
|
|
if ("user" === arg3) {
|
|
self.withExposureTracking(tmp, () => self.track(constants.EXPERIMENT_USER_EVALUATION_EXPOSED, { evaluation_id: arg0, experiment: arg1, exposure_location: arg2, unit_type: arg3, tracked_variation_id: arg5 }, { flush: true }));
|
|
} else if ("installation" === arg3) {
|
|
self.withExposureTracking(tmp, () => self.track(constants.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, { evaluation_id: arg0, installation_id: arg6, experiment: arg1, exposure_location: arg2, unit_type: arg3, tracked_variation_id: arg5 }, { flush: true }));
|
|
} else if ("guild" === arg3) {
|
|
self.withExposureTracking(tmp, () => self.track(constants.EXPERIMENT_GUILD_EVALUATION_EXPOSED, { evaluation_id: arg0, guild_id: arg6, experiment: arg1, exposure_location: arg2, unit_type: arg3, tracked_variation_id: arg5, revision: arg4 }, { flush: true }));
|
|
}
|
|
}
|
|
};
|
|
items[23] = {
|
|
key: "trackCommonTriggerPointExposures",
|
|
value(arg0) {
|
|
let done;
|
|
let done2;
|
|
let self = this;
|
|
const BaseApexExperimentStore = arg0;
|
|
self = this;
|
|
function _loop(evaluationId) {
|
|
self.withExposureTracking(callback("" + evaluationId + "|" + evaluationId), () => closure_1.track(constants.EXPERIMENT_USER_EVALUATION_EXPOSED, { evaluation_id: arg0, exposure_location: arg0, unit_type: "user" }, { flush: true }));
|
|
}
|
|
const tmp = callback5(this.evaluationsWithUnitIds("user"));
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let _loopResult = _loop(iter.value.evaluationId);
|
|
let iter2 = tmp();
|
|
iter = iter2;
|
|
done = iter2.done;
|
|
} while (!done);
|
|
}
|
|
function _loop2(evaluationId, unitId) {
|
|
const self = unitId;
|
|
self.withExposureTracking(callback("" + evaluationId + "|" + evaluationId), () => arg1.track(constants.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, { evaluation_id: arg0, exposure_location: arg0, unit_type: "installation", installation_id: arg1 }, { flush: true }));
|
|
}
|
|
const tmp3 = callback5(self.evaluationsWithUnitIds("installation"));
|
|
let iter3 = tmp3();
|
|
if (!iter3.done) {
|
|
do {
|
|
let value = iter3.value;
|
|
let _loop2Result = _loop2(value.evaluationId, value.unitId);
|
|
let iter4 = tmp3();
|
|
iter3 = iter4;
|
|
done2 = iter4.done;
|
|
} while (!done2);
|
|
}
|
|
}
|
|
};
|
|
items[24] = {
|
|
key: "withExposureTracking",
|
|
value: function withExposureTracking(arg0, arg1) {
|
|
const self = this;
|
|
if (this.shouldTrackExposure(arg0)) {
|
|
arg1();
|
|
const _Date = Date;
|
|
closure_23[arg0] = Date.now();
|
|
self.saveTrackedExposures(closure_23);
|
|
}
|
|
}
|
|
};
|
|
items[25] = {
|
|
key: "trackExposureSuppression",
|
|
value: function trackExposureSuppression(name, client_override) {
|
|
const self = this;
|
|
if (null != closure_14[name]) {
|
|
if ("user" === tmp.kind) {
|
|
let obj = { experiment: name, unit_type: tmp.kind, suppression_source: client_override };
|
|
obj = { flush: true };
|
|
self.track(constants.EXPERIMENT_USER_EXPOSURE_SUPPRESSED, obj, obj);
|
|
} else if ("installation" === tmp.kind) {
|
|
const _Object = Object;
|
|
const first = Object.keys(closure_13.installation)[0];
|
|
if (null != first) {
|
|
obj = { experiment: name, unit_type: tmp.kind, suppression_source: client_override, installation_id: first };
|
|
const obj1 = { flush: true };
|
|
self.track(constants.EXPERIMENT_INSTALLATION_EXPOSURE_SUPPRESSED, obj, obj1);
|
|
}
|
|
} else if ("guild" === tmp.kind) {
|
|
const _Object2 = Object;
|
|
const first1 = Object.keys(closure_13.guild)[0];
|
|
if (null != first1) {
|
|
const obj2 = { experiment: name, unit_type: tmp.kind, suppression_source: client_override, guild_id: first1 };
|
|
const obj3 = { flush: true };
|
|
self.track(constants.EXPERIMENT_GUILD_EXPOSURE_SUPPRESSED, obj2, obj3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[26] = {
|
|
key: "evaluationIds",
|
|
value: function evaluationIds(arg0) {
|
|
const values = Object.values(closure_13[arg0]);
|
|
const mapped = values.map((evaluationId) => evaluationId.evaluationId);
|
|
return mapped.filter((arg0) => null != arg0);
|
|
}
|
|
};
|
|
items[27] = {
|
|
key: "evaluationsWithUnitIds",
|
|
value: function evaluationsWithUnitIds(installation) {
|
|
const entries = Object.entries(closure_13[installation]);
|
|
const found = entries.filter((arg0) => {
|
|
let tmp;
|
|
[, tmp] = arg0;
|
|
return null != tmp.evaluationId;
|
|
});
|
|
return found.map((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
return { evaluationId: tmp2.evaluationId, unitId: tmp };
|
|
});
|
|
}
|
|
};
|
|
items[28] = {
|
|
key: "shouldTrackExposure",
|
|
value: function shouldTrackExposure(arg0) {
|
|
let tmp2 = null == tmp;
|
|
if (!tmp2) {
|
|
const _Date = Date;
|
|
tmp2 = Date.now() - tmp > closure_22;
|
|
}
|
|
return tmp2;
|
|
}
|
|
};
|
|
items[29] = {
|
|
key: "loadTrackedExposures",
|
|
value: function loadTrackedExposures() {
|
|
const self = this;
|
|
const Storage = BaseApexExperimentStore(closure_2[12]).Storage;
|
|
const value = Storage.get(closure_21);
|
|
if (null != value) {
|
|
if (2 === value.version) {
|
|
const exposures = value.exposures;
|
|
const _Date = Date;
|
|
let flag = false;
|
|
let flag2 = false;
|
|
const timestamp = Date.now();
|
|
const keys = Object.keys();
|
|
if (keys !== undefined) {
|
|
flag2 = flag;
|
|
while (keys[tmp] !== undefined) {
|
|
let tmp9 = tmp7;
|
|
let tmp10 = closure_22;
|
|
if (timestamp - exposures[tmp7] <= closure_22) {
|
|
continue;
|
|
} else {
|
|
delete r0[r12];
|
|
flag = true;
|
|
// continue
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (flag2) {
|
|
self.saveTrackedExposures(exposures);
|
|
}
|
|
return exposures;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
};
|
|
items[30] = {
|
|
key: "saveTrackedExposures",
|
|
value: function saveTrackedExposures(closure_23) {
|
|
const Storage = BaseApexExperimentStore(closure_2[12]).Storage;
|
|
const result = Storage.set(closure_21, { version: 2, exposures: closure_23 });
|
|
}
|
|
};
|
|
items[31] = {
|
|
key: "clearForTests",
|
|
value: function clearForTests() {
|
|
const result = this.clearAllServerAssignments();
|
|
this.clearAllOverrides();
|
|
const result1 = this.clearAllTrackedExposures();
|
|
set.clear();
|
|
set2.clear();
|
|
}
|
|
};
|
|
items[32] = {
|
|
key: "clearAllServerAssignments",
|
|
value: function clearAllServerAssignments() {
|
|
let closure_13 = { user: {}, guild: {}, installation: {} };
|
|
}
|
|
};
|
|
items[33] = {
|
|
key: "clearUserServerAssignments",
|
|
value: function clearUserServerAssignments() {
|
|
const obj = { user: {}, guild: {}, installation: obj.installation };
|
|
}
|
|
};
|
|
items[34] = {
|
|
key: "clearAllOverrides",
|
|
value: function clearAllOverrides() {
|
|
let closure_15 = {};
|
|
let closure_16 = {};
|
|
let closure_17 = {};
|
|
}
|
|
};
|
|
items[35] = {
|
|
key: "clearSessionOverrides",
|
|
value: function clearSessionOverrides() {
|
|
let closure_16 = {};
|
|
}
|
|
};
|
|
items[36] = {
|
|
key: "clearAllTrackedExposures",
|
|
value: function clearAllTrackedExposures() {
|
|
let closure_23 = {};
|
|
}
|
|
};
|
|
items[37] = {
|
|
key: "getHash",
|
|
value: function getHash(arg0) {
|
|
return callback7(arg0);
|
|
}
|
|
};
|
|
items[38] = {
|
|
key: "handleFetchStart",
|
|
value: function handleFetchStart(arg0) {
|
|
set.add(arg0);
|
|
}
|
|
};
|
|
items[39] = {
|
|
key: "handleFetchSuccess",
|
|
value: function handleFetchSuccess(arg0, arg1) {
|
|
set.delete(arg0);
|
|
set2.add(arg0);
|
|
const result = this.setExperimentAssignments(arg1);
|
|
}
|
|
};
|
|
items[40] = {
|
|
key: "handleFetchFailure",
|
|
value: function handleFetchFailure(arg0) {
|
|
set.delete(arg0);
|
|
set2.add(arg0);
|
|
}
|
|
};
|
|
items[41] = {
|
|
key: "isFetching",
|
|
value: function isFetching(wishlistId) {
|
|
return set.has(wishlistId);
|
|
}
|
|
};
|
|
items[42] = {
|
|
key: "hasLoaded",
|
|
value: function hasLoaded(FRECENCY_AND_FAVORITES_SETTINGS) {
|
|
return set2.has(FRECENCY_AND_FAVORITES_SETTINGS);
|
|
}
|
|
};
|
|
items[43] = {
|
|
key: "getOverride",
|
|
value: function getOverride(animateEmoji) {
|
|
let tmp = closure_16[animateEmoji];
|
|
if (null == tmp) {
|
|
tmp = closure_15[animateEmoji];
|
|
}
|
|
if (null == tmp) {
|
|
tmp = closure_17[animateEmoji];
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
return callback(BaseApexExperimentStore, items);
|
|
}(importDefault(dependencyMap[13]).PersistedStore);
|
|
tmp9.displayName = "ApexExperimentStore";
|
|
tmp9.persistKey = "ApexExperimentStore";
|
|
const result = arg1(dependencyMap[14]).fileFinishedImporting("../discord_common/js/packages/apex/BaseApexExperimentStore.tsx");
|
|
|
|
export default tmp9;
|