yeet

modules/guild_templates/AcceptGuildTemplateActionCreators.tsx

@@ -0,0 +1,52 @@
+// Metro module 10991 (f10992).
+import GatewayConnectionStore from "../gateway/GatewayConnectionStore";
+import GuildStore from "../../stores/GuildStore";
+import { Endpoints } from "../../Constants";
+import Dispatcher from "../../Dispatcher";
+import { HTTP, rejectWithMigratedError } from "../../_bundle/sendRequest";
+import { transitionToGuild } from "../routing/transitionToGuild.native";
+const r20 = {
+  acceptGuildTemplate: (a0, name, icon) => {
+    const code = a0;
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_ACCEPT",
+      code: a0
+    });
+    return new Promise((c26900_0, c26900_1) => {
+      HTTP.post({
+        url: Endpoints.UNRESOLVED_GUILD_TEMPLATE(code),
+        body: {
+          name,
+          icon
+        },
+        oldFormErrors: true,
+        rejectWithError: rejectWithMigratedError()
+      }).then(({ body }) => {
+        Dispatcher.dispatch({
+          type: "GUILD_TEMPLATE_ACCEPT_SUCCESS",
+          code,
+          guild: body
+        });
+        if (GatewayConnectionStore.isConnected()) {
+          GuildStore.addConditionalChangeListener(() => {
+            if (GuildStore.getGuild(body.id) != null) {
+              transitionToGuild(body.id);
+              c26900_0(body);
+              return false;
+            }
+          });
+        } else {
+          transitionToGuild(body.id);
+          c26900_0(body);
+        }
+      }, (a0) => {
+        Dispatcher.dispatch({
+          type: "GUILD_TEMPLATE_ACCEPT_FAILURE",
+          code
+        });
+        c26900_1(a0.body);
+      });
+    });
+  }
+};
+export default r20;

modules/guild_templates/GuildTemplateActionCreators.tsx

