decord/source/utils/ChannelUtils.tsx

// Module ID: 4313
// Function ID: 37792
// Name: _createForOfIteratorHelperLoose
// Dependencies: [1352, 1348, 1908, 3759, 1907, 4204, 653, 1852, 3764, 483, 1882, 4314, 4315, 1212, 3970, 4316, 21, 2, 4323]
// Exports: channelTypeString, computeSummarizedVoiceUsers, denyChannelAccessForNonPaidUsers, getBitrateLimit, getChannelAnalyticsPage, getChannelLinkToCopy, getMentionIconType, getPrivateChannelUserTagsString, isAnyVoiceStateStage, isChannelFull, permissionOverwriteForRole, permissionOverwriteForUser, permissionOverwritesForAnnouncement, permissionOverwritesForRoles, previousTextChannelRouteForGuild

// Module 4313 (_createForOfIteratorHelperLoose)
import _callSuper from "_callSuper";
import _isNativeReflectConstruct from "_isNativeReflectConstruct";
import closure_8 from "_isNativeReflectConstruct";
import closure_9 from "_isNativeReflectConstruct";
import closure_10 from "_isNativeReflectConstruct";
import closure_11 from "_isNativeReflectConstruct";
import ME from "ME";
import { BoostedGuildFeatures } from "GuildFeatures";

let closure_13;
let closure_14;
let closure_15;
let closure_16;
let closure_17;
let closure_18;
let closure_19;
let closure_21;
let closure_22;
let closure_23;
let closure_4;
let closure_5;
let closure_6;
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 isTypeOrCategory(channelType, closure_21) {
  let tmp = channelType === closure_21;
  if (!tmp) {
    tmp = channelType === closure_22;
  }
  return tmp;
}
function allowChannelAccess(id, channelType, MEMBER) {
  const NONE = importAll(3764).NONE;
  let tmp = callback(channelType);
  if (!tmp) {
    tmp = channelType === closure_22;
  }
  let addResult = NONE;
  if (tmp) {
    let obj = importAll(483);
    addResult = obj.add(NONE, constants.VIEW_CHANNEL);
  }
  let tmp7 = isTypeOrCategory(channelType, closure_21);
  if (!tmp7) {
    tmp7 = isTypeOrCategory(channelType, closure_23);
  }
  let addResult2 = addResult;
  if (tmp7) {
    const obj2 = importAll(483);
    const addResult1 = importAll(483).add(addResult, constants.VIEW_CHANNEL);
    addResult2 = importAll(483).add(addResult1, constants.CONNECT);
    const obj3 = importAll(483);
  }
  obj = { id, type: MEMBER, deny: importAll(3764).NONE, allow: addResult2 };
  return obj;
}
function computeSummarizedVoiceStates(arg0) {
  let channels;
  let importAll;
  let importDefault;
  let require;
  ({ channels, selectedChannelId: require, selectedVoiceChannelId: importDefault, voiceStates: importAll } = arg0);
  const items = [];
  let item = channels.forEach((id) => {
    if (id.id !== closure_1) {
      if (id.id !== closure_0) {
        if (null != table[id.id]) {
          const forEach = arr.forEach;
          if (id.isGuildStageVoice()) {
            const item = forEach((voiceState) => {
              const audienceRequestToSpeakState = outer2_0(items[12]).getAudienceRequestToSpeakState(voiceState.voiceState);
              if (audienceRequestToSpeakState === outer2_0(items[12]).RequestToSpeakStates.ON_STAGE) {
                outer1_3.push(voiceState);
              }
            });
          } else {
            const item1 = forEach((arg0) => outer1_3.push(arg0));
          }
        }
      }
    }
  });
  return items;
}
function getChannelPermalink(guild_id, id, id2, id3) {
  let str = "";
  if (null != id3) {
    const _HermesInternal = HermesInternal;
    str = "?summaryId=" + id3;
  }
  return "" + location.protocol + "//" + location.host + closure_18.CHANNEL(guild_id, id, id2) + str;
}
function getChannelThreadPermalink(guildId, id, id2, id2) {
  if (null != guildId) {
    if (null != id) {
      if (null != id2) {
        const _location = location;
        const _location2 = location;
        const _HermesInternal = HermesInternal;
        let combined = "" + protocol + "//" + host + closure_18.CHANNEL_THREAD_VIEW(guildId, id, id2, id2);
      }
      return combined;
    }
  }
  combined = getChannelPermalink(guildId, id, id2);
}
({ isGuildSelectableChannelType: closure_4, TEXT_CHANNEL_TYPES: closure_5, THREAD_CHANNEL_TYPES: closure_6 } = _callSuper);
const ChannelTypes = ME.ChannelTypes;
({ Permissions: closure_13, GuildFeatures: closure_14, BoostedGuildTiers: closure_15, BITRATE_MAX: closure_16, BITRATE_DEFAULT: closure_17, Routes: closure_18, AnalyticsPages: closure_19 } = ME);
({ GUILD_VOICE: closure_21, GUILD_CATEGORY: closure_22, GUILD_STAGE_VOICE: closure_23 } = ChannelTypes);
let result = require("_isNativeReflectConstruct").fileFinishedImporting("utils/ChannelUtils.tsx");

