561 lines
20 KiB
TypeScript
561 lines
20 KiB
TypeScript
// Module ID: 9557
|
|
// Function ID: 74545
|
|
// Name: _createForOfIteratorHelperLoose
|
|
// Dependencies: [5, 57, 31, 1838, 3948, 4971, 1850, 5035, 5036, 653, 566, 9558, 3804, 4467, 8204, 4800, 4023, 1212, 3764, 9541, 9559, 2]
|
|
// Exports: useFetchStickerPack, useFilteredStickerPackCategories, useHasSendableSticker, useLatestFrecentStickers, useShouldAnimateSticker, useStickerForRenderableSticker, useStickersGrid
|
|
|
|
// Module 9557 (_createForOfIteratorHelperLoose)
|
|
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
|
|
import _slicedToArray from "_slicedToArray";
|
|
import result from "result";
|
|
import _createForOfIteratorHelperLoose from "_createForOfIteratorHelperLoose";
|
|
import closure_7 from "_isNativeReflectConstruct";
|
|
import closure_8 from "_isNativeReflectConstruct";
|
|
import closure_9 from "_isNativeReflectConstruct";
|
|
import closure_10 from "_isNativeReflectConstruct";
|
|
import closure_11 from "_isNativeReflectConstruct";
|
|
import { Permissions } from "ME";
|
|
|
|
let require = arg1;
|
|
function _createForOfIteratorHelperLoose(iterable) {
|
|
let closure_0 = iterable;
|
|
iterable = "undefined" !== typeof Symbol;
|
|
if (iterable) {
|
|
const _Symbol = Symbol;
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (!iterable) {
|
|
iterable = iterable[Symbol.iterator];
|
|
}
|
|
if (iterable) {
|
|
const iter = iterable.call(iterable);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = iterable;
|
|
if (!Array.isArray(iterable)) {
|
|
let tmp2;
|
|
if (iterable) {
|
|
if ("string" === typeof iterable) {
|
|
tmp2 = _arrayLikeToArray(iterable, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(iterable).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = iterable.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(iterable, undefined);
|
|
} else {
|
|
let obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(iterable);
|
|
const callResult = toString.call(iterable);
|
|
tmp3 = "Object" === substr && iterable.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) {
|
|
closure_0 = tmp;
|
|
}
|
|
let c1 = 0;
|
|
return () => {
|
|
if (closure_1 >= length.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = length[+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 useFetchStickerPacks() {
|
|
const effect = React.useEffect(() => {
|
|
const stickerPacks = outer1_0(outer1_2[11]).fetchStickerPacks();
|
|
}, []);
|
|
}
|
|
function useFavoriteStickerIds() {
|
|
let stickerIds;
|
|
const favoriteStickers = require(9541) /* useFrecencySettings */.useFrecencySettings().favoriteStickers;
|
|
if (null != favoriteStickers) {
|
|
stickerIds = favoriteStickers.stickerIds;
|
|
}
|
|
if (null == stickerIds) {
|
|
stickerIds = closure_13;
|
|
}
|
|
return stickerIds;
|
|
}
|
|
function useFavoriteStickers() {
|
|
let tmp = useFavoriteStickerIds();
|
|
const require = tmp;
|
|
const items = [closure_11];
|
|
const items1 = [tmp];
|
|
return require(566) /* initialize */.useStateFromStoresArray(items, () => {
|
|
const mapped = tmp.map((arg0) => outer2_11.getStickerById(arg0));
|
|
return mapped.filter((body) => {
|
|
let tmp = null != body;
|
|
if (tmp) {
|
|
let result = !callback(outer2_2[13]).isGuildSticker(body);
|
|
if (!result) {
|
|
result = callback(outer2_2[13]).isAvailableGuildSticker(body);
|
|
const obj2 = callback(outer2_2[13]);
|
|
}
|
|
tmp = result;
|
|
const obj = callback(outer2_2[13]);
|
|
}
|
|
return tmp;
|
|
});
|
|
}, items1);
|
|
}
|
|
function useLatestFrecentStickerIds() {
|
|
const frecencySettings = require(9541) /* useFrecencySettings */.useFrecencySettings();
|
|
let keys = closure_13;
|
|
let stickers;
|
|
if (null != frecencySettings) {
|
|
const stickerFrecency = frecencySettings.stickerFrecency;
|
|
if (null != stickerFrecency) {
|
|
stickers = stickerFrecency.stickers;
|
|
}
|
|
}
|
|
if (null != stickers) {
|
|
let stickers1;
|
|
if (null != frecencySettings) {
|
|
const stickerFrecency2 = frecencySettings.stickerFrecency;
|
|
if (null != stickerFrecency2) {
|
|
stickers1 = stickerFrecency2.stickers;
|
|
}
|
|
}
|
|
keys = Object.keys(stickers1);
|
|
}
|
|
return keys;
|
|
}
|
|
function useStickerPackCategories(channel) {
|
|
const _require = channel;
|
|
let tmp = useFavoriteStickers();
|
|
const importAll = tmp;
|
|
let items = [closure_11, closure_10];
|
|
const stateFromStoresObject = _require(packs[10]).useStateFromStoresObject(items, () => ({ packs: outer1_11.getPremiumPacks(), frequentlyUsedStickers: outer1_10.stickerFrecencyWithoutFetchingLatest.frequently }), []);
|
|
packs = stateFromStoresObject.packs;
|
|
const frequentlyUsedStickers = stateFromStoresObject.frequentlyUsedStickers;
|
|
let obj = _require(packs[10]);
|
|
let items1 = [closure_9];
|
|
let stateFromStores = _require(packs[10]).useStateFromStores(items1, () => outer1_9.getCurrentUser());
|
|
let tmp4 = (function useGuildStickerCategories(channel) {
|
|
let items = [outer1_11];
|
|
const stateFromStores = channel(packs[10]).useStateFromStores(items, () => outer2_11.getAllGuildStickers());
|
|
let obj = channel(packs[10]);
|
|
const items1 = [outer1_8, outer1_6];
|
|
const stateFromStoresArray = channel(packs[10]).useStateFromStoresArray(items1, () => {
|
|
const flattenedGuildIds = outer2_8.getFlattenedGuildIds();
|
|
const items = [];
|
|
const item = flattenedGuildIds.forEach((guildId) => {
|
|
const guild = outer3_6.getGuild(guildId);
|
|
if (null != guild) {
|
|
items.push(guild);
|
|
}
|
|
});
|
|
return items;
|
|
}, []);
|
|
const obj2 = channel(packs[10]);
|
|
const items2 = [outer1_9];
|
|
const stateFromStores1 = channel(packs[10]).useStateFromStores(items2, () => outer2_9.getCurrentUser());
|
|
const items3 = [stateFromStores, stateFromStoresArray, stateFromStores1, channel];
|
|
return tmp4.useMemo(() => {
|
|
let iter2;
|
|
const items = [];
|
|
const tmp = outer2_14(stateFromStoresArray);
|
|
let iter = tmp();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
let id = value.id;
|
|
let tmp2 = stateFromStores;
|
|
value = stateFromStores.get(id);
|
|
let tmp3 = null != value && 0 !== value.length;
|
|
if (tmp3) {
|
|
let obj = {};
|
|
let tmp4 = store;
|
|
let tmp5 = packs;
|
|
obj.type = store(packs[15]).StickerCategoryTypes.GUILD;
|
|
obj.id = id;
|
|
obj.name = value.name;
|
|
obj.stickers = value;
|
|
let arr = items.push(obj);
|
|
}
|
|
iter2 = tmp();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
let guildId;
|
|
if (null != store) {
|
|
guildId = store.getGuildId();
|
|
}
|
|
if (null != guildId) {
|
|
const guild = outer2_6.getGuild(store.getGuildId());
|
|
const findIndexResult = items.findIndex((id) => id.id === outer1_0.getGuildId());
|
|
if (findIndexResult >= 1) {
|
|
items.unshift(items.splice(findIndexResult, 1)[0]);
|
|
} else {
|
|
if (tmp9) {
|
|
obj = { type: store(packs[15]).StickerCategoryTypes.EMPTY_GUILD_UPSELL };
|
|
({ id: obj2.id, name: obj2.name } = guild);
|
|
obj.stickers = [];
|
|
items.unshift(obj);
|
|
}
|
|
tmp9 = -1 === findIndexResult && null != guild && obj5.getManageResourcePermissions(guild).canManageAllExpressions;
|
|
}
|
|
if (null != stateFromStores1) {
|
|
obj = { permission: outer2_12.USE_EXTERNAL_EMOJIS, user: stateFromStores1, context: store };
|
|
stateFromStores(packs[18]).can(obj);
|
|
const obj3 = stateFromStores(packs[18]);
|
|
}
|
|
obj5 = store(packs[14]);
|
|
}
|
|
return items;
|
|
}, items3);
|
|
})(channel);
|
|
const React = tmp4;
|
|
let items2 = [packs, tmp, frequentlyUsedStickers, tmp4, stateFromStores, channel];
|
|
return React.useMemo(() => {
|
|
let found;
|
|
const mapped = packs.map(channel(packs[13]).createStickerPackCategory);
|
|
let obj = { type: channel(packs[15]).StickerCategoryTypes.FAVORITE, id: channel(packs[15]).StickerCategoryTypes.FAVORITE };
|
|
const intl = channel(packs[17]).intl;
|
|
obj.name = intl.string(channel(packs[17]).t.y3LQCG);
|
|
obj.stickers = closure_1;
|
|
const items = [obj, ];
|
|
obj = { type: channel(packs[15]).StickerCategoryTypes.RECENT, id: channel(packs[15]).StickerCategoryTypes.RECENT };
|
|
const intl2 = channel(packs[17]).intl;
|
|
obj.name = intl2.string(channel(packs[17]).t["6hjpXW"]);
|
|
if (null != frequentlyUsedStickers) {
|
|
found = frequentlyUsedStickers.filter((guild_id) => {
|
|
const callback = guild_id;
|
|
if (obj.isGuildSticker(guild_id)) {
|
|
const stickersByGuildId = outer2_11.getStickersByGuildId(guild_id.guild_id);
|
|
let someResult;
|
|
if (null != stickersByGuildId) {
|
|
someResult = stickersByGuildId.some((id) => id.id === guild_id.id);
|
|
}
|
|
let tmp8 = null != someResult && someResult;
|
|
if (tmp8) {
|
|
const stickerSendability = callback(packs[20]).getStickerSendability(guild_id, outer1_4, outer1_0);
|
|
tmp8 = stickerSendability !== callback(packs[20]).StickerSendability.NONSENDABLE;
|
|
const obj4 = callback(packs[20]);
|
|
}
|
|
let someResult1 = tmp8;
|
|
} else {
|
|
if (obj2.isStandardSticker(guild_id)) {
|
|
someResult1 = outer1_2.some((id) => id.id === guild_id.pack_id);
|
|
}
|
|
obj2 = callback(packs[13]);
|
|
}
|
|
return someResult1;
|
|
});
|
|
}
|
|
if (null == found) {
|
|
found = [];
|
|
}
|
|
obj.stickers = found;
|
|
items[1] = obj;
|
|
HermesBuiltin.arraySpread(mapped, HermesBuiltin.arraySpread(result, 2));
|
|
return items;
|
|
}, items2);
|
|
}
|
|
let closure_13 = [];
|
|
let result = require("result").fileFinishedImporting("modules/stickers/StickersHooks.tsx");
|
|
|
|
export const useFetchStickerPack = function useFetchStickerPack(pack_id) {
|
|
const _require = pack_id;
|
|
useFetchStickerPacks();
|
|
const items = [closure_11];
|
|
const stateFromStores = _require(566).useStateFromStores(items, () => outer1_11.hasLoadedStickerPacks);
|
|
const items1 = [pack_id, stateFromStores];
|
|
const effect = React.useEffect(() => {
|
|
let tmp = stateFromStores;
|
|
if (stateFromStores) {
|
|
tmp = null == outer1_11.getStickerPack(pack_id);
|
|
}
|
|
if (tmp) {
|
|
const stickerPack = pack_id(outer1_2[11]).fetchStickerPack(pack_id);
|
|
const obj = pack_id(outer1_2[11]);
|
|
}
|
|
}, items1);
|
|
};
|
|
export const useShouldAnimateSticker = function useShouldAnimateSticker(isFocused) {
|
|
const AnimateStickers = require(3804) /* explicitContentFromProto */.AnimateStickers;
|
|
const setting = AnimateStickers.useSetting();
|
|
return require(4467) /* getStickerPackPreviewSticker */.shouldAnimateSticker(setting, isFocused);
|
|
};
|
|
export const useStickersGrid = function useStickersGrid(collapsedStickersCategories) {
|
|
collapsedStickersCategories = collapsedStickersCategories.collapsedStickersCategories;
|
|
const filteredStickers = collapsedStickersCategories.filteredStickers;
|
|
let num = collapsedStickersCategories.listPaddingRight;
|
|
if (num === undefined) {
|
|
num = 0;
|
|
}
|
|
let num2 = collapsedStickersCategories.listWidth;
|
|
if (num2 === undefined) {
|
|
num2 = 0;
|
|
}
|
|
let num3 = collapsedStickersCategories.stickerNodeMargin;
|
|
if (num3 === undefined) {
|
|
num3 = 0;
|
|
}
|
|
const stickerNodeWidth = collapsedStickersCategories.stickerNodeWidth;
|
|
const stickersCategories = collapsedStickersCategories.stickersCategories;
|
|
let items = [collapsedStickersCategories, filteredStickers, num, num2, num3, stickerNodeWidth, stickersCategories];
|
|
return stickerNodeWidth.useMemo(() => {
|
|
let iter2;
|
|
let stickers;
|
|
let type;
|
|
function addGridSection(sendable, SEARCH_RESULTS, arg2) {
|
|
let flag = arg2;
|
|
let closure_0 = SEARCH_RESULTS;
|
|
if (arg2 === undefined) {
|
|
flag = false;
|
|
}
|
|
let obj = collapsedStickersCategories(num[13]);
|
|
let guild;
|
|
if (obj.isGuildSticker(sendable[0])) {
|
|
guild = stickersCategories.getGuild(sendable[0].guild_id);
|
|
}
|
|
const guildId = outer2_7.getGuildId();
|
|
const obj2 = collapsedStickersCategories(num[14]);
|
|
let canCreateExpressions = null != guild;
|
|
const findIndexResult = c6.findIndex((type) => type.type === collapsedStickersCategories(num[15]).StickerCategoryTypes.FAVORITE);
|
|
if (canCreateExpressions) {
|
|
canCreateExpressions = guildId === guild.id;
|
|
}
|
|
if (canCreateExpressions) {
|
|
canCreateExpressions = obj2.getManageResourcePermissions(guild).canCreateExpressions;
|
|
}
|
|
if (canCreateExpressions) {
|
|
canCreateExpressions = sendable.length < collapsedStickersCategories(16[16]).getTotalStickerCountForTier(guild.premiumTier);
|
|
const obj3 = collapsedStickersCategories(16[16]);
|
|
}
|
|
let sum = length;
|
|
if (canCreateExpressions) {
|
|
sum = length + 1;
|
|
}
|
|
const rounded = Math.ceil(sum / closure_0);
|
|
let num2 = 0;
|
|
if (!flag) {
|
|
num2 = rounded;
|
|
}
|
|
items1[result] = num2;
|
|
for (let num3 = 0; num3 < rounded; num3 = num3 + 1) {
|
|
let tmp12 = closure_0;
|
|
let result = num3 * closure_0;
|
|
let tmp14 = closure_0;
|
|
let substr = sendable.slice(result, result + closure_0);
|
|
let mapped = substr.map((pack_id, columnIndex) => {
|
|
const obj = { type: collapsedStickersCategories(num[15]).StickerGridItemTypes.STICKER, sticker: pack_id };
|
|
let str = "TODO - fix";
|
|
if (obj2.isStandardSticker(pack_id)) {
|
|
str = pack_id.pack_id;
|
|
}
|
|
obj.packId = str;
|
|
obj.gridSectionIndex = result;
|
|
obj.rowIndex = _slicedToArray;
|
|
obj.columnIndex = columnIndex;
|
|
obj.visibleRowIndex = _createForOfIteratorHelperLoose;
|
|
obj.category = closure_0;
|
|
return obj;
|
|
});
|
|
let tmp15 = result;
|
|
let tmp16 = result > findIndexResult1;
|
|
if (tmp16) {
|
|
let tmp17 = result;
|
|
tmp16 = result > findIndexResult;
|
|
}
|
|
if (tmp16) {
|
|
tmp16 = null != guild;
|
|
}
|
|
if (tmp16) {
|
|
tmp16 = sum > sendable.length;
|
|
}
|
|
if (tmp16) {
|
|
obj = {};
|
|
let tmp18 = collapsedStickersCategories;
|
|
let tmp19 = num;
|
|
obj.type = collapsedStickersCategories(num[15]).StickerGridItemTypes.CREATE_STICKER;
|
|
obj.guild_id = guild.id;
|
|
let intl = collapsedStickersCategories(num[17]).intl;
|
|
obj.name = intl.string(collapsedStickersCategories(num[17]).t["UwF+Cw"]);
|
|
let tmp20 = result;
|
|
obj.gridSectionIndex = result;
|
|
let tmp21 = _slicedToArray;
|
|
obj.rowIndex = _slicedToArray;
|
|
obj.columnIndex = mapped.length;
|
|
let tmp22 = _createForOfIteratorHelperLoose;
|
|
obj.visibleRowIndex = _createForOfIteratorHelperLoose;
|
|
let arr = mapped.push(obj);
|
|
}
|
|
if (!flag) {
|
|
let tmp24 = _createForOfIteratorHelperLoose;
|
|
_createForOfIteratorHelperLoose = _createForOfIteratorHelperLoose + 1;
|
|
let tmp25 = items2;
|
|
arr = items2.push(mapped);
|
|
let tmp27 = items;
|
|
let arr1 = items.push(mapped.length);
|
|
}
|
|
let tmp29 = _slicedToArray;
|
|
_slicedToArray = _slicedToArray + 1;
|
|
}
|
|
result = result + 1;
|
|
}
|
|
let rounded = Math.floor((items2 - items1 + c4) / (c5 + c4));
|
|
const items = [];
|
|
items1 = [];
|
|
items2 = [];
|
|
c4 = 0;
|
|
c5 = 0;
|
|
let c6 = 0;
|
|
const rounded1 = Math.floor(Math.max(c4, (items2 - items1 - c5 * rounded) / (rounded - 1)));
|
|
if (0 !== items2) {
|
|
if (null == items) {
|
|
const tmp10 = outer1_14(c6);
|
|
let iter = tmp10();
|
|
if (!iter.done) {
|
|
do {
|
|
let value = iter.value;
|
|
if (value.stickers.length > 0) {
|
|
let tmp15 = c4;
|
|
c4 = c4 + 1;
|
|
let tmp16 = rounded;
|
|
let hasItem;
|
|
({ stickers, type } = value);
|
|
if (null != rounded) {
|
|
let tmp18 = rounded;
|
|
hasItem = rounded.has(value.id);
|
|
}
|
|
let addGridSectionResult = addGridSection(stickers, type, true === hasItem);
|
|
} else {
|
|
let tmp11 = collapsedStickersCategories;
|
|
let tmp12 = num;
|
|
if (value.type === collapsedStickersCategories(num[15]).StickerCategoryTypes.EMPTY_GUILD_UPSELL) {
|
|
let tmp13 = c5;
|
|
items1[c5] = 0;
|
|
let tmp14 = c5;
|
|
c5 = c5 + 1;
|
|
}
|
|
}
|
|
iter2 = tmp10();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
} else {
|
|
if (items.sendable.length > 0) {
|
|
addGridSection(items.sendable, collapsedStickersCategories(15[15]).StickerCategoryTypes.SEARCH_RESULTS);
|
|
}
|
|
if (items.sendableWithPremium.length > 0) {
|
|
addGridSection(items.sendableWithPremium, collapsedStickersCategories(num[15]).StickerCategoryTypes.SEARCH_RESULTS);
|
|
}
|
|
}
|
|
}
|
|
return { rowCount: c4, rowCountBySection: items1, stickersGrid: items2, gutterWidth: rounded1, columnCounts: items };
|
|
}, items);
|
|
};
|
|
export function useHasSendableSticker() {
|
|
return true;
|
|
}
|
|
export { useFetchStickerPacks };
|
|
export { useFavoriteStickerIds };
|
|
export { useFavoriteStickers };
|
|
export { useLatestFrecentStickerIds };
|
|
export const useLatestFrecentStickers = function useLatestFrecentStickers() {
|
|
const tmp = useLatestFrecentStickerIds();
|
|
const require = tmp;
|
|
const items = [closure_11];
|
|
const items1 = [tmp];
|
|
return require(566) /* initialize */.useStateFromStoresArray(items, () => {
|
|
const mapped = tmp.map((arg0) => outer2_11.getStickerById(arg0));
|
|
return mapped.filter((arg0) => undefined !== arg0);
|
|
}, items1);
|
|
};
|
|
export { useStickerPackCategories };
|
|
export const useStickerForRenderableSticker = function useStickerForRenderableSticker(renderableSticker, arg1) {
|
|
let c3;
|
|
let tmp4;
|
|
let flag = arg1;
|
|
const _require = renderableSticker;
|
|
if (arg1 === undefined) {
|
|
flag = false;
|
|
}
|
|
let dependencyMap;
|
|
c3 = undefined;
|
|
let obj;
|
|
let React;
|
|
obj = _require(566);
|
|
const items = [closure_11];
|
|
const stateFromStores = obj.useStateFromStores(items, () => outer1_11.getStickerById(id.id));
|
|
const tmp2 = obj(React.useState(true), 2);
|
|
dependencyMap = tmp2[1];
|
|
[tmp4, c3] = obj(React.useState(false), 2);
|
|
const tmp3 = obj(React.useState(false), 2);
|
|
let isGuildStickerResult = _require(4467).isGuildSticker(renderableSticker);
|
|
if (!isGuildStickerResult) {
|
|
isGuildStickerResult = _require(4467).isStandardSticker(renderableSticker);
|
|
const obj3 = _require(4467);
|
|
}
|
|
obj = { hasFetched: tmp4, isReturnable: isGuildStickerResult, renderableSticker, shouldFetch: tmp2[0], stickersStoreDefinition: stateFromStores };
|
|
React = React.useRef(obj);
|
|
const effect = React.useEffect(() => {
|
|
result.current = obj;
|
|
});
|
|
const items1 = [flag];
|
|
const effect1 = React.useEffect(() => {
|
|
// CreateGeneratorClosureLongIndex (0x67)
|
|
_undefined(tmp)();
|
|
}, items1);
|
|
if (isGuildStickerResult) {
|
|
const items2 = [renderableSticker, tmp4];
|
|
let items3 = items2;
|
|
} else {
|
|
let tmp10 = null;
|
|
if (null != stateFromStores) {
|
|
tmp10 = stateFromStores;
|
|
}
|
|
items3 = [tmp10, tmp4];
|
|
}
|
|
return items3;
|
|
};
|
|
export const useFilteredStickerPackCategories = function useFilteredStickerPackCategories(channel) {
|
|
let tmp = useStickerPackCategories(channel);
|
|
const require = tmp;
|
|
const items = [tmp];
|
|
return React.useMemo(() => tmp.filter((type) => {
|
|
let tmp = type.type === callback(outer2_2[15]).StickerCategoryTypes.EMPTY_GUILD_UPSELL;
|
|
if (!tmp) {
|
|
tmp = type.stickers.length > 0;
|
|
}
|
|
return tmp;
|
|
}, []), items);
|
|
};
|