@@ -0,0 +1,198 @@
+// Metro module 7689 (f7690).
+import { Endpoints } from "../../Constants";
+import Dispatcher from "../../Dispatcher";
+import { HTTP, rejectWithMigratedError } from "../../_bundle/sendRequest";
+function $mk79200($env) {
+  return () => {
+    let r15;
+    let env26017;
+    const r9 = $env.$parent;
+    const code4 = $env[0];
+    const r3 = env26017 = {
+      $parent: r9
+    };
+    env26017[0] = code4;
+    const r8 = r9[1];
+    const r4 = r9[2];
+    if (r8(r4[1]).isDispatching()) {
+      r15 = Promise.resolve().then($mk79200(r3));
+    } else {
+      const r6 = r9[5];
+      r15 = r6.get(code4);
+      if (r15 == null) {
+        r8(r4[1]).dispatch({
+          type: "GUILD_TEMPLATE_RESOLVE",
+          code: code4
+        });
+        const r29 = (0, r9[0])(r4[2]).HTTP.get({
+          url: r9[3].UNRESOLVED_GUILD_TEMPLATE(code4),
+          oldFormErrors: true,
+          rejectWithError: true
+        });
+        const r31 = $mk79202(r3);
+        const r36 = r29.then($mk79201(r3), r31).finally($mk79203(r3));
+        r6.set(code4, r36);
+        r15 = r36;
+      }
+    }
+    return r15;
+  };
+}
+function $mk79201($env) {
+  return ({ body }) => {
+    const r10 = $env.$parent;
+    const r5 = r10[1];
+    const r3 = r10[2];
+    const r8 = r5(r3[3]);
+    const GUILD_TEMPLATE_RESOLVED = r10[4].GUILD_TEMPLATE_RESOLVED;
+    const guild_template_code = $env[0];
+    r8.track(GUILD_TEMPLATE_RESOLVED, {
+      resolved: true,
+      guild_template_code,
+      guild_template_name: body.name,
+      guild_template_description: body.description,
+      guild_template_guild_id: body.source_guild_id
+    });
+    r5(r3[1]).dispatch({
+      type: "GUILD_TEMPLATE_RESOLVE_SUCCESS",
+      guildTemplate: body,
+      code: guild_template_code
+    });
+    return {
+      guildTemplate: r5(r3[4])(body),
+      code: guild_template_code
+    };
+  };
+}
+function $mk79202($env) {
+  return () => {
+    const r2 = $env.$parent;
+    const r3 = r2[1];
+    const r1 = r2[2];
+    const r7 = r3(r1[3]);
+    const GUILD_TEMPLATE_RESOLVED = r2[4].GUILD_TEMPLATE_RESOLVED;
+    const guild_template_code = $env[0];
+    r7.track(GUILD_TEMPLATE_RESOLVED, {
+      resolved: false,
+      guild_template_code
+    });
+    r3(r1[1]).dispatch({
+      type: "GUILD_TEMPLATE_RESOLVE_FAILURE",
+      code: guild_template_code
+    });
+    return {
+      guildTemplate: null,
+      code: guild_template_code
+    };
+  };
+}
+function $mk79203($env) {
+  return () => {
+    $env.$parent[5].delete($env[0]);
+  };
+}
+let env4832 = {};
+const c4832_5 = new Map();
+const r25 = {
+  resolveGuildTemplate: function resolveGuildTemplate(a0) {
+    let env15962;
+    const r2 = env15962 = {
+      $parent: env4832
+    };
+    env15962[0] = a0;
+    if (Dispatcher.isDispatching()) {
+      return Promise.resolve().then($mk79200(r2));
+    }
+    const r14 = c4832_5.get(a0);
+    if (r14 != null) {
+      return r14;
+    }
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_RESOLVE",
+      code: a0
+    });
+    const r28 = HTTP.get({
+      url: Endpoints.UNRESOLVED_GUILD_TEMPLATE(a0),
+      oldFormErrors: true,
+      rejectWithError: true
+    });
+    const r30 = $mk79202(r2);
+    const r35 = r28.then($mk79201(r2), r30).finally($mk79203(r2));
+    c4832_5.set(a0, r35);
+    return r35;
+  },
+  loadTemplatesForGuild: (a0) => HTTP.get({
+    url: Endpoints.GUILD_TEMPLATES(a0),
+    oldFormErrors: true,
+    rejectWithError: rejectWithMigratedError()
+  }).then((result) => {
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_LOAD_FOR_GUILD_SUCCESS",
+      guildTemplates: result.body
+    });
+    return result;
+  }),
+  createGuildTemplate: (a0, a1, a2) => HTTP.post({
+    url: Endpoints.GUILD_TEMPLATES(a0),
+    body: {
+      name: a1,
+      description: a2
+    },
+    oldFormErrors: true,
+    rejectWithError: rejectWithMigratedError()
+  }).then((result) => {
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_CREATE_SUCCESS",
+      guildTemplate: result.body,
+      code: result.body.code
+    });
+  }),
+  syncGuildTemplate: (a0, a1) => {
+    const code = a1;
+    return HTTP.put({
+      url: Endpoints.GUILD_TEMPLATE(a0, a1),
+      oldFormErrors: true,
+      rejectWithError: rejectWithMigratedError()
+    }).then((result) => {
+      Dispatcher.dispatch({
+        type: "GUILD_TEMPLATE_SYNC_SUCCESS",
+        guildTemplate: result.body,
+        code
+      });
+    });
+  },
+  updateGuildTemplate: (a0, a1, a2, a3) => {
+    const code2 = a1;
+    return HTTP.patch({
+      url: Endpoints.GUILD_TEMPLATE(a0, a1),
+      body: {
+        name: a2,
+        description: a3
+      },
+      oldFormErrors: true,
+      rejectWithError: rejectWithMigratedError()
+    }).then((result) => {
+      Dispatcher.dispatch({
+        type: "GUILD_TEMPLATE_SYNC_SUCCESS",
+        guildTemplate: result.body,
+        code: code2
+      });
+    });
+  },
+  deleteGuildTemplate: (a0, a1) => {
+    const guildId = a0;
+    const code3 = a1;
+    return HTTP.del({
+      url: Endpoints.GUILD_TEMPLATE(a0, a1),
+      oldFormErrors: true,
+      rejectWithError: rejectWithMigratedError()
+    }).then(() => {
+      Dispatcher.dispatch({
+        type: "GUILD_TEMPLATE_DELETE_SUCCESS",
+        guildId,
+        code: code3
+      });
+    });
+  }
+};
+export default r25;

