453 lines
13 KiB
TypeScript
453 lines
13 KiB
TypeScript
// Module ID: 7970
|
|
// Function ID: 63449
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [6, 7, 15, 17, 18, 7971, 653, 4016, 3713, 4367, 686, 7972, 566, 2]
|
|
|
|
// Module 7970 (_isNativeReflectConstruct)
|
|
import closure_3 from "ME";
|
|
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
|
|
import _possibleConstructorReturn from "_possibleConstructorReturn";
|
|
import _getPrototypeOf from "_getPrototypeOf";
|
|
import _inherits from "_inherits";
|
|
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
|
|
import ME from "ME";
|
|
import set from "_possibleConstructorReturn";
|
|
|
|
let closure_10;
|
|
let closure_11;
|
|
let closure_9;
|
|
const require = arg1;
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
function updateGiftCode(giftCode) {
|
|
const fromServer = _isNativeReflectConstruct.createFromServer(giftCode);
|
|
const code = fromServer.code;
|
|
if (map.has(code)) {
|
|
const value = map.get(code);
|
|
const result = set(code, value.merge(fromServer));
|
|
} else {
|
|
const result1 = set(code, fromServer);
|
|
if (null != fromServer.expiresAt) {
|
|
const Timeout = require(4016) /* _createForOfIteratorHelperLoose */.Timeout;
|
|
const prototype = Timeout.prototype;
|
|
const timeout = new Timeout();
|
|
closure_12[code] = timeout;
|
|
checkGiftCodeExpiry(code);
|
|
}
|
|
}
|
|
}
|
|
function checkGiftCodeExpiry(code) {
|
|
let closure_0 = code;
|
|
const value = map.get(code);
|
|
if (null != value) {
|
|
if (null != value.expiresAt) {
|
|
const expiresAt = value.expiresAt;
|
|
const valueOfResult = expiresAt.valueOf();
|
|
const diff = valueOfResult - importDefault(3713)().valueOf();
|
|
if (diff <= 0) {
|
|
map.delete(code);
|
|
delete tmp[tmp2];
|
|
tmp6.emitChange();
|
|
} else if (null != dependencyMap[code]) {
|
|
const _Math = Math;
|
|
obj.start(Math.min(closure_10, diff), () => {
|
|
outer1_24(closure_0);
|
|
});
|
|
}
|
|
const obj2 = importDefault(3713)();
|
|
}
|
|
}
|
|
}
|
|
function resolveMessageGiftCodes(message, arg1) {
|
|
let flag = arg1;
|
|
if (arg1 === undefined) {
|
|
flag = false;
|
|
}
|
|
if (flag) {
|
|
if (!set1.has(message.channel_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
let obj = require(4367) /* unambiguousRegex */;
|
|
const isGiftCodeEmbedResult = require(4367) /* unambiguousRegex */.isGiftCodeEmbed(message);
|
|
const findGiftCodes = require(4367) /* unambiguousRegex */.findGiftCodes;
|
|
if (isGiftCodeEmbedResult) {
|
|
let embeds;
|
|
if (null != message) {
|
|
embeds = message.embeds;
|
|
}
|
|
let tmp6;
|
|
if (null != embeds) {
|
|
let url;
|
|
if (null != message) {
|
|
url = message.embeds[0].url;
|
|
}
|
|
tmp6 = url;
|
|
}
|
|
let findGiftCodesResult = findGiftCodes(tmp6);
|
|
} else {
|
|
findGiftCodesResult = findGiftCodes(message.content);
|
|
}
|
|
if (0 !== findGiftCodesResult.length) {
|
|
const item = findGiftCodesResult.forEach((code) => {
|
|
let closure_0 = code;
|
|
let hasItem = outer1_14.includes(code);
|
|
if (!hasItem) {
|
|
hasItem = outer1_16.includes(code);
|
|
}
|
|
if (!hasItem) {
|
|
const obj = { code };
|
|
outer1_26(obj);
|
|
outer1_1(outer1_2[10]).wait(() => {
|
|
const giftCode = outer2_1(outer2_2[11]).resolveGiftCode(closure_0, false, true);
|
|
return giftCode.catch(outer2_11);
|
|
});
|
|
const obj2 = outer1_1(outer1_2[10]);
|
|
}
|
|
});
|
|
}
|
|
return false;
|
|
}
|
|
function handleGiftCodeResolve(code) {
|
|
code = code.code;
|
|
if (!items.includes(code)) {
|
|
items = [];
|
|
const arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
items[arraySpreadResult] = code;
|
|
const sum = arraySpreadResult + 1;
|
|
}
|
|
}
|
|
function handleMessage(message) {
|
|
resolveMessageGiftCodes(message.message, true);
|
|
return false;
|
|
}
|
|
function handleLoadMessages(messages) {
|
|
messages = messages.messages;
|
|
set1.add(messages.channelId);
|
|
const item = messages.forEach((arg0) => {
|
|
outer1_25(arg0, true);
|
|
return false;
|
|
});
|
|
}
|
|
function handleLoadThreadsSuccess(firstMessages) {
|
|
firstMessages = firstMessages.firstMessages;
|
|
if (null == firstMessages) {
|
|
return false;
|
|
} else if (null != firstMessages) {
|
|
const item = firstMessages.forEach((arg0) => {
|
|
outer1_25(arg0);
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
({ AbortCodes: closure_9, MAX_TIMEOUT_MS: closure_10, NOOP_NULL: closure_11 } = ME);
|
|
let closure_12 = {};
|
|
const map = new Map();
|
|
let closure_14 = [];
|
|
let closure_15 = [];
|
|
let closure_16 = [];
|
|
let set = new Set();
|
|
let closure_18 = {};
|
|
let closure_19 = {};
|
|
const set1 = new Set();
|
|
let tmp6 = ((Store) => {
|
|
class GiftCodeStore {
|
|
constructor() {
|
|
self = this;
|
|
tmp = outer1_3(this, GiftCodeStore);
|
|
obj = outer1_6(GiftCodeStore);
|
|
tmp2 = outer1_5;
|
|
if (outer1_22()) {
|
|
tmp6 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp7 = outer1_6;
|
|
tmp8 = arguments;
|
|
constructResult = Reflect.construct(obj, arguments, outer1_6(self).constructor);
|
|
} else {
|
|
tmp3 = arguments;
|
|
tmp4 = arguments;
|
|
constructResult = obj(...arguments);
|
|
}
|
|
return tmp2(self, constructResult);
|
|
}
|
|
}
|
|
callback2(GiftCodeStore, Store);
|
|
let obj = {
|
|
key: "get",
|
|
value(arg0) {
|
|
const value = outer1_13.get(arg0);
|
|
let tmp = null;
|
|
if (null != value) {
|
|
tmp = null;
|
|
if (!value.isExpired()) {
|
|
tmp = value;
|
|
}
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
const items = [obj, , , , , , , , , , ];
|
|
obj = {
|
|
key: "getError",
|
|
value(arg0) {
|
|
let tmp = null;
|
|
if (null != arg0) {
|
|
tmp = outer1_19[arg0];
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "getForGifterSKUAndPlan",
|
|
value(arg0, arg1, arg2) {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
return Array.from(outer1_13.values()).filter((userId) => {
|
|
let tmp = userId.userId === closure_0;
|
|
if (tmp) {
|
|
tmp = userId.skuId === closure_1;
|
|
}
|
|
if (tmp) {
|
|
let tmp5 = null == closure_2;
|
|
if (!tmp5) {
|
|
tmp5 = userId.subscriptionPlanId === closure_2;
|
|
}
|
|
tmp = tmp5;
|
|
}
|
|
if (tmp) {
|
|
tmp = !userId.isExpired();
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "getIsResolving",
|
|
value(arg0) {
|
|
return outer1_14.includes(arg0);
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "getIsResolved",
|
|
value(arg0) {
|
|
return outer1_16.includes(arg0);
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "getIsAccepting",
|
|
value(arg0) {
|
|
return outer1_15.includes(arg0);
|
|
}
|
|
};
|
|
items[6] = {
|
|
key: "getUserGiftCodesFetchingForSKUAndPlan",
|
|
value(skuId, subscriptionPlanId) {
|
|
return outer1_17.has(GiftCodeStore(outer1_2[9]).makeComboId(skuId, subscriptionPlanId));
|
|
}
|
|
};
|
|
items[7] = {
|
|
key: "getUserGiftCodesLoadedAtForSKUAndPlan",
|
|
value(skuId, subscriptionPlanId) {
|
|
const obj = GiftCodeStore(outer1_2[9]);
|
|
return outer1_18[obj.makeComboId(obj, skuId, subscriptionPlanId)];
|
|
}
|
|
};
|
|
items[8] = {
|
|
key: "getResolvingCodes",
|
|
value() {
|
|
return outer1_14;
|
|
}
|
|
};
|
|
items[9] = {
|
|
key: "getResolvedCodes",
|
|
value() {
|
|
return outer1_16;
|
|
}
|
|
};
|
|
items[10] = {
|
|
key: "getAcceptingCodes",
|
|
value() {
|
|
return outer1_15;
|
|
}
|
|
};
|
|
return callback(GiftCodeStore, items);
|
|
})(require("initialize").Store);
|
|
tmp6.displayName = "GiftCodeStore";
|
|
tmp6 = new tmp6(require("dispatcher"), {
|
|
CONNECTION_OPEN: function handleConnectionOpen() {
|
|
set1.clear();
|
|
return false;
|
|
},
|
|
CHANNEL_SELECT: function handleChannelSelect(channelId) {
|
|
channelId = channelId.channelId;
|
|
if (null != channelId) {
|
|
set1.add(channelId);
|
|
}
|
|
return false;
|
|
},
|
|
GIFT_CODE_RESOLVE: handleGiftCodeResolve,
|
|
GIFT_CODE_RESOLVE_SUCCESS: function handleGiftCodeResolveSuccess(giftCode) {
|
|
giftCode = giftCode.giftCode;
|
|
closure_14 = closure_14.filter((arg0) => arg0 !== giftCode.code);
|
|
if (!items.includes(giftCode.code)) {
|
|
items = [];
|
|
const arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
items[arraySpreadResult] = giftCode.code;
|
|
const sum = arraySpreadResult + 1;
|
|
}
|
|
updateGiftCode(giftCode);
|
|
},
|
|
GIFT_CODE_RESOLVE_FAILURE: function handleGiftCodeResolveFailure(code) {
|
|
code = code.code;
|
|
const error = code.error;
|
|
closure_14 = closure_14.filter((arg0) => arg0 !== code);
|
|
if (!items.includes(code)) {
|
|
items = [];
|
|
const arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
items[arraySpreadResult] = code;
|
|
const sum = arraySpreadResult + 1;
|
|
}
|
|
if (null != error) {
|
|
closure_19[code] = error;
|
|
}
|
|
},
|
|
GIFT_CODE_REDEEM: function handleGiftCodeAccept(code) {
|
|
code = code.code;
|
|
if (!items.includes(code)) {
|
|
items = [];
|
|
const arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
items[arraySpreadResult] = code;
|
|
const sum = arraySpreadResult + 1;
|
|
}
|
|
},
|
|
GIFT_CODE_REDEEM_SUCCESS: function handleGiftCodeAcceptSuccess(code) {
|
|
code = code.code;
|
|
closure_15 = closure_15.filter((arg0) => arg0 !== code);
|
|
const value = map.get(code);
|
|
if (null != value) {
|
|
const obj = { redeemed: true, uses: value.uses + 1 };
|
|
const result = map.set(code, value.merge(obj));
|
|
}
|
|
},
|
|
GIFT_CODE_REDEEM_FAILURE: function handleGiftCodeAcceptFailure(code) {
|
|
code = code.code;
|
|
const error = code.error;
|
|
closure_15 = closure_15.filter((arg0) => arg0 !== code);
|
|
const value = map.get(code);
|
|
closure_19[code] = error;
|
|
if (null != value) {
|
|
const code2 = error.code;
|
|
if (constants.UNKNOWN_GIFT_CODE === code2) {
|
|
const result = map.set(code, value.set("revoked", true));
|
|
} else if (constants.INVALID_GIFT_REDEMPTION_EXHAUSTED === code2) {
|
|
const result1 = map.set(code, value.set("uses", value.maxUses));
|
|
}
|
|
}
|
|
},
|
|
GIFT_CODE_REVOKE_SUCCESS: function handleGiftCodeRevoke(code) {
|
|
code = code.code;
|
|
map.delete(code);
|
|
if (null != dependencyMap[code]) {
|
|
obj.stop();
|
|
delete tmp[tmp2];
|
|
}
|
|
if (!items.includes(code)) {
|
|
items = [];
|
|
const arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
items[arraySpreadResult] = code;
|
|
const sum = arraySpreadResult + 1;
|
|
}
|
|
},
|
|
GIFT_CODE_CREATE_SUCCESS: function handleGiftCodeCreate(giftCode) {
|
|
updateGiftCode(giftCode.giftCode);
|
|
},
|
|
GIFT_CODES_FETCH: function handleGiftCodesFetch(arg0) {
|
|
let skuId;
|
|
let subscriptionPlanId;
|
|
({ skuId, subscriptionPlanId } = arg0);
|
|
set.add(require(4367) /* unambiguousRegex */.makeComboId(skuId, subscriptionPlanId));
|
|
},
|
|
GIFT_CODES_FETCH_SUCCESS: function handleGiftCodesFetchSuccess(giftCodes) {
|
|
let skuId;
|
|
let subscriptionPlanId;
|
|
giftCodes = giftCodes.giftCodes;
|
|
({ skuId, subscriptionPlanId } = giftCodes);
|
|
const item = giftCodes.forEach(updateGiftCode);
|
|
const comboId = require(4367) /* unambiguousRegex */.makeComboId(skuId, subscriptionPlanId);
|
|
closure_18[comboId] = Date.now();
|
|
set.delete(comboId);
|
|
},
|
|
GIFT_CODES_FETCH_FAILURE: function handleGiftCodesFetchFail(arg0) {
|
|
let skuId;
|
|
let subscriptionPlanId;
|
|
({ skuId, subscriptionPlanId } = arg0);
|
|
set.delete(require(4367) /* unambiguousRegex */.makeComboId(skuId, subscriptionPlanId));
|
|
},
|
|
MESSAGE_CREATE: handleMessage,
|
|
MESSAGE_UPDATE: handleMessage,
|
|
LOCAL_MESSAGES_LOADED: handleLoadMessages,
|
|
LOAD_MESSAGES_SUCCESS: handleLoadMessages,
|
|
LOAD_MESSAGES_AROUND_SUCCESS: handleLoadMessages,
|
|
LOAD_RECENT_MENTIONS_SUCCESS: function handleLoadRecentMentions(messages) {
|
|
messages = messages.messages;
|
|
const item = messages.forEach((arg0) => {
|
|
outer1_25(arg0);
|
|
return false;
|
|
});
|
|
},
|
|
LOAD_PINNED_MESSAGES_SUCCESS: function handleLoadPinnedMessages(pins) {
|
|
pins = pins.pins;
|
|
const item = pins.forEach((message) => {
|
|
outer1_25(message.message);
|
|
return false;
|
|
});
|
|
},
|
|
SEARCH_MESSAGES_SUCCESS: function handleSearchMessagesSuccess(data) {
|
|
data = data.data;
|
|
let item = data.forEach((messages) => {
|
|
messages = messages.messages;
|
|
let item = messages.forEach((arr) => {
|
|
const item = arr.forEach((arg0) => {
|
|
outer3_25(arg0);
|
|
return false;
|
|
});
|
|
});
|
|
});
|
|
},
|
|
GIFT_CODE_UPDATE: function handleGiftCodeUpdate(code) {
|
|
code = code.code;
|
|
const value = map.get(code);
|
|
if (null != value) {
|
|
const _Math = Math;
|
|
const result = map.set(code, value.set("uses", Math.max(value.uses, code.uses)));
|
|
}
|
|
},
|
|
LOAD_THREADS_SUCCESS: handleLoadThreadsSuccess,
|
|
LOAD_ARCHIVED_THREADS_SUCCESS: handleLoadThreadsSuccess,
|
|
LOAD_FORUM_POSTS: function handleLoadForumPosts(threads) {
|
|
const values = Object.values(threads.threads);
|
|
const mapped = values.map((first_message) => {
|
|
first_message = first_message.first_message;
|
|
let flag = null != first_message;
|
|
if (flag) {
|
|
outer1_25(first_message);
|
|
flag = false;
|
|
}
|
|
return flag;
|
|
});
|
|
}
|
|
});
|
|
let closure_21 = tmp6;
|
|
let result = set.fileFinishedImporting("stores/GiftCodeStore.tsx");
|
|
|
|
export default tmp6;
|