export const denyChannelAccessForNonPaidUsers = function denyChannelAccessForNonPaidUsers(id) {
  if (arg1 === ChannelTypes.GUILD_STAGE_VOICE) {
    let obj = importAll(483);
    obj = { id, type: require(1882) /* PermissionOverwriteType */.PermissionOverwriteType.ROLE, allow: importAll(3764).NONE };
    obj.deny = obj.add(importAll(3764).NONE, constants.CONNECT);
    return obj;
  } else {
    const _Error = Error;
    const _HermesInternal = HermesInternal;
    const error = new Error("Premium channel feature not supported for channel type " + arg1);
    throw error;
  }
};
export { allowChannelAccess };
export const permissionOverwritesForRoles = function permissionOverwritesForRoles(guildId, channelType, arr, arg3) {
  let flag = arg3;
  const _require = channelType;
  if (arg3 === undefined) {
    flag = false;
  }
  const items = [];
  if (tmp) {
    const NONE = importAll(3764).NONE;
    let tmp6 = callback(channelType);
    if (!tmp6) {
      tmp6 = channelType === closure_22;
    }
    let addResult = NONE;
    if (tmp6) {
      let obj = importAll(483);
      addResult = obj.add(NONE, constants.VIEW_CHANNEL);
    }
    let addResult2 = addResult;
    if (isTypeOrCategory(channelType, closure_21)) {
      const obj2 = importAll(483);
      const addResult1 = importAll(483).add(addResult, constants.VIEW_CHANNEL);
      addResult2 = importAll(483).add(addResult1, constants.CONNECT);
      const obj3 = importAll(483);
    }
    obj = { id: guildId, type: _require(1882).PermissionOverwriteType.ROLE, allow: importAll(3764).NONE, deny: addResult2 };
    items.push(obj);
  }
  const item = arr.forEach((arg0) => {
    items.push(outer1_27(arg0, channelType, channelType(outer1_3[10]).PermissionOverwriteType.ROLE));
  });
  return items;
};
export const permissionOverwriteForUser = function permissionOverwriteForUser(id, channelType) {
  return allowChannelAccess(id, channelType, require(1882) /* PermissionOverwriteType */.PermissionOverwriteType.MEMBER);
};
export const permissionOverwriteForRole = function permissionOverwriteForRole(id, channelType) {
  return allowChannelAccess(id, channelType, require(1882) /* PermissionOverwriteType */.PermissionOverwriteType.ROLE);
};
export const permissionOverwritesForAnnouncement = function permissionOverwritesForAnnouncement(id) {
  const items = [{ id, type: require(1882) /* PermissionOverwriteType */.PermissionOverwriteType.ROLE, deny: constants.SEND_MESSAGES, allow: importAll(3764).NONE }];
  return items;
};
export const isChannelFull = function isChannelFull(channel, stateFromStores3, stateFromStores1) {
  const guildId = channel.getGuildId();
  const guild = stateFromStores1.getGuild(guildId);
  let maxVideoChannelUsers;
  if (null != guild) {
    maxVideoChannelUsers = guild.maxVideoChannelUsers;
  }
  let num = -1;
  let num2 = -1;
  if (null != maxVideoChannelUsers) {
    num2 = maxVideoChannelUsers;
  }
  let prop;
  if (null != guild) {
    prop = guild.maxStageVideoChannelUsers;
  }
  if (null != prop) {
    num = prop;
  }
  const result = closure_11.countVoiceStatesForChannel(channel.id);
  const voiceStatesForChannel = closure_11.getVoiceStatesForChannel(channel);
  let canResult = closure_9.can(constants.MOVE_MEMBERS, channel);
  if (canResult) {
    canResult = closure_9.can(constants.CONNECT, channel);
  }
  if (channel.type === closure_23) {
    let tmp11 = null != guildId;
    if (tmp11) {
      let hasVideoResult = stateFromStores3.hasVideo(channel.id);
      if (!hasVideoResult) {
        hasVideoResult = require(4314) /* hasStream */.hasStream(voiceStatesForChannel);
        const obj = require(4314) /* hasStream */;
      }
      tmp11 = hasVideoResult;
    }
    if (tmp11) {
      tmp11 = num > 0;
    }
    if (tmp11) {
      tmp11 = result >= num;
    }
    let tmp10 = tmp11;
  } else {
    tmp10 = null != guildId && stateFromStores3.hasVideo(channel.id);
    if (tmp10) {
      tmp10 = num2 > 0;
    }
    if (tmp10) {
      let num4 = 0;
      if (canResult) {
        num4 = 1;
      }
      tmp10 = result >= num2 + num4;
    }
  }
  let tmp15 = channel.userLimit > 0 && result >= channel.userLimit;
  if (!tmp10) {
    if (tmp15) {
      tmp15 = !canResult;
    }
    tmp10 = tmp15;
  }
  return tmp10;
};
export const sanitizeGuildTextChannelName = require("sanitizeGuildTextChannelName");
export const getBitrateLimit = function getBitrateLimit(guild, channel) {
  if (channel.isGuildStageVoice()) {
    let bound = closure_17;
  } else if (null == guild) {
    bound = closure_16;
  } else {
    const features = guild.features;
    if (features.has(constants2.VIP_REGIONS)) {
      let bitrate = BoostedGuildFeatures[TIER_3.TIER_3].limits.bitrate;
    } else {
      bitrate = closure_16;
    }
    bound = Math.max(bitrate, BoostedGuildFeatures[guild.premiumTier].limits.bitrate);
  }
  return bound;
};
export { computeSummarizedVoiceStates };
export const computeSummarizedVoiceUsers = function computeSummarizedVoiceUsers(channels) {
  return computeSummarizedVoiceStates({ channels: channels.channels, selectedChannelId: channels.selectedChannelId, selectedVoiceChannelId: channels.selectedVoiceChannelId, voiceStates: channels.voiceStates }).map((user) => user.user);
};
export const isAnyVoiceStateStage = function isAnyVoiceStateStage(channels, stateFromStores, closure_1) {
  const tmp = _createForOfIteratorHelperLoose(channels);
  const iter = tmp();
  let iter2 = iter;
  if (!iter.done) {
    while (true) {
      let value = iter2.value;
      let tmp4 = tmp2;
      let tmp5 = tmp3;
      if (value.id !== stateFromStores) {
        let tmp13 = closure_1[value.id];
        let tmp14 = tmp13;
        tmp4 = tmp2;
        tmp5 = tmp3;
        if (null != tmp13) {
          let tmp15 = tmp13;
          tmp4 = tmp2;
          tmp5 = tmp3;
          if (value.isGuildStageVoice()) {
            let tmp6 = _createForOfIteratorHelperLoose;
            let tmp7 = _createForOfIteratorHelperLoose(tmp13);
            let iter3 = tmp7();
            let iter4 = iter3;
            let tmp8 = tmp13;
            tmp4 = iter3;
            tmp5 = tmp7;
            if (!iter3.done) {
              let tmp9 = require;
              let tmp10 = dependencyMap;
              let obj = require(4315) /* getAudienceRequestToSpeakState */;
              let audienceRequestToSpeakState = obj.getAudienceRequestToSpeakState(iter4.value.voiceState);
              while (audienceRequestToSpeakState !== require(4315) /* getAudienceRequestToSpeakState */.RequestToSpeakStates.ON_STAGE) {
                let iter5 = tmp7();
                iter4 = iter5;
                let tmp12 = tmp13;
                tmp4 = iter5;
                tmp5 = tmp7;
                continue;
              }
              let flag = true;
              return true;
            }
          }
        }
      }
      let iter6 = tmp();
      tmp2 = tmp4;
      tmp3 = tmp5;
      iter2 = iter6;
    }
  }
  return false;
};
export const channelTypeString = function channelTypeString(channel) {
  const type = channel.type;
  if (ChannelTypes.DM === type) {
    const intl10 = require(1212) /* getSystemLocale */.intl;
    return intl10.string(require(1212) /* getSystemLocale */.t.jN2DfZ);
  } else if (ChannelTypes.GROUP_DM === type) {
    const intl9 = require(1212) /* getSystemLocale */.intl;
    return intl9.string(require(1212) /* getSystemLocale */.t["e5y+gm"]);
  } else if (ChannelTypes.GUILD_TEXT === type) {
    const intl8 = require(1212) /* getSystemLocale */.intl;
    return intl8.string(require(1212) /* getSystemLocale */.t.Pnajj0);
  } else if (ChannelTypes.GUILD_FORUM === type) {
    const intl7 = require(1212) /* getSystemLocale */.intl;
    return intl7.string(require(1212) /* getSystemLocale */.t.GbryDd);
  } else if (ChannelTypes.GUILD_MEDIA === type) {
    const intl6 = require(1212) /* getSystemLocale */.intl;
    return intl6.string(require(1212) /* getSystemLocale */.t.seKITE);
  } else if (ChannelTypes.GUILD_VOICE === type) {
    const intl5 = require(1212) /* getSystemLocale */.intl;
    return intl5.string(require(1212) /* getSystemLocale */.t.BVZqJl);
  } else if (ChannelTypes.GUILD_STAGE_VOICE === type) {
    const intl4 = require(1212) /* getSystemLocale */.intl;
    return intl4.string(require(1212) /* getSystemLocale */.t.EErMzA);
  } else if (ChannelTypes.GUILD_ANNOUNCEMENT === type) {
    const intl3 = require(1212) /* getSystemLocale */.intl;
    return intl3.string(require(1212) /* getSystemLocale */.t.l1dkSD);
  } else if (ChannelTypes.GUILD_STORE === type) {
    const intl2 = require(1212) /* getSystemLocale */.intl;
    return intl2.string(require(1212) /* getSystemLocale */.t["P1/Erq"]);
  } else if (ChannelTypes.GUILD_CATEGORY === type) {
    const intl = require(1212) /* getSystemLocale */.intl;
    return intl.string(require(1212) /* getSystemLocale */.t.vHCZwr);
  } else {
    return null;
  }
};
export const getPrivateChannelUserTagsString = function getPrivateChannelUserTagsString(recipients, outer1_7) {
  let iter;
  if (null == recipients) {
    return null;
  } else {
    const currentUser = outer1_7.getCurrentUser();
    let id;
    if (null != currentUser) {
      id = currentUser.id;
    }
    if (null == id) {
      return null;
    } else {
      const items = [];
      const tmp8 = _createForOfIteratorHelperLoose(recipients);
      const iter3 = tmp8();
      let iter2 = iter3;
      if (!iter3.done) {
        do {
          let value = iter2.value;
          if (id !== value) {
            let user = outer1_7.getUser(value);
            let tmp3 = user;
            if (null != user) {
              let arr = items.push(user);
              let tmp5 = user;
            }
          }
          iter = tmp8();
          iter2 = iter;
        } while (!iter.done);
      }
      if (0 === items.length) {
        return null;
      } else {
        const substr = items.slice(0, 2);
        const mapped = substr.map((isProvisional) => {
          const obj = outer1_1(outer1_3[14]);
          if (isProvisional.isProvisional) {
            let name = obj.getName(isProvisional);
          } else {
            name = obj.getUserTag(isProvisional);
          }
          return name;
        });
        const intl = require(1212) /* getSystemLocale */.intl;
        let obj = { users: items.length, user1: mapped[0], user2: mapped[1], extras: items.length - mapped.length };
        return intl.formatToPlainString(require(1212) /* getSystemLocale */.t.BXG0Eh, obj);
      }
    }
  }
};
export const getMentionIconType = function getMentionIconType(channel) {
  if (null == channel) {
    return "text";
  } else {
    const isNSFWResult = channel.isNSFW();
    const isSpoilerChannelResult = channel.isSpoilerChannel();
    if (channel.type === ChannelTypes.GUILD_VOICE) {
      let str11 = "voice-locked";
      if (closure_9.can(constants.CONNECT, channel)) {
        let str12 = "voice-nsfw";
        if (!isNSFWResult) {
          let str13 = "voice";
          if (isSpoilerChannelResult) {
            str13 = "voice-spoiler";
          }
          str12 = str13;
        }
        str11 = str12;
      }
      let tmp4 = str11;
    } else if (channel.type === ChannelTypes.GUILD_STAGE_VOICE) {
      let str10 = "stage-locked";
      if (closure_9.can(constants.CONNECT, channel)) {
        str10 = "stage";
      }
      tmp4 = str10;
    } else if (set2.has(channel.type)) {
      let str9 = "thread";
      if (channel.isForumPost()) {
        str9 = "post";
      }
      tmp4 = str9;
    } else if (channel.type === ChannelTypes.GUILD_FORUM) {
      if (tmp12) {
        let str8 = "media";
        if (isNSFWResult) {
          str8 = "media-nsfw";
        }
        let str6 = str8;
      } else {
        str6 = "forum-nsfw";
        if (!isNSFWResult) {
          let str7 = "forum";
          if (isSpoilerChannelResult) {
            str7 = "forum-spoiler";
          }
          str6 = str7;
        }
      }
    } else if (channel.type === ChannelTypes.GUILD_MEDIA) {
      let str5 = "media";
      if (isNSFWResult) {
        str5 = "media-nsfw";
      }
      tmp4 = str5;
    } else if (channel.type === ChannelTypes.GUILD_ANNOUNCEMENT) {
      let str3 = "announcement-nsfw";
      if (!isNSFWResult) {
        let str4 = "announcement";
        if (isSpoilerChannelResult) {
          str4 = "announcement-spoiler";
        }
        str3 = str4;
      }
      tmp4 = str3;
    } else if (set.has(channel.type)) {
      let str = "text-nsfw";
      if (!isNSFWResult) {
        let str2 = "text";
        if (isSpoilerChannelResult) {
          str2 = "text-spoiler";
        }
        str = str2;
      }
      tmp4 = str;
    }
    return tmp4;
  }
};
export const previousTextChannelRouteForGuild = function previousTextChannelRouteForGuild(arg0) {
  channel = channel.getChannel(lastSelectedChannelId.getLastSelectedChannelId());
  if (null != channel) {
    if (channel.getGuildId() === arg0) {
      if (channel.type === ChannelTypes.GUILD_TEXT) {
        let id = channel.id;
      }
      return closure_18.CHANNEL(arg0, id);
    }
  }
  defaultChannel = defaultChannel.getDefaultChannel(arg0);
  id = null;
  if (null != defaultChannel) {
    id = defaultChannel.id;
  }
};
export { getChannelPermalink };
export { getChannelThreadPermalink };
export const getChannelLinkToCopy = function getChannelLinkToCopy(channel, channel1, id2) {
  let tmp = arg3;
  const guildId = channel.getGuildId();
  if (null != channel1) {
    if (obj.canUseMediaPostEmbed(guildId, channel1)) {
      tmp = getChannelThreadPermalink(guildId, channel1.id, channel.id, importDefault(21).castChannelIdAsMessageId(channel.id));
      const obj2 = importDefault(21);
    }
    return tmp;
  }
  if (null == tmp) {
    tmp = getChannelPermalink(guildId, channel.id, id2);
  }
};
export const getChannelAnalyticsPage = function getChannelAnalyticsPage(type) {
  if (null == type) {
    return null;
  } else {
    type = type.type;
    if (ChannelTypes.GUILD_ANNOUNCEMENT !== type) {
      if (ChannelTypes.GUILD_TEXT !== type) {
        if (ChannelTypes.GUILD_FORUM !== type) {
          if (ChannelTypes.GUILD_MEDIA !== type) {
            if (ChannelTypes.GROUP_DM !== type) {
              if (ChannelTypes.DM !== type) {
                return null;
              }
            }
            return constants3.DM_CHANNEL;
          }
        }
      }
    }
    return constants3.GUILD_CHANNEL;
  }
};