modules/guild_templates/GuildTemplateStore.tsx

@@ -0,0 +1,167 @@
+// Metro module 5715 (f5716).
+import { GuildTemplateStates } from "./GuildTemplatesConstants";
+import createResolvedGuildTemplate from "./createResolvedGuildTemplate";
+import Module589 from "../../_bundle/Module589";
+import Dispatcher from "../../Dispatcher";
+let c3545_3, code;
+const handleGuildTemplateResolveSuccess = function handleGuildTemplateResolveSuccess({ guildTemplate }) {
+  const code2 = guildTemplate.code;
+  if (code2 != null) {
+    const r8 = c3545_3.get(code2);
+    const r18 = r8 != null ? {
+      ...r8
+    } : {
+      code: code2,
+      state: GuildTemplateStates.RESOLVING
+    };
+    const resolvedGuildTemplate = createResolvedGuildTemplate(guildTemplate);
+    for (const key in resolvedGuildTemplate) {
+      r18[key] = resolvedGuildTemplate[key];
+    }
+    const map = new Map(c3545_3);
+    c3545_3 = map;
+    map.set(code2, r18);
+  }
+};
+const handleGuildTemplateResolveFailure = function handleGuildTemplateResolveFailure({ code: code2 }) {
+  if (code2 != null) {
+    const r5 = c3545_3.get(code2);
+    const r13 = r5 != null ? {
+      ...r5
+    } : {
+      code: code2,
+      state: GuildTemplateStates.RESOLVING
+    };
+    r13.state = GuildTemplateStates.EXPIRED;
+    const map = new Map(c3545_3);
+    c3545_3 = map;
+    map.set(code2, r13);
+  }
+};
+c3545_3 = new Map();
+code = null;
+class GuildTemplateStore extends Module589.Store {
+  static displayName = "GuildTemplateStore";
+  getGuildTemplate(a0) {
+    if (a0 != null) {
+      return c3545_3.get(a0);
+    }
+  }
+  getGuildTemplates() {
+    return c3545_3;
+  }
+  getForGuild(a0) {
+    for (const item of c3545_3.keys()) {
+      const r28 = c3545_3.get(item);
+      if (r28 == null) {
+        continue;
+      }
+      if (!("sourceGuildId" in r28)) {
+        continue;
+      }
+      if (r28.sourceGuildId !== a0) {
+        continue;
+      }
+      if (r28.state === GuildTemplateStates.EXPIRED) {
+        continue;
+      }
+      return r28;
+    }
+  }
+  getDisplayedGuildTemplateCode() {
+    return code;
+  }
+}
+const guildTemplateStore = new GuildTemplateStore(Dispatcher, {
+  GUILD_TEMPLATE_RESOLVE: function handleGuildTemplateResolve({ code: code2 }) {
+    const map = new Map(c3545_3);
+    c3545_3 = map;
+    map.set(code2, {
+      code: code2,
+      state: GuildTemplateStates.RESOLVING
+    });
+  },
+  GUILD_TEMPLATE_CREATE_SUCCESS: handleGuildTemplateResolveSuccess,
+  GUILD_TEMPLATE_SYNC_SUCCESS: handleGuildTemplateResolveSuccess,
+  GUILD_TEMPLATE_RESOLVE_SUCCESS: handleGuildTemplateResolveSuccess,
+  GUILD_TEMPLATE_LOAD_FOR_GUILD_SUCCESS: function handleGuildTemplateLoadForGuildSuccess(a0) {
+    a0.guildTemplates.forEach((guildTemplate) => {
+      const code2 = guildTemplate.code;
+      if (code2 != null) {
+        const r8 = c3545_3.get(code2);
+        const r17 = r8 != null ? {
+          ...r8
+        } : {
+          code: code2,
+          state: GuildTemplateStates.RESOLVING
+        };
+        const resolvedGuildTemplate = createResolvedGuildTemplate(guildTemplate);
+        for (const key in resolvedGuildTemplate) {
+          r17[key] = resolvedGuildTemplate[key];
+        }
+        const map = new Map(c3545_3);
+        c3545_3 = map;
+        map.set(code2, r17);
+      }
+    });
+  },
+  GUILD_TEMPLATE_RESOLVE_FAILURE: handleGuildTemplateResolveFailure,
+  GUILD_TEMPLATE_DELETE_SUCCESS: handleGuildTemplateResolveFailure,
+  GUILD_TEMPLATE_ACCEPT: function handleGuildTemplateAccept({ code: code2 }) {
+    if (code2 != null) {
+      const r5 = c3545_3.get(code2);
+      const r13 = r5 != null ? {
+        ...r5
+      } : {
+        code: code2,
+        state: GuildTemplateStates.RESOLVING
+      };
+      r13.state = GuildTemplateStates.ACCEPTING;
+      const map = new Map(c3545_3);
+      c3545_3 = map;
+      map.set(code2, r13);
+    }
+  },
+  GUILD_TEMPLATE_ACCEPT_SUCCESS: function handleGuildTemplateAcceptSuccess({ code: code2 }) {
+    if (code2 != null) {
+      const r6 = c3545_3.get(code2);
+      const r14 = r6 != null ? {
+        ...r6
+      } : {
+        code: code2,
+        state: GuildTemplateStates.RESOLVING
+      };
+      r14.state = GuildTemplateStates.ACCEPTED;
+      let usageCount = r14.usageCount;
+      if (usageCount == null) {
+        usageCount = 0;
+      }
+      r14.usageCount = usageCount + 1;
+      const map = new Map(c3545_3);
+      c3545_3 = map;
+      map.set(code2, r14);
+    }
+  },
+  GUILD_TEMPLATE_ACCEPT_FAILURE: function handleAcceptInviteFailure({ code: code2 }) {
+    if (code2 != null) {
+      const r5 = c3545_3.get(code2);
+      const r13 = r5 != null ? {
+        ...r5
+      } : {
+        code: code2,
+        state: GuildTemplateStates.RESOLVING
+      };
+      r13.state = GuildTemplateStates.RESOLVED;
+      const map = new Map(c3545_3);
+      c3545_3 = map;
+      map.set(code2, r13);
+    }
+  },
+  GUILD_TEMPLATE_MODAL_SHOW: function handleGuildTemplateModalShow(a0) {
+    code = a0.code;
+  },
+  GUILD_TEMPLATE_MODAL_HIDE: function handleGuildTemplateModalHide() {
+    code = null;
+  }
+});
+export default guildTemplateStore;

