yeet

lib/uploader/native/CloudUploader.tsx

@@ -0,0 +1,399 @@
+// Metro module 6150 (f6151).
+import * as _Module17 from "react-native";
+import { AbortCodes, NOOP } from "../../../Constants";
+import { DEFAULT_MOBILE_PRE_COMPRESSION_MAX_ATTACHMENT_SIZE, FileUploadErrorTypes } from "../../../modules/messages/MessageConstants";
+import Logger from "../../../modules/debug/Logger";
+import UploaderBase from "../UploaderBase";
+import BackgroundTaskManager_native from "../../../modules/messages/BackgroundTaskManager.native";
+import { intl, t } from "../../../intl/index.native";
+import { getKestrelConfig, getEffectiveKestrelLimit } from "../../../modules/media_uploads/experiments/KestrelExperiment";
+import { getFileSize } from "../../../utils/native/UploadUtils";
+import { getUploadTarget } from "../UploadTargets";
+import UploaderQueue from "../UploaderQueue";
+import { isAndroid } from "../../../utils/PlatformUtils";
+import stageAttachmentFiles from "../stageAttachmentFiles";
+import { CloudUploadStatus } from "../CloudUpload";
+import { UploadPlatform } from "../Upload";
+import Module12 from "../../../_bundle/Module12";
+function $mk114879($env) {
+  return () => {
+    const r2 = $env[0];
+    r2.startUpload();
+    return r2;
+  };
+}
+function $mk114880($env) {
+  return (a0) => a0.status === CloudUploadStatus.COMPLETED;
+}
+let c3892_11, prototype;
+let env3892 = {};
+const { NativeEventEmitter, NativeModules } = _Module17;
+const c3892_8 = new Logger("CloudUploader(Native).tsx");
+const c3892_9 = new NativeEventEmitter(NativeModules.MediaManager);
+class CloudUploader extends UploaderBase {
+  mediaEventSubscriptions = new Map();
+  uploadItems = new Map();
+  preCompressionFileSizes = [];
+  async uploadFiles(a0) {
+    let r40, r116, r202, r241, r256, r281, r345;
+    let env15519 = {
+      $parent: env3892
+    };
+    env15519[3] = this;
+    env15519[1] = a0;
+    env15519[2] = () => {
+      const r1 = env15519[3];
+      return Reflect.get(Object.getPrototypeOf(prototype), "upload", r1);
+    };
+    env15519[0] = this;
+    let c25719_0, files, c25719_2, c25719_3, c25719_4;
+    let c25719_5 = 0;
+    const r15 = env15519;
+    L30: {
+      L29: {
+        L28: {
+          L27: {
+            try {
+              let env29672;
+              c25719_3 = r15;
+              const r50 = env29672 = {
+                $parent: r15
+              };
+              c25719_2 = r50;
+              env29672[0] = void 0;
+              env29672[1] = void 0;
+              env29672[2] = void 0;
+              env29672[3] = void 0;
+              env29672[4] = void 0;
+              env29672[5] = void 0;
+              env29672[6] = void 0;
+              env29672[7] = void 0;
+              env29672[0] = BackgroundTaskManager_native.backgroundTaskIdentifierInvalid;
+              env15519[0].once("start", async () => {
+                let c31393_0 = env29672;
+                env29672[0] = await BackgroundTaskManager_native.startBackgroundTask({
+                  title: intl.string(t["B/HSDd"]),
+                  content: intl.formatToPlainString(t.D0noUt, {
+                    count: env15519[1].length
+                  })
+                });
+                if (env15519[0]._aborted) {
+                  BackgroundTaskManager_native.endBackgroundTask(env29672[0]);
+                }
+              });
+              const onCompleteTask = () => {
+                BackgroundTaskManager_native.endBackgroundTask(env29672[0]);
+                const r11 = env15519[0];
+                const r13 = env29672[1];
+                r11.removeListener("complete", r13);
+                r11.removeListener("error", r13);
+              };
+              env29672[1] = onCompleteTask;
+              env15519[0].once("error", onCompleteTask);
+              env15519[0].once("complete", onCompleteTask);
+              env29672[2] = new Promise((c31394_0, c31394_1) => {
+                const r4 = env15519[0];
+                r4.once("error", (a0, a1, a2, a3) => {
+                  c31394_1({
+                    file: a0,
+                    code: a1,
+                    responseBody: a2,
+                    reason: a3
+                  });
+                });
+                r4.once("complete", () => {
+                  const r3 = env15519[0];
+                  if (!r3._errored) {
+                    c31394_0(r3.files);
+                  }
+                });
+              });
+              c25719_5 = 1;
+              const r69 = env15519[0];
+              const files3 = env15519[1];
+              r69.files = files3;
+              (0, env15519[2])().call(env15519[0], files3);
+              env15519[0]._file.attachmentsCount = files3.length;
+              env15519[0]._handleStart(void 0);
+              env29672[3] = getKestrelConfig({
+                location: "CloudUploader.native.uploadFiles"
+              });
+              env29672[4] = 0;
+              const files2 = env15519[0].files;
+              files = files2;
+              const r93 = files2[Symbol.iterator]();
+              files = r93.next;
+              c25719_0 = r93;
+              const r95 = files;
+              let r96 = c25719_0;
+              const r97 = r96 === void 0 ? void 0 : (r40 = r95.call(r96)).done ? r96 = void 0 : r40.value;
+              c25719_0 = r96;
+              if (r96 === void 0) {
+                c3892_8.log(`${env15519[0].id} queued`);
+                UploaderQueue.enqueue($mk114879(env15519));
+                r116 = env29672[2];
+                c25719_5 = 0;
+                break L30;
+              }
+              c25719_5 = 2;
+              env29672[5] = r97;
+              let r135 = await getFileSize(env29672[5].item.uri);
+              while (true) {
+                env29672[6] = r135;
+                env15519[0].preCompressionFileSizes.push(env29672[6]);
+                env29672[5].preCompressionSize = env29672[6];
+                env29672[4] = env29672[4] + env29672[6];
+                env15519[0]._file.totalPreCompressionSize = env29672[4];
+                env15519[0]._file.currentSize = env29672[4];
+                env29672[7] = getUploadTarget(env29672[5].item.target);
+                if (env29672[6] > Math.max(env29672[7].getMaxFileSize(env29672[5].channelId), DEFAULT_MOBILE_PRE_COMPRESSION_MAX_ATTACHMENT_SIZE)) {
+                  env15519[0]._handleError({
+                    code: AbortCodes.ENTITY_TOO_LARGE,
+                    reason: {
+                      type: FileUploadErrorTypes.PRECOMPRESSION_INDIVIDUAL_FILE_TOO_LARGE
+                    }
+                  });
+                  r202 = env29672[2];
+                  c25719_5 = 1;
+                  const r203 = c25719_0;
+                  if (r203 !== void 0 && typeof r203.return === "function") {
+                    r203.return();
+                  }
+                  c25719_5 = 0;
+                  break L29;
+                }
+                if (env29672[3].enabled) {
+                  if (env29672[6] > getEffectiveKestrelLimit(env29672[3], env29672[7].getMaxFileSize(env29672[5].channelId))) {
+                    env15519[0]._handleError({
+                      code: AbortCodes.ENTITY_TOO_LARGE,
+                      reason: {
+                        type: FileUploadErrorTypes.PRECOMPRESSION_INDIVIDUAL_FILE_TOO_LARGE
+                      }
+                    });
+                    r241 = env29672[2];
+                    c25719_5 = 1;
+                    const r242 = c25719_0;
+                    if (r242 !== void 0 && typeof r242.return === "function") {
+                      r242.return();
+                    }
+                    c25719_5 = 0;
+                    break;
+                  }
+                }
+                if (env29672[4] > env29672[7].getMaxTotalAttachmentSize()) {
+                  env15519[0]._handleError({
+                    code: AbortCodes.ENTITY_TOO_LARGE,
+                    reason: {
+                      type: FileUploadErrorTypes.PRECOMPRESSION_SUM_TOO_LARGE
+                    }
+                  });
+                  r256 = env29672[2];
+                  c25719_5 = 1;
+                  const r257 = c25719_0;
+                  if (r257 !== void 0 && typeof r257.return === "function") {
+                    r257.return();
+                  }
+                  c25719_5 = 0;
+                  break L28;
+                }
+                c25719_5 = 1;
+                const r259 = files;
+                let r260 = c25719_0;
+                const r261 = r260 === void 0 ? void 0 : (r40 = r259.call(r260)).done ? r260 = void 0 : r40.value;
+                c25719_0 = r260;
+                if (r260 === void 0) {
+                  c3892_8.log(`${env15519[0].id} queued`);
+                  UploaderQueue.enqueue($mk114879(env15519));
+                  r281 = env29672[2];
+                  c25719_5 = 0;
+                  break L27;
+                }
+                c25719_5 = 2;
+                env29672[5] = r261;
+                r135 = await getFileSize(env29672[5].item.uri);
+              }
+            } catch ($e) {
+              const r48 = $e;
+              let r8 = r48;
+              c25719_4 = r48;
+              let r49 = c25719_5;
+              if (r49 !== 0) {
+                while (true) {
+                  if (r49 === 1) {
+                    try {
+                      const r329 = c25719_4;
+                      c25719_5 = 0;
+                      env29672[8] = r329;
+                      c3892_8.log(`${env15519[0].id} failed in CloudUploader uploadFiles ${env29672[8]}`);
+                      env15519[0]._handleException(env29672[8]);
+                      r345 = env29672[2];
+                    } catch (r326) {
+                      r8 = r326;
+                      c25719_4 = r326;
+                      r49 = c25719_5;
+                      if (r49 === 0) {
+                        break;
+                      }
+                      continue;
+                    }
+                    return r345;
+                  }
+                  try {
+                    const r321 = c25719_4;
+                    c25719_5 = 1;
+                    const r323 = c25719_0;
+                    if (r323 !== void 0 && typeof r323.return === "function") {
+                      try {
+                        r323.return();
+                      } catch {}
+                    }
+                    throw r321;
+                  } catch (r320) {
+                    r8 = r320;
+                    c25719_4 = r320;
+                    r49 = c25719_5;
+                    if (r49 === 0) {
+                      break;
+                    }
+                  }
+                }
+              }
+              throw r8;
+            }
+            return r241;
+          }
+          return r281;
+        }
+        return r256;
+      }
+      return r202;
+    }
+    return r116;
+  }
+  async startUpload() {
+    const _this = this;
+    let c25720_0, c25720_1, c25720_2;
+    let c25720_3 = 0;
+    const r19 = void 0;
+    const r18 = env3892;
+    L28: {
+      L25: {
+        L26: {
+          try {
+            let env29673;
+            c25720_1 = r19;
+            const r40 = env29673 = {
+              $parent: r18
+            };
+            c25720_0 = r40;
+            if (_this._aborted) {
+              _this._handleAborted();
+              break L28;
+            }
+            _this._handleStart(NOOP);
+            c25720_3 = 1;
+            if (isAndroid()) {
+              _this.observeCompressionProgress(_this.files);
+            }
+            if (await _this.compressAndCheckFileSize()) {
+              _this.setUploadingTextForUI();
+              await stageAttachmentFiles(_this.files, true, _this._recomputeProgress.bind(_this));
+              if (_this.files.length === 0) {
+                c3892_8.log(`All uploads cancelled for ${_this.id}`);
+                _this._handleComplete();
+                c25720_3 = 0;
+                break L26;
+              }
+              if (_this.files.every($mk114880(env3892))) {
+                const items = _this._file.items;
+                if (items != null) {
+                  items.forEach((item) => {
+                    item.item.progress = 100;
+                  });
+                }
+                _this._file = {
+                  ..._this._file,
+                  progress: 100
+                };
+                _this.emit("progress", _this._file);
+                c3892_8.log(`All uploads complete for ${_this.id}`);
+                _this._handleComplete();
+                c25720_3 = 0;
+                break L25;
+              }
+              throw new Error("Not all attachments were uploaded successfully");
+            }
+            c25720_3 = 0;
+          } catch ($e) {
+            const r38 = $e;
+            let r8 = r38;
+            c25720_2 = r38;
+            if (c25720_3 !== 0) {
+              while (true) {
+                try {
+                  const r195 = c25720_2;
+                  c25720_3 = 0;
+                  env29673[0] = r195;
+                  _this._handleException(env29673[0]);
+                  break L25;
+                } catch (r191) {
+                  r8 = r191;
+                  c25720_2 = r191;
+                  if (c25720_3 === 0) {
+                    break;
+                  }
+                }
+              }
+            }
+            throw r8;
+          }
+          return void 0;
+        }
+        return void 0;
+      }
+      return void 0;
+    }
+  }
+  observeCompressionProgress(a0) {
+    a0.forEach(({ item }) => {
+      if (item.platform === UploadPlatform.REACT_NATIVE) {
+        item.compressionProgress = 0;
+        this.uploadItems.set(item.uri, item);
+      }
+    });
+    this.mediaEventSubscriptions.set(this._file.id, c3892_9.addListener("compression-progress", ({ uri, progress }) => {
+      if (this.uploadItems.has(uri)) {
+        this.uploadItems.get(uri).compressionProgress = progress;
+        const compressionProgress = Module12.meanBy([...this.uploadItems.values()], "compressionProgress");
+        if (compressionProgress >= 100) {
+          const r37 = this.mediaEventSubscriptions.get(this._file.id);
+          if (r37 != null) {
+            r37.remove();
+          }
+          this.mediaEventSubscriptions.delete(this._file.id);
+          this.uploadItems.clear();
+          const items = this._file.items;
+          if (items != null) {
+            items.forEach((item) => {
+              item.item.compressionProgress = 100;
+            });
+          }
+          this._file = {
+            ...this._file,
+            compressionProgress: 100
+          };
+        } else {
+          this._file = {
+            ...this._file,
+            compressionProgress
+          };
+        }
+        this.emit("compression-progress", this._file);
+      }
+    }));
+  }
+}
+const prototype2 = CloudUploader.prototype;
+c3892_11 = CloudUploader;
+prototype = prototype2;
+export default CloudUploader;

