stream-chat-react-native-core/lib/commonjs/nativeMultipartUpload.js

The official React Native and Expo components for Stream Chat, a service for building chat applications

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createNativeMultipartUploader = exports.createNativeMultipartUpload = void 0;
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
var _reactNative = require("react-native");
var STREAM_MULTIPART_UPLOAD_PROGRESS_EVENT = 'streamMultipartUploadProgress';
var CANCELED_ERROR_CODE = 'ERR_CANCELED';
var createDefaultUploadId = () => `stream-upload-${Date.now()}-${Math.random().toString(16).slice(2)}`;
var createCanceledError = () => {
  var error = new Error('Request aborted');
  error.name = 'CanceledError';
  error.code = CANCELED_ERROR_CODE;
  error.__CANCEL__ = true;
  return error;
};
var toUploadHeaders = headers => Object.entries(headers).map(([name, value]) => ({
  name,
  value
}));
var fromUploadHeaders = headers => {
  if (!headers?.length) {
    return undefined;
  }
  return headers.reduce((acc, header) => {
    acc[header.name] = header.value;
    return acc;
  }, {});
};
var addAbortHandler = (signal, onAbort) => {
  if (!signal) {
    return () => undefined;
  }
  var handled = false;
  var handleAbort = () => {
    if (handled) {
      return;
    }
    handled = true;
    onAbort();
  };
  if (typeof signal.addEventListener === 'function') {
    signal.addEventListener('abort', handleAbort, {
      once: true
    });
    return () => {
      signal.removeEventListener?.('abort', handleAbort);
    };
  }
  var previousOnAbort = signal.onabort;
  var chainedOnAbort = (...args) => {
    previousOnAbort?.(...args);
    handleAbort();
  };
  signal.onabort = chainedOnAbort;
  return () => {
    if (signal.onabort === chainedOnAbort) {
      signal.onabort = previousOnAbort ?? null;
    }
  };
};
var getNativeProgressConfig = progress => {
  if (!progress) {
    return undefined;
  }
  var nativeProgressConfig = {
    ...progress
  };
  delete nativeProgressConfig.completionProgressCap;
  return Object.keys(nativeProgressConfig).length ? nativeProgressConfig : undefined;
};
var isPhotoLibraryUri = uri => {
  var normalizedUri = uri.toLowerCase();
  return normalizedUri.startsWith('ph://') || normalizedUri.startsWith('assets-library://');
};
var sanitizeResolvedFileUri = uri => {
  var normalizedUri = uri.startsWith('/') ? `file://${uri}` : uri;
  if (!normalizedUri.startsWith('file://')) {
    return normalizedUri;
  }
  return normalizedUri.split('#')[0].split('?')[0];
};
var resolvePartUri = function () {
  var _ref = (0, _asyncToGenerator2.default)(function* (part, getLocalAssetUri) {
    if (part.kind !== 'file' || typeof getLocalAssetUri !== 'function' || !isPhotoLibraryUri(part.uri)) {
      return part;
    }
    try {
      var resolvedUri = yield getLocalAssetUri(part.uri);
      return {
        ...part,
        uri: resolvedUri ? sanitizeResolvedFileUri(resolvedUri) : part.uri
      };
    } catch {
      return part;
    }
  });
  return function resolvePartUri(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();
var createNativeMultipartUploader = (nativeModule, options = {}) => {
  if (!nativeModule) {
    return undefined;
  }
  var multipartUploadEventEmitter = options.eventEmitter ?? new _reactNative.NativeEventEmitter(nativeModule);
  return function () {
    var _ref2 = (0, _asyncToGenerator2.default)(function* ({
      headers,
      method,
      onProgress,
      parts,
      progress,
      signal,
      timeoutMs,
      uploadId,
      url
    }) {
      var progressSubscription;
      var uploadStarted = false;
      var abortUpload = function () {
        var _ref3 = (0, _asyncToGenerator2.default)(function* () {
          try {
            yield nativeModule.cancelUpload(uploadId);
          } catch {}
        });
        return function abortUpload() {
          return _ref3.apply(this, arguments);
        };
      }();
      var handleAbort = () => {
        if (uploadStarted) {
          abortUpload().catch(() => undefined);
        }
      };
      if (signal?.aborted) {
        throw createCanceledError();
      }
      var removeAbortListener = addAbortHandler(signal, handleAbort);
      if (signal?.aborted) {
        removeAbortListener();
        throw createCanceledError();
      }
      if (onProgress) {
        progressSubscription = multipartUploadEventEmitter.addListener(STREAM_MULTIPART_UPLOAD_PROGRESS_EVENT, event => {
          if (event.uploadId !== uploadId) {
            return;
          }
          onProgress({
            loaded: event.loaded,
            total: typeof event.total === 'number' ? event.total : undefined
          });
        });
      }
      try {
        uploadStarted = true;
        var response = yield nativeModule.uploadMultipart(uploadId, url, method, toUploadHeaders(headers), parts, progress ?? {}, timeoutMs);
        if (signal?.aborted) {
          throw createCanceledError();
        }
        return {
          body: response.body,
          headers: fromUploadHeaders(response.headers),
          status: response.status,
          statusText: typeof response.statusText === 'string' ? response.statusText : undefined
        };
      } catch (error) {
        if (signal?.aborted) {
          throw createCanceledError();
        }
        throw error;
      } finally {
        progressSubscription?.remove();
        removeAbortListener();
      }
    });
    return function (_x3) {
      return _ref2.apply(this, arguments);
    };
  }();
};
exports.createNativeMultipartUploader = createNativeMultipartUploader;
var createNativeMultipartUpload = ({
  getLocalAssetUri,
  uploadIdFactory = createDefaultUploadId,
  uploadMultipart
}) => {
  if (!uploadMultipart) {
    return undefined;
  }
  return function () {
    var _ref4 = (0, _asyncToGenerator2.default)(function* ({
      headers,
      method,
      onProgress,
      parts,
      progress,
      signal,
      timeoutMs,
      url
    }) {
      var resolvedParts = yield Promise.all(parts.map(part => resolvePartUri(part, getLocalAssetUri)));
      return uploadMultipart({
        headers,
        method,
        onProgress,
        parts: resolvedParts,
        progress: getNativeProgressConfig(progress),
        signal,
        timeoutMs,
        uploadId: uploadIdFactory(),
        url
      });
    });
    return function (_x4) {
      return _ref4.apply(this, arguments);
    };
  }();
};
exports.createNativeMultipartUpload = createNativeMultipartUpload;
//# sourceMappingURL=nativeMultipartUpload.js.map