modules/guild_templates/GuildTemplateTooltipActionCreators.tsx

@@ -0,0 +1,30 @@
+// Metro module 7688 (f7689).
+import PermissionStore from "../../stores/PermissionStore";
+import { Permissions } from "../../Constants";
+import GuildTemplateActionCreators from "./GuildTemplateActionCreators";
+import Dispatcher from "../../Dispatcher";
+const r20 = {
+  checkGuildTemplateDirty: async (guildId) => {
+    L11: {
+      if (PermissionStore.canWithPartialContext(Permissions.MANAGE_GUILD, {
+        guildId
+      })) {
+        await GuildTemplateActionCreators.loadTemplatesForGuild(guildId);
+        break L11;
+      }
+      return void 0;
+    }
+  },
+  hideGuildTemplateDirtyTooltip: (a0) => {
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_DIRTY_TOOLTIP_HIDE",
+      guildId: a0
+    });
+  },
+  hideGuildTemplatePromotionTooltip: () => {
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_PROMOTION_TOOLTIP_HIDE"
+    });
+  }
+};
+export default r20;

modules/guild_templates/GuildTemplatesConstants.tsx

@@ -0,0 +1,23 @@
+// Metro module 5716 (f5717).
+const r10 = {
+  RESOLVING: "RESOLVING",
+  RESOLVED: "RESOLVED",
+  EXPIRED: "EXPIRED",
+  ACCEPTED: "ACCEPTED",
+  ACCEPTING: "ACCEPTING"
+};
+const r16 = {
+  CLASSROOM: "fVfBazbqjhXg",
+  LOCAL_COMMUNITIES: "64UDvRNCC52Y",
+  CREATORS_HOBBIES: "6exdzMgjZgah",
+  GLOBAL_COMMUNITIES: "4sgbPdCjzAYU",
+  FRIENDS_FAMILY: "hgM48av5Q69A",
+  STUDY_GROUPS: "FbwUwRp4j8Es",
+  CREATE_FROM_SCRATCH: "WYAQmEzjw3Pj",
+  CAMPUS_CLUBS: "Ctg7PUHcQmZu",
+  LEAGUE_CLUBS: "PJ6VvgEJYg45",
+  GITHUB_HACKATHON: "UqzZCTj2zfwy"
+};
+export const GUILD_TEMPLATES_MEMBER_COUNT_PROMOTION_THRESHOLD = 50;
+export { r10 as GuildTemplateStates };
+export { r16 as InternalTemplateCodes };

