stream-chat-react-native-core 9.0.2-beta.2 → 9.1.0-beta.1

package/src/utils/installNativeMultipartAdapter.ts

@@ -0,0 +1,302 @@
+import axios from 'axios';
+import type { AxiosAdapter, AxiosProgressEvent, InternalAxiosRequestConfig } from 'axios';
+import type { StreamChat } from 'stream-chat';
+
+import {
+  isNativeMultipartUploadAvailable,
+  NativeHandlers,
+  NativeMultipartUploadProgressConfig,
+  NativeMultipartUploadRequest,
+} from '../native';
+
+type FormDataPartValue =
+  | string
+  | {
+      contentType?: string;
+      name?: string;
+      type?: string;
+      uri: string;
+    };
+
+type NativeMultipartAxiosRequestConfig = InternalAxiosRequestConfig & {
+  onUploadProgress?: (event: AxiosProgressEvent) => void;
+  uploadProgressOptions?: NativeMultipartUploadProgressConfig;
+  uploadProgress?: (event: AxiosProgressEvent) => void;
+};
+
+type ResolvableAxiosAdapter = Parameters<typeof axios.getAdapter>[0];
+
+const DEFAULT_COMPLETION_PROGRESS_CAP = 90;
+
+const installedAdapters = new WeakSet<StreamChat>();
+
+const getFormDataEntries = (data: unknown): [string, FormDataPartValue][] | null => {
+  if (!data || typeof data !== 'object') {
+    return null;
+  }
+
+  if ('entries' in data && typeof data.entries === 'function') {
+    return Array.from(data.entries()) as [string, FormDataPartValue][];
+  }
+
+  const parts = Reflect.get(data, '_parts');
+
+  if (Array.isArray(parts)) {
+    return parts as [string, FormDataPartValue][];
+  }
+
+  return null;
+};
+
+const normalizeHeaders = (
+  headers: NativeMultipartAxiosRequestConfig['headers'],
+): Record<string, string> => {
+  const rawHeaders = headers?.toJSON() ?? {};
+  const normalizedHeaders: Record<string, string> = {};
+
+  Object.entries(rawHeaders ?? {}).forEach(([key, value]) => {
+    if (value == null) {
+      return;
+    }
+
+    normalizedHeaders[key] = Array.isArray(value) ? value.join(', ') : String(value);
+  });
+
+  return normalizedHeaders;
+};
+
+const getFileNameFromUri = (uri: string) => uri.split('/').filter(Boolean).pop() || 'file';
+
+const getNativeProgressOptions = (
+  progress?: NativeMultipartUploadProgressConfig,
+): NativeMultipartUploadProgressConfig | undefined => {
+  if (!progress) {
+    return undefined;
+  }
+
+  const nativeProgressOptions = { ...progress };
+  delete nativeProgressOptions.completionProgressCap;
+
+  return Object.keys(nativeProgressOptions).length ? nativeProgressOptions : undefined;
+};
+
+const createNativeMultipartRequest = (
+  client: StreamChat,
+  config: NativeMultipartAxiosRequestConfig,
+): NativeMultipartUploadRequest | null => {
+  const entries = getFormDataEntries(config.data);
+
+  if (!entries) {
+    return null;
+  }
+
+  const parts: NativeMultipartUploadRequest['parts'] = [];
+
+  for (const [fieldName, value] of entries) {
+    if (typeof value === 'string') {
+      parts.push({
+        fieldName,
+        kind: 'text',
+        value,
+      });
+      continue;
+    }
+
+    if (value && typeof value === 'object' && 'uri' in value && typeof value.uri === 'string') {
+      parts.push({
+        fieldName,
+        fileName: value.name || getFileNameFromUri(value.uri),
+        kind: 'file',
+        mimeType: value.type || value.contentType,
+        uri: value.uri,
+      });
+      continue;
+    }
+
+    return null;
+  }
+
+  if (!parts.some((part) => part.kind === 'file')) {
+    return null;
+  }
+
+  return {
+    headers: normalizeHeaders(config.headers),
+    method: (config.method || 'POST').toUpperCase(),
+    parts,
+    progress: getNativeProgressOptions(config.uploadProgressOptions),
+    signal: config.signal,
+    timeoutMs: config.timeout,
+    url: client.axiosInstance.getUri(config),
+  };
+};
+
+const toFiniteNumber = (value: unknown) => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : undefined;
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+
+  return undefined;
+};
+
+const getCompletionProgressCap = (config: NativeMultipartAxiosRequestConfig) => {
+  const cap = toFiniteNumber(config.uploadProgressOptions?.completionProgressCap);
+  if (cap === undefined) {
+    return DEFAULT_COMPLETION_PROGRESS_CAP;
+  }
+
+  return Math.min(100, Math.max(0, cap));
+};
+
+const getDisplayLoaded = ({
+  completionProgressCap,
+  loaded,
+  total,
+}: {
+  completionProgressCap: number;
+  loaded: number;
+  total?: number;
+}) => {
+  if (typeof total !== 'number' || total <= 0) {
+    return loaded;
+  }
+
+  return Math.min(loaded, total * (completionProgressCap / 100));
+};
+
+const getUploadProgressCallbacks = (config: NativeMultipartAxiosRequestConfig) => {
+  const callbacks = [config.onUploadProgress, config.uploadProgress].filter(
+    (callback): callback is NonNullable<typeof config.onUploadProgress> =>
+      typeof callback === 'function',
+  );
+
+  return Array.from(new Set(callbacks));
+};
+
+const createUploadProgressEvent = ({
+  bytes,
+  loaded,
+  total,
+}: {
+  bytes: unknown;
+  loaded: unknown;
+  total?: unknown;
+}) => {
+  const normalizedBytes = toFiniteNumber(bytes) ?? 0;
+  const normalizedLoaded = toFiniteNumber(loaded) ?? 0;
+  const normalizedTotal = toFiniteNumber(total);
+
+  return {
+    bytes: normalizedBytes,
+    download: false,
+    event: undefined,
+    lengthComputable: typeof normalizedTotal === 'number' && normalizedTotal > 0,
+    loaded: normalizedLoaded,
+    progress:
+      typeof normalizedTotal === 'number' && normalizedTotal > 0
+        ? normalizedLoaded / normalizedTotal
+        : undefined,
+    total: normalizedTotal,
+    upload: true,
+  };
+};
+
+const nativeMultipartAxiosAdapter = async (
+  request: NativeMultipartUploadRequest,
+  config: NativeMultipartAxiosRequestConfig,
+) => {
+  const uploadProgressCallbacks = getUploadProgressCallbacks(config);
+  const completionProgressCap = getCompletionProgressCap(config);
+  let lastLoaded = 0;
+
+  const response = await NativeHandlers.multipartUpload({
+    ...request,
+    onProgress: uploadProgressCallbacks.length
+      ? ({ loaded, total }) => {
+          const normalizedLoaded = toFiniteNumber(loaded) ?? 0;
+          const normalizedTotal = toFiniteNumber(total);
+          const displayLoaded = getDisplayLoaded({
+            completionProgressCap,
+            loaded: normalizedLoaded,
+            total: normalizedTotal,
+          });
+          const event = createUploadProgressEvent({
+            bytes: Math.max(0, displayLoaded - lastLoaded),
+            loaded: displayLoaded,
+            total: normalizedTotal,
+          });
+          lastLoaded = displayLoaded;
+          uploadProgressCallbacks.forEach((callback) => callback(event));
+        }
+      : undefined,
+  });
+
+  if (!response) {
+    throw new Error('Native multipart upload did not return a response');
+  }
+
+  return {
+    config,
+    data: response.body,
+    headers: response.headers ?? {},
+    request: null,
+    status: response.status,
+    statusText: response.statusText ?? '',
+  };
+};
+
+const resolveAxiosAdapter = (adapter: ResolvableAxiosAdapter): AxiosAdapter =>
+  axios.getAdapter(adapter);
+
+const createNativeMultipartAwareAdapter = (
+  client: StreamChat,
+  fallbackAdapter: ResolvableAxiosAdapter,
+): AxiosAdapter => {
+  const resolvedFallbackAdapter = resolveAxiosAdapter(fallbackAdapter);
+
+  return (config) => {
+    const nativeMultipartRequest = createNativeMultipartRequest(
+      client,
+      config as NativeMultipartAxiosRequestConfig,
+    );
+
+    if (!nativeMultipartRequest) {
+      return resolvedFallbackAdapter(config);
+    }
+
+    return nativeMultipartAxiosAdapter(nativeMultipartRequest, config);
+  };
+};
+
+export const wrapAxiosAdapterWithNativeMultipart = (
+  client: StreamChat,
+  fallbackAdapter: ResolvableAxiosAdapter,
+): AxiosAdapter => {
+  if (!isNativeMultipartUploadAvailable()) {
+    return resolveAxiosAdapter(fallbackAdapter);
+  }
+
+  return createNativeMultipartAwareAdapter(client, fallbackAdapter);
+};
+
+export const installNativeMultipartAdapter = (client: StreamChat) => {
+  if (!isNativeMultipartUploadAvailable()) {
+    return;
+  }
+
+  if (installedAdapters.has(client)) {
+    return;
+  }
+
+  const previousAdapter = client.axiosInstance.defaults.adapter;
+  client.axiosInstance.defaults.adapter = wrapAxiosAdapterWithNativeMultipart(
+    client,
+    previousAdapter,
+  );
+  installedAdapters.add(client);
+};

package/src/utils/utils.ts

@@ -57,14 +57,14 @@ type IndicatorStatesMap = Record<AttachmentLoadingState, Progress | undefined>;
 
 export const getIndicatorTypeForFileState = (
   fileState: AttachmentLoadingState,
-  enableOfflineSupport: boolean,
+  allowSendBeforeAttachmentsUpload: boolean,
 ): Progress | undefined => {
   const indicatorMap: IndicatorStatesMap = {
-    [FileState.UPLOADING]: enableOfflineSupport
+    [FileState.UPLOADING]: allowSendBeforeAttachmentsUpload
       ? ProgressIndicatorTypes.INACTIVE
       : ProgressIndicatorTypes.IN_PROGRESS,
     [FileState.BLOCKED]: ProgressIndicatorTypes.NOT_SUPPORTED,
-    [FileState.FAILED]: enableOfflineSupport
+    [FileState.FAILED]: allowSendBeforeAttachmentsUpload
       ? ProgressIndicatorTypes.INACTIVE
       : ProgressIndicatorTypes.RETRY,
     [FileState.PENDING]: ProgressIndicatorTypes.PENDING,

package/src/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "9.0.2-beta.2"
+  "version": "9.1.0-beta.1"
 }