599 lines
16 KiB
JavaScript
599 lines
16 KiB
JavaScript
// Metro module 1213 (f1214).
|
|
import _objectWithoutProperties from "./_objectWithoutProperties";
|
|
import { WebAnalyticsEvents } from "./Module505";
|
|
import { Logger } from "./log";
|
|
import * as _Module1214 from "./Module1214";
|
|
import { UnitType, UnitTypeToKind, ExperimentFlags, LOGGED_OUT_USER_ID_SENTINEL } from "./Module1215";
|
|
import MurmurHashV3 from "./MurmurHashV3";
|
|
import Module589 from "./Module589";
|
|
import { Storage } from "./Module595";
|
|
let c1021_7, c1021_8, evaluatedExperiments, c1021_10, clientOverrides, c1021_12, c1021_13, c1021_14, c1021_15, c1021_16, c1021_17, c1021_18, c1021_19, c1021_20;
|
|
const _toPropertyKey = function _toPropertyKey(a0) {
|
|
let r2 = a0;
|
|
if (typeof a0 === "object") {
|
|
r2 = a0;
|
|
if (a0) {
|
|
const r5 = a0[Symbol.toPrimitive];
|
|
if (r5 !== void 0) {
|
|
r2 = r5.call(a0, "string");
|
|
if (typeof r2 === "object") {
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
} else {
|
|
r2 = String(a0);
|
|
}
|
|
}
|
|
}
|
|
let r19 = r2;
|
|
if (typeof r19 !== "symbol") {
|
|
r19 = "" + r2;
|
|
}
|
|
return r19;
|
|
};
|
|
c1021_7 = new Logger("ApexExperimentStore");
|
|
const window2 = globalThis.window;
|
|
if (!(typeof window2 !== "undefined" ? window.TextEncoder != null && window.TextDecoder != null : typeof window2 === "undefined")) {
|
|
_Module1214;
|
|
}
|
|
c1021_8 = [UnitType.User, UnitType.Installation];
|
|
evaluatedExperiments = {
|
|
user: {},
|
|
guild: {},
|
|
installation: {}
|
|
};
|
|
c1021_10 = {};
|
|
clientOverrides = {};
|
|
c1021_12 = {};
|
|
c1021_13 = {};
|
|
c1021_14 = {};
|
|
c1021_15 = new Set();
|
|
c1021_16 = new Set();
|
|
c1021_17 = "apexTrackedExposures";
|
|
c1021_18 = 604800000;
|
|
c1021_19 = {};
|
|
c1021_20 = {};
|
|
class BaseApexExperimentStore extends Module589.PersistedStore {
|
|
static displayName = "ApexExperimentStore";
|
|
static persistKey = "ApexExperimentStore";
|
|
track = () => Promise.resolve();
|
|
surface = "unset";
|
|
loadStoredState(a0, a1) {
|
|
if (a0 != null && a0.version === 3) {
|
|
clientOverrides = a0.clientOverrides;
|
|
evaluatedExperiments = a0.evaluatedExperiments;
|
|
} else if (a0 != null && a0.version === 2) {
|
|
clientOverrides = a0.clientOverrides;
|
|
evaluatedExperiments = {
|
|
...a0.evaluatedExperiments,
|
|
installation: {}
|
|
};
|
|
}
|
|
c1021_13 = {};
|
|
for (const key in a1) {
|
|
let hashedName = c1021_20[key];
|
|
if (hashedName == null) {
|
|
const r33 = MurmurHashV3.v3(key);
|
|
c1021_20[key] = r33;
|
|
hashedName = r33;
|
|
}
|
|
c1021_13[key] = {
|
|
hashedName,
|
|
variantId: a1[key],
|
|
isOverride: true,
|
|
exposureTrackingEnabled: false,
|
|
useAsEligibility: false
|
|
};
|
|
}
|
|
c1021_19 = this.loadTrackedExposures();
|
|
}
|
|
getState() {
|
|
return {
|
|
version: 3,
|
|
evaluatedExperiments,
|
|
clientOverrides
|
|
};
|
|
}
|
|
setExperimentAssignments(a0, a1) {
|
|
if (a0 == null && a1 == null) {
|
|
return false;
|
|
}
|
|
this.clearSessionOverrides();
|
|
if (a0 != null) {
|
|
for (const item of c1021_8) {
|
|
const r58 = UnitTypeToKind[item];
|
|
const r60 = a0.assignments[item];
|
|
if (r60 != null && r58 != null) {
|
|
const r65 = evaluatedExperiments[r58];
|
|
for (const key in r60) {
|
|
c1021_16.add(key);
|
|
const r72 = r60[key];
|
|
let evaluation_id4 = r72.evaluation_id;
|
|
const assignments2 = r72.assignments;
|
|
if (evaluation_id4 == null) {
|
|
evaluation_id4 = void 0;
|
|
}
|
|
const r75 = {
|
|
evaluationId: evaluation_id4,
|
|
assignments: {}
|
|
};
|
|
r65[key] = r75;
|
|
for (const item2 of assignments2) {
|
|
const [r88, variantId, r90, revision2, trackedVariantId, config] = item2;
|
|
let r91 = r90;
|
|
if (r90 == null) {
|
|
r91 = 0;
|
|
}
|
|
const assignments = r75.assignments;
|
|
const r33 = r91;
|
|
assignments[r88] = {
|
|
hashedName: r88,
|
|
variantId,
|
|
trackedVariantId,
|
|
isOverride: !!(r33 & ExperimentFlags.IsOverride),
|
|
revision: revision2,
|
|
exposureTrackingEnabled: !!(r33 & ExperimentFlags.ExposureTrackingEnabled),
|
|
useAsEligibility: !!(r33 & ExperimentFlags.UseAsEligibility),
|
|
config
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (a1 != null) {
|
|
this.setGuildExperimentAssignments(a1);
|
|
}
|
|
return true;
|
|
}
|
|
setGuildExperimentAssignments(a0) {
|
|
let r3 = a0;
|
|
const guild = evaluatedExperiments.guild;
|
|
const r2 = Object;
|
|
if (a0 == null) {
|
|
r3 = {};
|
|
}
|
|
for (const item of r2.entries(r3)) {
|
|
const [r48, r49] = item;
|
|
let evaluation_id4 = r49.evaluation_id;
|
|
const assignments = r49.assignments;
|
|
if (evaluation_id4 == null) {
|
|
evaluation_id4 = void 0;
|
|
}
|
|
const r52 = {
|
|
evaluationId: evaluation_id4,
|
|
assignments: {}
|
|
};
|
|
guild[r48] = r52;
|
|
for (const item2 of assignments) {
|
|
const [r63, variantId, r65, revision2, trackedVariantId] = item2;
|
|
let r66 = r65;
|
|
if (r65 == null) {
|
|
r66 = 0;
|
|
}
|
|
const r22 = r66;
|
|
r52.assignments[r63] = {
|
|
hashedName: r63,
|
|
variantId,
|
|
trackedVariantId,
|
|
isOverride: !!(r22 & ExperimentFlags.IsOverride),
|
|
revision: revision2,
|
|
exposureTrackingEnabled: !!(r22 & ExperimentFlags.ExposureTrackingEnabled),
|
|
useAsEligibility: !!(r22 & ExperimentFlags.UseAsEligibility)
|
|
};
|
|
}
|
|
}
|
|
}
|
|
createOverride(a0, a1) {
|
|
const r1 = {
|
|
...clientOverrides
|
|
};
|
|
let hashedName = c1021_20[a0];
|
|
if (hashedName == null) {
|
|
const r15 = MurmurHashV3.v3(a0);
|
|
c1021_20[a0] = r15;
|
|
hashedName = r15;
|
|
}
|
|
r1[a0] = {
|
|
hashedName,
|
|
variantId: a1,
|
|
isOverride: true,
|
|
exposureTrackingEnabled: false
|
|
};
|
|
clientOverrides = r1;
|
|
this.trackExposureSuppression(a0, "client_override");
|
|
}
|
|
deleteOverride(a0) {
|
|
const r4 = clientOverrides;
|
|
r4[a0];
|
|
clientOverrides = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
|
|
}
|
|
createSessionOverride(a0, a1) {
|
|
const r1 = {
|
|
...c1021_12
|
|
};
|
|
let hashedName = c1021_20[a0];
|
|
if (hashedName == null) {
|
|
const r15 = MurmurHashV3.v3(a0);
|
|
c1021_20[a0] = r15;
|
|
hashedName = r15;
|
|
}
|
|
r1[a0] = {
|
|
hashedName,
|
|
variantId: a1,
|
|
isOverride: true,
|
|
exposureTrackingEnabled: false
|
|
};
|
|
c1021_12 = r1;
|
|
}
|
|
deleteSessionOverride(a0) {
|
|
const r4 = c1021_12;
|
|
r4[a0];
|
|
c1021_12 = _objectWithoutProperties(r4, [a0].map(_toPropertyKey));
|
|
}
|
|
setExperimentsMetadata(a0) {
|
|
c1021_14 = {
|
|
...c1021_14,
|
|
...Object.fromEntries(a0.map((item) => [item.name, item]))
|
|
};
|
|
}
|
|
getExperimentsMetadata() {
|
|
return c1021_14;
|
|
}
|
|
getClientOverrides() {
|
|
return clientOverrides;
|
|
}
|
|
getSessionOverrides() {
|
|
return c1021_12;
|
|
}
|
|
getExperimentClientOverride(a0) {
|
|
return clientOverrides[a0];
|
|
}
|
|
getExperimentSessionOverride(a0) {
|
|
return c1021_12[a0];
|
|
}
|
|
handleLogout(a0) {
|
|
if (!a0) {
|
|
this.clearUserServerAssignments();
|
|
this.clearSessionOverrides();
|
|
}
|
|
Storage.remove(c1021_17);
|
|
this.clearAllTrackedExposures();
|
|
}
|
|
registerExperiment(a0) {
|
|
c1021_10[a0.name] = a0;
|
|
if (c1021_13[a0.name] != null) {
|
|
this.trackExposureSuppression(a0.name, "cookie_override");
|
|
}
|
|
}
|
|
getRegisteredExperiments() {
|
|
return c1021_10;
|
|
}
|
|
getAssignment(a0, a1, a2) {
|
|
let r7 = this.getOverride(a2);
|
|
if (r7 == null) {
|
|
r7 = this.getServerAssignment(a0, a1, a2);
|
|
}
|
|
return r7;
|
|
}
|
|
getServerAssignment(a0, a1, a2) {
|
|
let r3 = c1021_20[a2];
|
|
if (r3 == null) {
|
|
const r11 = MurmurHashV3.v3(a2);
|
|
c1021_20[a2] = r11;
|
|
r3 = r11;
|
|
}
|
|
const r16 = evaluatedExperiments[a0][a1];
|
|
if (r16 != null) {
|
|
return r16.assignments[r3];
|
|
}
|
|
}
|
|
getEvaluation(a0, a1) {
|
|
return evaluatedExperiments[a0][a1]?.evaluationId;
|
|
}
|
|
getEvaluationAndAssignmentInner(a0, a1, a2) {
|
|
let r14;
|
|
const override = this.getOverride(a2);
|
|
if (override != null) {
|
|
return [void 0, override];
|
|
}
|
|
const r12 = evaluatedExperiments[a0][a1];
|
|
if (r12 == null) {
|
|
r14 = [void 0, void 0];
|
|
} else {
|
|
r14 = [r12.evaluationId, ,];
|
|
const assignments = r12.assignments;
|
|
let r16 = c1021_20[a2];
|
|
if (r16 == null) {
|
|
const r22 = MurmurHashV3.v3(a2);
|
|
c1021_20[a2] = r22;
|
|
r16 = r22;
|
|
}
|
|
r14[1] = assignments[r16];
|
|
}
|
|
return r14;
|
|
}
|
|
getEvaluationAndAssignment(a0, a1, a2, a3) {
|
|
const [r14, r15] = this.getEvaluationAndAssignmentInner(a0, a1, a2);
|
|
if (a0 !== "guild") {
|
|
return [r14, r15];
|
|
}
|
|
let r16 = a3;
|
|
const getEvaluationAndAssignmentInner2 = this.getEvaluationAndAssignmentInner;
|
|
if (a3 == null) {
|
|
r16 = LOGGED_OUT_USER_ID_SENTINEL;
|
|
}
|
|
const [, r25] = getEvaluationAndAssignmentInner2.call(this, "user", r16, a2);
|
|
return r25 == null ? [void 0, void 0] : r25.isOverride ? [r14, r25] : r25.useAsEligibility ? r15 == null ? [void 0, void 0] : r15.variantId != null ? [r14, r15] : [void 0, void 0] : [void 0, void 0];
|
|
}
|
|
trackExperimentExposure(evaluation_id, a1, a2, a3, a4, a5, a6) {
|
|
const experiment = a1;
|
|
const exposure_location = a2;
|
|
const unit_type = a3;
|
|
const revision = a4;
|
|
const tracked_variation_id = a5;
|
|
const installation_id = a6;
|
|
const r7 = `${a1}|${a4}|${a5}|${a2}|${a6}|1`;
|
|
let r28 = c1021_20[r7];
|
|
if (r28 == null) {
|
|
const r35 = MurmurHashV3.v3(r7);
|
|
c1021_20[r7] = r35;
|
|
r28 = r35;
|
|
}
|
|
if (a3 === "user") {
|
|
this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
|
|
evaluation_id,
|
|
experiment,
|
|
exposure_location,
|
|
unit_type,
|
|
tracked_variation_id
|
|
}, {
|
|
flush: true
|
|
}));
|
|
} else if (a3 === "installation") {
|
|
this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
|
|
evaluation_id,
|
|
installation_id,
|
|
experiment,
|
|
exposure_location,
|
|
unit_type,
|
|
tracked_variation_id
|
|
}, {
|
|
flush: true
|
|
}));
|
|
} else if (a3 === "guild") {
|
|
this.withExposureTracking(r28, () => this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EVALUATION_EXPOSED, {
|
|
evaluation_id,
|
|
guild_id: installation_id,
|
|
experiment,
|
|
exposure_location,
|
|
unit_type,
|
|
tracked_variation_id,
|
|
revision
|
|
}, {
|
|
flush: true
|
|
}));
|
|
}
|
|
}
|
|
trackCommonTriggerPointExposures(exposure_location2) {
|
|
const _this = this;
|
|
const _loop = function _loop(a0) {
|
|
const evaluation_id2 = a0;
|
|
const r11 = `${a0}|${exposure_location2}`;
|
|
let r13 = c1021_20[r11];
|
|
if (r13 == null) {
|
|
const r20 = MurmurHashV3.v3(r11);
|
|
c1021_20[r11] = r20;
|
|
r13 = r20;
|
|
}
|
|
_this.withExposureTracking(r13, () => _this.track(WebAnalyticsEvents.EXPERIMENT_USER_EVALUATION_EXPOSED, {
|
|
evaluation_id: evaluation_id2,
|
|
exposure_location: exposure_location2,
|
|
unit_type: "user"
|
|
}, {
|
|
flush: true
|
|
}));
|
|
};
|
|
for (const item of this.evaluationsWithUnitIds("user")) {
|
|
_loop(item.evaluationId);
|
|
}
|
|
const _loop2 = function _loop2(a0, installation_id2) {
|
|
const evaluation_id3 = a0;
|
|
const r12 = `${a0}|${exposure_location2}`;
|
|
let r14 = c1021_20[r12];
|
|
if (r14 == null) {
|
|
const r21 = MurmurHashV3.v3(r12);
|
|
c1021_20[r12] = r21;
|
|
r14 = r21;
|
|
}
|
|
_this.withExposureTracking(r14, () => _this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EVALUATION_EXPOSED, {
|
|
evaluation_id: evaluation_id3,
|
|
exposure_location: exposure_location2,
|
|
unit_type: "installation",
|
|
installation_id: installation_id2
|
|
}, {
|
|
flush: true
|
|
}));
|
|
};
|
|
for (const item2 of this.evaluationsWithUnitIds("installation")) {
|
|
_loop2(item2.evaluationId, item2.unitId);
|
|
}
|
|
}
|
|
withExposureTracking(a0, a1) {
|
|
if (this.shouldTrackExposure(a0)) {
|
|
a1();
|
|
c1021_19[a0] = Date.now();
|
|
this.saveTrackedExposures(c1021_19);
|
|
}
|
|
}
|
|
trackExposureSuppression(a0, a1) {
|
|
const r6 = c1021_10[a0];
|
|
if (r6 != null) {
|
|
if (r6.kind === "user") {
|
|
this.track(WebAnalyticsEvents.EXPERIMENT_USER_EXPOSURE_SUPPRESSED, {
|
|
experiment: a0,
|
|
unit_type: r6.kind,
|
|
suppression_source: a1
|
|
}, {
|
|
flush: true
|
|
});
|
|
} else if (r6.kind === "installation") {
|
|
const installation_id3 = Object.keys(evaluatedExperiments.installation)[0];
|
|
if (installation_id3 != null) {
|
|
this.track(WebAnalyticsEvents.EXPERIMENT_INSTALLATION_EXPOSURE_SUPPRESSED, {
|
|
experiment: a0,
|
|
unit_type: r6.kind,
|
|
suppression_source: a1,
|
|
installation_id: installation_id3
|
|
}, {
|
|
flush: true
|
|
});
|
|
}
|
|
} else if (r6.kind === "guild") {
|
|
const guild_id = Object.keys(evaluatedExperiments.guild)[0];
|
|
if (guild_id != null) {
|
|
this.track(WebAnalyticsEvents.EXPERIMENT_GUILD_EXPOSURE_SUPPRESSED, {
|
|
experiment: a0,
|
|
unit_type: r6.kind,
|
|
suppression_source: a1,
|
|
guild_id
|
|
}, {
|
|
flush: true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
evaluationIds(a0) {
|
|
return Object.values(evaluatedExperiments[a0]).map((item) => item.evaluationId).filter((item) => item != null);
|
|
}
|
|
evaluationsWithUnitIds(a0) {
|
|
return Object.entries(evaluatedExperiments[a0]).filter((item) => {
|
|
const [, r13] = item;
|
|
return r13.evaluationId != null;
|
|
}).map((item) => {
|
|
const [unitId, r14] = item;
|
|
return {
|
|
evaluationId: r14.evaluationId,
|
|
unitId
|
|
};
|
|
});
|
|
}
|
|
shouldTrackExposure(a0) {
|
|
const r6 = c1021_19[a0];
|
|
return r6 == null || Date.now() - r6 > c1021_18;
|
|
}
|
|
loadTrackedExposures() {
|
|
let r3;
|
|
const r19 = Storage.get(c1021_17);
|
|
if (r19 != null && r19.version === 2) {
|
|
const exposures = r19.exposures;
|
|
const r11 = Date.now();
|
|
let r2 = false;
|
|
let r27 = false;
|
|
for (const key in exposures) {
|
|
r3 = r2;
|
|
r27 = r3;
|
|
const r30 = r11 - exposures[key];
|
|
r2 = r3;
|
|
if (r30 > c1021_18) {
|
|
delete exposures[key];
|
|
r2 = true;
|
|
}
|
|
}
|
|
r3 = r2;
|
|
r27 = r3;
|
|
if (r27) {
|
|
this.saveTrackedExposures(exposures);
|
|
}
|
|
return exposures;
|
|
}
|
|
return {};
|
|
}
|
|
saveTrackedExposures(a0) {
|
|
try {
|
|
Storage.set(c1021_17, {
|
|
version: 2,
|
|
exposures: a0
|
|
});
|
|
} catch ($e) {
|
|
c1021_7.error("Error saving tracked exposures", $e);
|
|
this.track(WebAnalyticsEvents.EXPERIMENT_SAVE_EXPOSURE_FAILED, {
|
|
module: this.surface,
|
|
call: "ApexExperimentStore.saveTrackedExposures"
|
|
}, {
|
|
flush: true
|
|
});
|
|
}
|
|
}
|
|
clearForTests() {
|
|
this.clearAllServerAssignments();
|
|
this.clearAllOverrides();
|
|
this.clearAllTrackedExposures();
|
|
c1021_15.clear();
|
|
c1021_16.clear();
|
|
}
|
|
clearAllServerAssignments() {
|
|
evaluatedExperiments = {
|
|
user: {},
|
|
guild: {},
|
|
installation: {}
|
|
};
|
|
}
|
|
clearUserServerAssignments() {
|
|
evaluatedExperiments = {
|
|
user: {},
|
|
guild: {},
|
|
installation: evaluatedExperiments.installation
|
|
};
|
|
}
|
|
clearAllOverrides() {
|
|
clientOverrides = {};
|
|
c1021_12 = {};
|
|
c1021_13 = {};
|
|
}
|
|
clearSessionOverrides() {
|
|
c1021_12 = {};
|
|
}
|
|
clearAllTrackedExposures() {
|
|
c1021_19 = {};
|
|
}
|
|
getHash(a0) {
|
|
let r1 = c1021_20[a0];
|
|
if (r1 == null) {
|
|
const r11 = MurmurHashV3.v3(a0);
|
|
c1021_20[a0] = r11;
|
|
r1 = r11;
|
|
}
|
|
return r1;
|
|
}
|
|
handleFetchStart(a0) {
|
|
c1021_15.add(a0);
|
|
}
|
|
handleFetchSuccess(a0, a1) {
|
|
c1021_15.delete(a0);
|
|
c1021_16.add(a0);
|
|
this.setExperimentAssignments(a1);
|
|
}
|
|
handleFetchFailure(a0) {
|
|
c1021_15.delete(a0);
|
|
c1021_16.add(a0);
|
|
}
|
|
isFetching(a0) {
|
|
return c1021_15.has(a0);
|
|
}
|
|
hasLoaded(a0) {
|
|
return c1021_16.has(a0);
|
|
}
|
|
getOverride(a0) {
|
|
let r5 = c1021_12[a0];
|
|
if (r5 == null) {
|
|
r5 = clientOverrides[a0];
|
|
}
|
|
if (r5 == null) {
|
|
r5 = c1021_13[a0];
|
|
}
|
|
return r5;
|
|
}
|
|
}
|
|
export default BaseApexExperimentStore;
|