modules/guild_templates/createResolvedGuildTemplate.tsx

@@ -0,0 +1,22 @@
+// Metro module 5717 (f5718).
+import { GuildTemplateStates } from "./GuildTemplatesConstants";
+export default function createResolvedGuildTemplate(a0) {
+  let description = a0.description;
+  if (description == null) {
+    description = "";
+  }
+  return {
+    code: a0.code,
+    state: GuildTemplateStates.RESOLVED,
+    name: a0.name,
+    description,
+    creatorId: a0.creator_id,
+    creator: a0.creator,
+    createdAt: a0.created_at,
+    updatedAt: a0.updated_at,
+    sourceGuildId: a0.source_guild_id,
+    serializedSourceGuild: a0.serialized_source_guild,
+    usageCount: a0.usage_count,
+    isDirty: a0.is_dirty
+  };
+};

modules/guild_templates/native/AcceptGuildTemplateModal.tsx

@@ -0,0 +1,71 @@
+// Metro module 10986 (f10987).
+import { useState, useMemo } from "react";
+import GuildTemplateStore from "../GuildTemplateStore";
+import { UPLOAD_MEDIUM_SIZE } from "../../../Constants";
+import { createStyles } from "../../../design/components/Styles/native/createStyles";
+import { NAV_BAR_HEIGHT } from "../../../design/components/Navigator/native/NavigatorConstants.native";
+import { useStateFromStores } from "../../../_bundle/Module589";
+import { getGuildNameSuggestion } from "../../../utils/GuildUtils";
+import useTrackCreateGuildViewed from "../useTrackCreateGuildViewed";
+import { SafeAreaPaddingView } from "../../../components_native/common/SafeAreaView";
+import AcceptGuildTemplate from "../../create_guild/native/AcceptGuildTemplate";
+import UploadUtils from "../../../utils/native/UploadUtils";
+import AcceptGuildTemplateActionCreators from "../AcceptGuildTemplateActionCreators";
+import GuildTemplateActionCreators from "./GuildTemplateActionCreators";
+import { getHeaderCloseButton } from "../../../design/components/Navigator/native/NavigatorHeader.native";
+import { Navigator } from "../../../design/components/Navigator/native/Navigator.native";
+let useStyles, initialRouteName;
+const ConnectedAcceptGuildTemplate = function ConnectedAcceptGuildTemplate(props) {
+  let state, setState, state2, setState2, setState3;
+  const code = props.code;
+  state = void 0;
+  setState = void 0;
+  state2 = void 0;
+  setState2 = void 0;
+  setState3 = void 0;
+  const styles = useStyles();
+  const stateFromStores = useStateFromStores([GuildTemplateStore], () => GuildTemplateStore.getGuildTemplate(code));
+  [state, setState] = useState(getGuildNameSuggestion());
+  [state2, setState2] = useState(null);
+  let errors;
+  [errors, setState3] = useState(null);
+  useTrackCreateGuildViewed(stateFromStores);
+  return <SafeAreaPaddingView top style={styles.container}>
+    <AcceptGuildTemplate code={code} guildTemplate={stateFromStores} name={state} setName={(a0) => setState(a0)} icon={state2} errors={errors} chooseIcon={async () => {
+      let c26898_1;
+      c26898_1 = void 0;
+      let c30326_0 = (await UploadUtils.openImagePicker({
+        size: UPLOAD_MEDIUM_SIZE
+      })).base64;
+      if (c30326_0 != null) {
+        (0, setState2)(c30326_0);
+      }
+    }} createServer={function createServer() {
+      if (stateFromStores != null) {
+        AcceptGuildTemplateActionCreators.acceptGuildTemplate(stateFromStores.code, state, state2).then(() => GuildTemplateActionCreators.hideModal(), (a0) => setState3(a0));
+      }
+    }} />
+  </SafeAreaPaddingView>;
+};
+useStyles = createStyles({
+  container: {
+    marginTop: NAV_BAR_HEIGHT
+  }
+});
+initialRouteName = "ACCEPT_GUILD_TEMPLATE";
+export default function AcceptGuildTemplateModal(props) {
+  const code2 = props.code;
+  return <Navigator initialRouteName={initialRouteName} screens={useMemo(() => {
+    let c26899_0 = {
+      code: code2
+    };
+    const r9 = {};
+    r9[initialRouteName] = {
+      title: "",
+      fullscreen: true,
+      headerLeft: getHeaderCloseButton(() => GuildTemplateActionCreators.hideModal()),
+      render: () => <ConnectedAcceptGuildTemplate {...c26899_0} />
+    };
+    return r9;
+  }, [code2])} />;
+};

