371 lines
13 KiB
TypeScript
371 lines
13 KiB
TypeScript
// Module ID: 13724
|
|
// Function ID: 13725
|
|
// Name: PendingBadgeSettings
|
|
// Dependencies: [32, 1390, 8317, 10579, 584, 8318, 2]
|
|
// Exports: applyPendingBadgeSettings, getPendingProfileBadges, hasPendingBadgeSettings, moveBadgeInDisplayOrder, resetPendingBadgeSettings, setPendingBadgeDisplayOrder, setPendingBadgeHiddenBadges, setPendingBadgeVisibility
|
|
|
|
// Module 13724 (PendingBadgeSettings)
|
|
import DispatcherDefault from "Dispatcher" /* 584 */;
|
|
import BadgeIdResolution from "BadgeIdResolution" /* 8318 */;
|
|
import BadgeUtils from "BadgeUtils" /* 10579 */;
|
|
import _slicedToArray from "_slicedToArray" /* 32 */;
|
|
import UserStore from "UserStore" /* 1390 */;
|
|
import BadgeDirectoryStore from "BadgeDirectoryStore" /* 8317 */;
|
|
import size from "module_2" /* 2 */;
|
|
|
|
let map, owned, set;
|
|
|
|
function getSavedBadgeSettings() {
|
|
const currentUser = UserStore.getCurrentUser();
|
|
let id;
|
|
if (currentUser != null) {
|
|
id = currentUser.id;
|
|
}
|
|
if (null != id) {
|
|
const obj4 = BadgeDirectoryStore;
|
|
if (BadgeDirectoryStore.hasCatalogFor(id)) {
|
|
const items = [];
|
|
const _Set = Set;
|
|
const self = this;
|
|
const self2 = this;
|
|
set = new Set();
|
|
const badges = obj4.getBadges(id);
|
|
for (const item10020 of badges) {
|
|
let tmp8 = item10020;
|
|
let obj2 = BadgeUtils;
|
|
if (!obj2.isPinnedBadge(item10020.badge_id)) {
|
|
if (tmp8.owned) {
|
|
if (tmp8.hidden) {
|
|
let addResult = set.add(tmp8.badge_id);
|
|
} else {
|
|
let arr = items.push(tmp8.badge_id);
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
return { displayOrder: items, hiddenBadges: set };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function applyPendingBadgeSettingsToProfileBadges(items, arg1) {
|
|
let found;
|
|
let pendingBadgeDisplayOrder;
|
|
let pendingBadgeHiddenBadges;
|
|
({ pendingBadgeDisplayOrder, pendingBadgeHiddenBadges } = arg1);
|
|
set = undefined;
|
|
if (null == pendingBadgeDisplayOrder) {
|
|
if (null == pendingBadgeHiddenBadges) {
|
|
items = [];
|
|
HermesBuiltin.arraySpread(items, items, 0);
|
|
return items;
|
|
}
|
|
}
|
|
set = null;
|
|
if (null != pendingBadgeHiddenBadges) {
|
|
const _Set = Set;
|
|
const self2 = this;
|
|
const self = this;
|
|
set = new Set(pendingBadgeHiddenBadges);
|
|
}
|
|
if (null == set) {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items1, items, 0);
|
|
found = items1;
|
|
} else {
|
|
found = items.filter((id) => {
|
|
const obj = BadgeIdResolution;
|
|
const profileBadgeId = obj.resolveProfileBadgeId(id.id);
|
|
let isPinnedBadgeResult = null == profileBadgeId;
|
|
if (!isPinnedBadgeResult) {
|
|
const tmpResult = BadgeUtils;
|
|
isPinnedBadgeResult = tmpResult.isPinnedBadge(profileBadgeId);
|
|
}
|
|
if (!isPinnedBadgeResult) {
|
|
isPinnedBadgeResult = !set.has(profileBadgeId);
|
|
}
|
|
return isPinnedBadgeResult;
|
|
});
|
|
}
|
|
if (null == pendingBadgeDisplayOrder) {
|
|
return found;
|
|
} else {
|
|
const items2 = [];
|
|
const _Map = Map;
|
|
const self3 = this;
|
|
const self4 = this;
|
|
map = new Map();
|
|
for (const item10027 of found) {
|
|
let tmp10 = item10027;
|
|
let tmp11 = set;
|
|
let obj = set(8318);
|
|
let profileBadgeId = obj.resolveProfileBadgeId(item10027.id);
|
|
let tmp14 = profileBadgeId;
|
|
if (null != profileBadgeId) {
|
|
let tmp11Result = tmp11(10579);
|
|
if (!tmp11Result.isPinnedBadge(tmp14)) {
|
|
if (!map.has(tmp14)) {
|
|
let result = map.set(tmp14, tmp10);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
let arr = items2.push(tmp10);
|
|
}
|
|
const items3 = [];
|
|
for (const item10058 of pendingBadgeDisplayOrder) {
|
|
let tmp24 = item10058;
|
|
let value = map.get(item10058);
|
|
if (null != value) {
|
|
let arr2 = items3.push(tmp26);
|
|
let deleteResult = map.delete(tmp24);
|
|
}
|
|
continue;
|
|
}
|
|
const items4 = [];
|
|
const arraySpreadResult5 = HermesBuiltin.arraySpread(items4, items3, HermesBuiltin.arraySpread(items4, items2, 0));
|
|
HermesBuiltin.arraySpread(items4, map.values(), arraySpreadResult5);
|
|
return items4;
|
|
}
|
|
}
|
|
function moveBadgeInDisplayOrder(value, index, clampResult) {
|
|
if (index !== clampResult) {
|
|
if (index >= 0) {
|
|
if (index < value.length) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(items, value, 0);
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
items.splice(Math.min(Math.max(clampResult, 0), items.length), 0, _slicedToArray(items.splice(index, 1), 1)[0]);
|
|
return items;
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
moveBadgeInDisplayOrder.__closure = {};
|
|
moveBadgeInDisplayOrder.__workletHash = 15133920248237;
|
|
moveBadgeInDisplayOrder.__initData = { code: "function moveBadgeInDisplayOrder_PendingBadgeSettingsTsx1(badgeIds,fromIndex,toIndex){if(fromIndex===toIndex||fromIndex<0||fromIndex>=badgeIds.length){return badgeIds;}const next=[...badgeIds];const[moved]=next.splice(fromIndex,1);next.splice(Math.min(Math.max(toIndex,0),next.length),0,moved);return next;}" };
|
|
let result = size.fileFinishedImporting("modules/badges/PendingBadgeSettings.tsx");
|
|
|
|
export const setPendingBadgeDisplayOrder = function setPendingBadgeDisplayOrder(arr) {
|
|
const tmp2 = getSavedBadgeSettings();
|
|
let tmp3 = null != tmp2;
|
|
if (tmp3) {
|
|
const displayOrder = tmp2.displayOrder;
|
|
tmp3 = arr.length === displayOrder.length && arr.every((item, index) => item === displayOrder[index]);
|
|
arr.length === displayOrder.length && arr.every((item, index) => item === displayOrder[index]);
|
|
}
|
|
let tmp6;
|
|
const dispatch = DispatcherDefault.dispatch;
|
|
DispatcherDefault;
|
|
if (!tmp3) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(items, arr, 0);
|
|
tmp6 = items;
|
|
}
|
|
dispatch({ type: "USER_PROFILE_SETTINGS_SET_PENDING_CHANGES", pendingBadgeDisplayOrder: tmp6 });
|
|
};
|
|
export const setPendingBadgeHiddenBadges = function setPendingBadgeHiddenBadges(arr) {
|
|
const tmp2 = getSavedBadgeSettings();
|
|
let tmp3 = null != tmp2;
|
|
if (tmp3) {
|
|
const hiddenBadges = tmp2.hiddenBadges;
|
|
tmp3 = arr.length === hiddenBadges.size && arr.every((item) => hiddenBadges.has(item));
|
|
arr.length === hiddenBadges.size && arr.every((item) => hiddenBadges.has(item));
|
|
}
|
|
let tmp6;
|
|
const dispatch = DispatcherDefault.dispatch;
|
|
DispatcherDefault;
|
|
if (!tmp3) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(items, arr, 0);
|
|
tmp6 = items;
|
|
}
|
|
dispatch({ type: "USER_PROFILE_SETTINGS_SET_PENDING_CHANGES", pendingBadgeHiddenBadges: tmp6 });
|
|
};
|
|
export const setPendingBadgeVisibility = function setPendingBadgeVisibility(badgeId) {
|
|
let found1;
|
|
let hidden;
|
|
let hiddenBadgeIds;
|
|
let reorderableBadgeIds;
|
|
badgeId = badgeId.badgeId;
|
|
({ hidden, reorderableBadgeIds, hiddenBadgeIds } = badgeId);
|
|
if (badgeId.canReorder) {
|
|
let found;
|
|
if (hidden) {
|
|
found = reorderableBadgeIds.filter((item) => item !== badgeId);
|
|
} else {
|
|
const items = [];
|
|
items[HermesBuiltin.arraySpread(items, reorderableBadgeIds, 0)] = badgeId;
|
|
found = items;
|
|
}
|
|
const tmp5 = getSavedBadgeSettings();
|
|
let tmp7 = null != tmp5;
|
|
if (tmp7) {
|
|
const displayOrder = tmp5.displayOrder;
|
|
tmp7 = found.length === displayOrder.length && found.every((item, index) => item === displayOrder[index]);
|
|
found.length === displayOrder.length && found.every((item, index) => item === displayOrder[index]);
|
|
}
|
|
let tmp12;
|
|
const dispatch = DispatcherDefault.dispatch;
|
|
DispatcherDefault;
|
|
if (!tmp7) {
|
|
const items1 = [];
|
|
HermesBuiltin.arraySpread(items1, found, 0);
|
|
tmp12 = items1;
|
|
}
|
|
const obj = { type: "USER_PROFILE_SETTINGS_SET_PENDING_CHANGES", pendingBadgeDisplayOrder: tmp12 };
|
|
dispatch(obj);
|
|
}
|
|
if (hidden) {
|
|
const items2 = [];
|
|
items2[HermesBuiltin.arraySpread(items2, hiddenBadgeIds, 0)] = badgeId;
|
|
found1 = items2;
|
|
} else {
|
|
found1 = hiddenBadgeIds.filter((item) => item !== badgeId);
|
|
}
|
|
const tmp19 = getSavedBadgeSettings();
|
|
let tmp20 = null != tmp19;
|
|
if (tmp20) {
|
|
const hiddenBadges = tmp19.hiddenBadges;
|
|
tmp20 = found1.length === hiddenBadges.size && found1.every((item) => hiddenBadges.has(item));
|
|
found1.length === hiddenBadges.size && found1.every((item) => hiddenBadges.has(item));
|
|
}
|
|
let tmp23;
|
|
const dispatch2 = DispatcherDefault.dispatch;
|
|
DispatcherDefault;
|
|
if (!tmp20) {
|
|
const items3 = [];
|
|
HermesBuiltin.arraySpread(items3, found1, 0);
|
|
tmp23 = items3;
|
|
}
|
|
dispatch2({ type: "USER_PROFILE_SETTINGS_SET_PENDING_CHANGES", pendingBadgeHiddenBadges: tmp23 });
|
|
};
|
|
export const resetPendingBadgeSettings = function resetPendingBadgeSettings() {
|
|
const obj = DispatcherDefault;
|
|
obj.dispatch({ type: "USER_PROFILE_SETTINGS_SET_PENDING_CHANGES", pendingBadgeDisplayOrder: "code", pendingBadgeHiddenBadges: "top" });
|
|
};
|
|
export const hasPendingBadgeSettings = function hasPendingBadgeSettings(pendingBadgeDisplayOrder) {
|
|
return undefined !== pendingBadgeDisplayOrder.pendingBadgeDisplayOrder || undefined !== pendingBadgeDisplayOrder.pendingBadgeHiddenBadges;
|
|
};
|
|
export const applyPendingBadgeSettings = function applyPendingBadgeSettings(stateFromStoresArray, arg1) {
|
|
let mapped;
|
|
let pendingBadgeDisplayOrder;
|
|
let pendingBadgeHiddenBadges;
|
|
({ pendingBadgeDisplayOrder, pendingBadgeHiddenBadges } = arg1);
|
|
set = null;
|
|
if (null != pendingBadgeHiddenBadges) {
|
|
const _Set = Set;
|
|
const self2 = this;
|
|
const self = this;
|
|
set = new Set(pendingBadgeHiddenBadges);
|
|
}
|
|
if (null == set) {
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(items, stateFromStoresArray, 0);
|
|
mapped = items;
|
|
} else {
|
|
mapped = stateFromStoresArray.map((badge_id) => {
|
|
let tmp = badge_id;
|
|
const obj = BadgeUtils;
|
|
if (!obj.isPinnedBadge(badge_id.badge_id)) {
|
|
const obj2 = { hidden: set.has(badge_id.badge_id) };
|
|
const merged = Object.assign(badge_id);
|
|
tmp = obj2;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
if (null == pendingBadgeDisplayOrder) {
|
|
return mapped;
|
|
} else {
|
|
const items1 = [];
|
|
const _Map = Map;
|
|
const self3 = this;
|
|
const self4 = this;
|
|
map = new Map();
|
|
for (const item10026 of mapped) {
|
|
let tmp9 = item10026;
|
|
let obj = set(10579);
|
|
if (obj.isPinnedBadge(item10026.badge_id)) {
|
|
let arr = items1.push(tmp9);
|
|
} else {
|
|
let result = map.set(tmp9.badge_id, tmp9);
|
|
}
|
|
continue;
|
|
}
|
|
const items2 = [];
|
|
for (const item10048 of pendingBadgeDisplayOrder) {
|
|
let tmp18 = item10048;
|
|
let value = map.get(item10048);
|
|
if (null != value) {
|
|
let arr2 = items2.push(tmp20);
|
|
let deleteResult = map.delete(tmp18);
|
|
}
|
|
continue;
|
|
}
|
|
const items3 = [];
|
|
const arraySpreadResult3 = HermesBuiltin.arraySpread(items3, items2, HermesBuiltin.arraySpread(items3, items1, 0));
|
|
HermesBuiltin.arraySpread(items3, map.values(), arraySpreadResult3);
|
|
return items3;
|
|
}
|
|
};
|
|
export const getPendingProfileBadges = function getPendingProfileBadges(arr, stateFromStoresArray, arg2) {
|
|
let pendingBadgeDisplayOrder;
|
|
let pendingBadgeHiddenBadges;
|
|
({ pendingBadgeDisplayOrder, pendingBadgeHiddenBadges } = arg2);
|
|
if (null == pendingBadgeHiddenBadges) {
|
|
return applyPendingBadgeSettingsToProfileBadges(arr, arg2);
|
|
} else {
|
|
const _Set = Set;
|
|
const self3 = this;
|
|
const self4 = this;
|
|
set = new Set(arr.map((id) => {
|
|
const obj = set(_Set31[5]);
|
|
return obj.resolveProfileBadgeId(id.id);
|
|
}));
|
|
const _Set2 = Set;
|
|
const self5 = this;
|
|
const self6 = this;
|
|
const set1 = new Set(pendingBadgeHiddenBadges);
|
|
const _Set3 = Set;
|
|
if (pendingBadgeDisplayOrder == null) {
|
|
pendingBadgeDisplayOrder = [];
|
|
}
|
|
const self = this;
|
|
const self2 = this;
|
|
const _Set31 = new _Set3(pendingBadgeDisplayOrder);
|
|
const found = stateFromStoresArray.filter((owned) => {
|
|
owned = owned.owned;
|
|
if (owned) {
|
|
let flag = owned.hidden;
|
|
if (flag == null) {
|
|
flag = false;
|
|
}
|
|
if (!flag) {
|
|
flag = _Set31.has(owned.badge_id);
|
|
}
|
|
owned = flag;
|
|
}
|
|
if (owned) {
|
|
owned = !set1.has(owned.badge_id);
|
|
}
|
|
if (owned) {
|
|
owned = !set.has(owned.badge_id);
|
|
}
|
|
return owned;
|
|
});
|
|
const mapped = found.map((badge_id) => {
|
|
const obj = set(_Set31[5]);
|
|
const result = obj.toProfileBadgeLegacyId(badge_id.badge_id);
|
|
return { id: result, icon: result, iconSrc: badge_id.simple_icon_raster_url, description: badge_id.name };
|
|
});
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(items, mapped, HermesBuiltin.arraySpread(items, arr, 0));
|
|
return applyPendingBadgeSettingsToProfileBadges(items, arg2);
|
|
}
|
|
};
|
|
export { applyPendingBadgeSettingsToProfileBadges };
|
|
export { moveBadgeInDisplayOrder };
|