lib/uploader/native/CloudUploaderUtils.tsx

@@ -0,0 +1,57 @@
+// Metro module 4762 (f4763).
+import LocaleStore from "../../../modules/user_settings/LocaleStore";
+import AuthenticationStore from "../../../stores/AuthenticationStore";
+import DeveloperOptionsStore from "../../../stores/DeveloperOptionsStore";
+import { getAttachmentPayload } from "../../../utils/UploadUtils";
+import Module12 from "../../../_bundle/Module12";
+import AnalyticsUtils from "../../../utils/AnalyticsUtils";
+export function getUploadPayload(a0) {
+  return {
+    filename: a0.filename,
+    file_size: a0.currentSize,
+    id: Module12.uniqueId(),
+    original_content_type: void 0
+  };
+}
+const r19 = {
+  getUploadPayload
+};
+export default r19;
+export function prepareMessagePayload(a0, a1, a2, a3) {
+  let body;
+  const attachments = [];
+  let c14426_0 = attachments;
+  a1.forEach((item, index) => {
+    c14426_0.push({
+      ...getAttachmentPayload(item, index)
+    });
+  });
+  if (a3 != null && a2 != null) {
+    const r8 = {
+      ...a2
+    };
+    body = Module12.set(r8, a3, [...Module12.get(r8, a3, []), ...attachments]);
+  } else {
+    body = {
+      ...a2,
+      attachments
+    };
+  }
+  const headers = {
+    Authorization: a0,
+    "X-Debug-Options": DeveloperOptionsStore.getDebugOptionsHeaderValue(),
+    "Accept-Language": LocaleStore.locale
+  };
+  const superPropertiesBase64 = AnalyticsUtils.getSuperPropertiesBase64();
+  if (superPropertiesBase64 != null) {
+    headers["X-Super-Properties"] = superPropertiesBase64;
+  }
+  const fingerprint = AuthenticationStore.getFingerprint();
+  if (fingerprint != null) {
+    headers["X-Fingerprint"] = fingerprint;
+  }
+  return {
+    headers,
+    body
+  };
+}