modules/guild_templates/native/GuildTemplateActionCreators.tsx

@@ -0,0 +1,25 @@
+// Metro module 10985 (f10986).
+import GuildTemplateActionCreators from "../GuildTemplateActionCreators";
+import ModalActionCreators from "../../../actions/ModalActionCreators";
+import Dispatcher from "../../../Dispatcher";
+let c7400_3 = "GUILD_TEMPLATE_MODAL_KEY";
+const r16 = {
+  ...GuildTemplateActionCreators,
+  showModal: (a0) => {
+    ModalActionCreators.pushLazy(import("./AcceptGuildTemplateModal"), {
+      code: a0
+    }, c7400_3);
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_MODAL_SHOW",
+      code: a0
+    });
+    GuildTemplateActionCreators.resolveGuildTemplate(a0);
+  },
+  hideModal: () => {
+    ModalActionCreators.popWithKey(c7400_3);
+    Dispatcher.dispatch({
+      type: "GUILD_TEMPLATE_MODAL_HIDE"
+    });
+  }
+};
+export default r16;

modules/guild_templates/useTrackCreateGuildViewed.tsx

@@ -0,0 +1,19 @@
+// Metro module 10987 (f10988).
+import { useRef, useEffect } from "react";
+import { GuildTemplateStates } from "./GuildTemplatesConstants";
+import { AnalyticEvents } from "../../Constants";
+import AnalyticsUtils from "../../utils/AnalyticsUtils";
+export default function useTrackCreateGuildViewed(c18433_0) {
+  const ref = useRef([]);
+  useEffect(() => {
+    if (c18433_0 != null && c18433_0.state !== GuildTemplateStates.RESOLVING && !ref.current.includes(c18433_0.code)) {
+      ref.current.push(c18433_0.code);
+      AnalyticsUtils.track(AnalyticEvents.CREATE_GUILD_VIEWED, {
+        guild_template_code: c18433_0.code,
+        guild_template_name: c18433_0.name,
+        guild_template_description: c18433_0.description,
+        guild_template_guild_id: c18433_0.sourceGuildId
+      });
+    }
+  });
+};