@stream-io/video-react-native-sdk 1.39.0 → 1.40.0

package/src/hooks/useLoopbackRecording.ts

@@ -0,0 +1,448 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { NativeModules } from 'react-native';
+import { combineLatest } from 'rxjs';
+import {
+  Call,
+  CallingState,
+  videoLoggerSystem,
+  type StreamVideoParticipant,
+} from '@stream-io/video-client';
+import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
+
+/** @internal */
+const { StreamVideoReactNative } = NativeModules;
+
+// Upper bound on how long `startRecording` will wait for the SFU to
+// echo loopback tracks back via the Subscriber. Tuned generously since
+// this includes connection setup; consumers that want shorter feedback
+// should call `stopRecording` to cancel the wait early.
+const STREAMS_WAIT_TIMEOUT_MS = 10 * 1000;
+const DEFAULT_RECORDING_DURATION = 10 * 1000;
+const MIN_RECORDING_DURATION = 5 * 1000;
+const MAX_RECORDING_DURATION = 2 * 60 * 1000;
+
+type LoopbackStreams = {
+  loopbackVideoStream?: MediaStream;
+  loopbackAudioStream?: MediaStream;
+};
+
+export type LoopbackRecordingState = 'idle' | 'awaiting-streams' | 'recording';
+
+export type ResolvedStreams = {
+  audioTrack?: MediaStreamTrack;
+  videoTrack?: MediaStreamTrack;
+};
+
+export interface StartLoopbackRecordingOptions {
+  /**
+   * Whether to include the loopback video track in the recording.
+   * Defaults to `true`. Set to `false` for an audio-only recording.
+   * Audio is always recorded — there is no video-only mode.
+   */
+  includeVideo?: boolean;
+  /**
+   * Maximum recording duration in milliseconds, after which the
+   * recording auto-stops and finalises the file.
+   *
+   * Defaults to `10_000` (10 seconds). Clamped to
+   * `[5_000, 120_000]` (5 seconds — 2 minutes).
+   */
+  maxDurationMs?: number;
+}
+
+export interface UseLoopbackRecordingResult {
+  /**
+   * Start a recording. The hook waits internally for the SFU loopback
+   * streams to arrive on `localParticipant`, then begins recording.
+   *
+   * The returned promise resolves with the produced `file://` URI **at
+   * the recording's terminal moment** — whether that is the auto-stop
+   * timer expiring, an explicit `stopRecording` call, or a cleanup-
+   * driven stop on unmount/leave. Resolves with `null` if no file was
+   * produced (writer torn down before any buffer arrived, or
+   * `stopRecording` was called while still awaiting streams). Rejects
+   * on a fatal error, if a recording is already running, or if the
+   * stream-wait times out.
+   */
+  startRecording: (
+    options?: StartLoopbackRecordingOptions,
+  ) => Promise<string | null>;
+  /**
+   * Signal an early termination. While `awaiting-streams` this aborts
+   * the wait and the pending `startRecording` resolves with `null`.
+   * While `recording` this signals native finalisation and resolves
+   * once it completes.
+   */
+  stopRecording: () => Promise<void>;
+  /**
+   * Recursively delete every file under the SDK's recordings directory.
+   */
+  clearRecordings: () => Promise<void>;
+  /**
+   * List every `file://` URI in the SDK's recordings directory, sorted
+   * most-recent first. Returns an empty array if the directory doesn't
+   * exist yet.
+   */
+  getRecordings: () => Promise<string[]>;
+  /**
+   * Lifecycle phase of the recording, owned by the hook:
+   *  - `'idle'`: no recording in progress.
+   *  - `'awaiting-streams'`: `startRecording` was called but the SFU
+   *    has not yet echoed the loopback tracks back.
+   *  - `'recording'`: native pipeline is actively writing.
+   */
+  recordingState: LoopbackRecordingState;
+  /**
+   * The SFU loopback video stream on the local participant, when
+   * present. Identified by reference inequality against
+   * `call.camera.state.mediaStream`.
+   */
+  loopbackVideoStream?: MediaStream;
+  /**
+   * The SFU loopback audio stream on the local participant, when
+   * present. Identified by reference inequality against
+   * `call.microphone.state.mediaStream`.
+   */
+  loopbackAudioStream?: MediaStream;
+}
+
+/**
+ * Records the SFU loopback streams (audio + video) on the local participant
+ * to a local MP4 file. Designed for the `allowOwnTracksLoopback` pre-call test mode:
+ * the SFU echoes the caller's published tracks back through the Subscriber
+ * peer connection. The hook identifies the loopback streams on the local
+ * participant by reference inequality against
+ * `call.camera.state.mediaStream` / `call.microphone.state.mediaStream` —
+ * the canonical references to the local capture — and captures them.
+ */
+export function useLoopbackRecording(): UseLoopbackRecordingResult {
+  const call = useCall();
+  const {
+    useCallCallingState,
+    useParticipantCount,
+    useLocalParticipant,
+    useCameraState,
+    useMicrophoneState,
+  } = useCallStateHooks();
+  const callingState = useCallCallingState();
+  const participantCount = useParticipantCount();
+  const localParticipant = useLocalParticipant();
+  const { mediaStream: cameraStream } = useCameraState();
+  const { mediaStream: microphoneStream } = useMicrophoneState();
+
+  const [recordingState, setRecordingState] =
+    useState<LoopbackRecordingState>('idle');
+  const recordingStateRef = useRef<LoopbackRecordingState>('idle');
+  const isMountedRef = useRef(true);
+  // Used to abort the awaiting-streams wait on stop / leave / unmount.
+  const awaitAbortRef = useRef<AbortController | null>(null);
+
+  const loopbackStreams = useMemo<LoopbackStreams>(
+    () =>
+      getLoopbackStreamsFor(localParticipant, cameraStream, microphoneStream),
+    [localParticipant, cameraStream, microphoneStream],
+  );
+
+  const updateState = useCallback((next: LoopbackRecordingState) => {
+    recordingStateRef.current = next;
+    if (isMountedRef.current) {
+      setRecordingState(next);
+    }
+  }, []);
+
+  const stopRecording = useCallback(async (): Promise<void> => {
+    const current = recordingStateRef.current;
+    if (current === 'idle') {
+      return;
+    }
+
+    if (current === 'awaiting-streams') {
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .debug('aborting awaiting-streams wait');
+      awaitAbortRef.current?.abort();
+      return;
+    }
+
+    try {
+      await StreamVideoReactNative.stopTrackRecording();
+    } catch (error) {
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .error('failed to stop recording', error);
+      throw new Error('failed to stop recording');
+    }
+  }, []);
+
+  const startRecording = useCallback(
+    async ({
+      includeVideo = true,
+      maxDurationMs = DEFAULT_RECORDING_DURATION,
+    }: StartLoopbackRecordingOptions = {}): Promise<string | null> => {
+      if (!call) {
+        return null;
+      }
+
+      if (recordingStateRef.current !== 'idle') {
+        videoLoggerSystem
+          .getLogger('useLoopbackRecording')
+          .warn('a recording is already running');
+        return null;
+      }
+
+      if (call.state.participantCount > 1) {
+        videoLoggerSystem
+          .getLogger('useLoopbackRecording')
+          .warn('cannot start recording with other participants present');
+        return null;
+      }
+
+      awaitAbortRef.current = new AbortController();
+      updateState('awaiting-streams');
+
+      let audioTrack: MediaStreamTrack | undefined;
+      try {
+        const streams = await waitForLoopbackStreams(call, {
+          includeVideo,
+          signal: awaitAbortRef.current.signal,
+          timeoutMs: STREAMS_WAIT_TIMEOUT_MS,
+        });
+
+        if (streams === null) {
+          videoLoggerSystem
+            .getLogger('useLoopbackRecording')
+            .warn('timed out waiting for loopback streams');
+          return null;
+        }
+
+        audioTrack = streams.audioTrack;
+        const videoTrackId = streams.videoTrack?.id;
+
+        // The loopback audio track lands disabled (the SDK default-mutes
+        // it to prevent echo). Enable it so the native recording
+        // pipeline receives PCM; `finally` returns it to muted.
+        if (audioTrack) {
+          audioTrack.enabled = true;
+        }
+        updateState('recording');
+
+        const clampedDuration = Math.min(
+          MAX_RECORDING_DURATION,
+          Math.max(MIN_RECORDING_DURATION, maxDurationMs),
+        );
+
+        // Pre-size the native encoder to the publisher's max video
+        // publish-option dimension. Without this, the encoder locks to
+        // whatever the SFU happens to echo *first* and stays there for the
+        // rest of the recording even after the network improves and
+        // higher layers arrive.
+        const publishMaxDim = call.getMaxVideoPublishDimension();
+
+        try {
+          const uri: string | null =
+            await StreamVideoReactNative.startTrackRecording({
+              videoTrackId,
+              maxDurationMs: Math.round(clampedDuration),
+              targetWidth: publishMaxDim?.width,
+              targetHeight: publishMaxDim?.height,
+            });
+          return uri;
+        } catch (error) {
+          videoLoggerSystem
+            .getLogger('useLoopbackRecording')
+            .error('failed to start recording', error);
+          throw new Error('failed to start recording');
+        }
+      } finally {
+        if (audioTrack) {
+          audioTrack.enabled = false;
+        }
+        awaitAbortRef.current = null;
+        updateState('idle');
+      }
+    },
+    [call, updateState],
+  );
+
+  const clearRecordings = useCallback(async (): Promise<void> => {
+    try {
+      await StreamVideoReactNative.clearStreamRecordings();
+    } catch (error) {
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .error('failed to clear recordings', error);
+      throw new Error('failed to clear recordings');
+    }
+  }, []);
+
+  const getRecordings = useCallback(async (): Promise<string[]> => {
+    try {
+      const list: string[] | null | undefined =
+        await StreamVideoReactNative.getStreamRecordings();
+      return list ?? [];
+    } catch (error) {
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .error('failed to get recordings', error);
+      throw new Error('failed to get recordings');
+    }
+  }, []);
+
+  // Auto-stop on call leave / end. Aborts an awaiting-streams wait or
+  // signals native finalisation depending on which phase we're in.
+  // Without this, leaving the call mid-recording would leave native
+  // encoders mid-write while the SFU subscriber tracks end under their
+  // feet — undefined final file state.
+  useEffect(() => {
+    if (
+      callingState === CallingState.LEFT ||
+      callingState === CallingState.IDLE
+    ) {
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .debug('auto-stopping recording on call leave / end');
+      stopRecording().catch(() => {});
+    }
+  }, [callingState, stopRecording]);
+
+  // Auto-stop if another participant joins. Loopback recording is a
+  // single-user pre-call test.
+  useEffect(() => {
+    if (recordingState !== 'idle' && participantCount > 1) {
+      stopRecording().catch(() => {});
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .debug('auto-stopping recording on participant count change');
+    }
+  }, [participantCount, recordingState, stopRecording]);
+
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      videoLoggerSystem
+        .getLogger('useLoopbackRecording')
+        .debug('auto-stopping recording on unmount');
+      stopRecording().catch(() => {});
+    };
+  }, [stopRecording]);
+
+  return {
+    startRecording,
+    stopRecording,
+    clearRecordings,
+    getRecordings,
+    recordingState,
+    loopbackVideoStream: loopbackStreams.loopbackVideoStream,
+    loopbackAudioStream: loopbackStreams.loopbackAudioStream,
+  };
+}
+
+function getLoopbackStreamsFor(
+  participant: StreamVideoParticipant | undefined,
+  cameraStream: MediaStream | undefined,
+  microphoneStream: MediaStream | undefined,
+): LoopbackStreams {
+  return {
+    loopbackVideoStream:
+      participant?.videoStream && participant.videoStream !== cameraStream
+        ? participant.videoStream
+        : undefined,
+    loopbackAudioStream:
+      participant?.audioStream && participant.audioStream !== microphoneStream
+        ? participant.audioStream
+        : undefined,
+  };
+}
+
+/**
+ * Subscribe to `localParticipant$` and resolve once the requested loopback
+ * streams are present on the participant. Aborts cleanly on `signal`
+ * (resolves `null`) and rejects on timeout.
+ */
+function waitForLoopbackStreams(
+  call: Call,
+  opts: { includeVideo: boolean; signal: AbortSignal; timeoutMs: number },
+): Promise<ResolvedStreams | null> {
+  return new Promise((resolve, reject) => {
+    const initial = getLoopbackStreams(
+      call.state.localParticipant,
+      call.camera.state.mediaStream,
+      call.microphone.state.mediaStream,
+      opts.includeVideo,
+    );
+    if (initial) {
+      resolve(initial);
+      return;
+    }
+
+    const cleanup = () => {
+      subscription.unsubscribe();
+      if (timeoutId !== undefined) {
+        clearTimeout(timeoutId);
+      }
+      opts.signal.removeEventListener('abort', onAbort);
+    };
+
+    const onAbort = () => {
+      cleanup();
+      resolve(null);
+    };
+
+    opts.signal.addEventListener('abort', onAbort);
+
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      reject(
+        new Error(
+          'useLoopbackRecording: timed out waiting for loopback streams. ' +
+            'Ensure the call was joined with `allowOwnTracksLoopback: true` and ' +
+            'that the SFU is configured to echo self-sub tracks.',
+        ),
+      );
+    }, opts.timeoutMs);
+
+    const subscription = combineLatest([
+      call.state.localParticipant$,
+      call.camera.state.mediaStream$,
+      call.microphone.state.mediaStream$,
+    ]).subscribe(([participant, cameraStream, microphoneStream]) => {
+      const ready = getLoopbackStreams(
+        participant,
+        cameraStream,
+        microphoneStream,
+        opts.includeVideo,
+      );
+      if (ready) {
+        cleanup();
+        resolve(ready);
+      }
+    });
+  });
+}
+
+function getLoopbackStreams(
+  participant: StreamVideoParticipant | undefined,
+  cameraStream: MediaStream | undefined,
+  microphoneStream: MediaStream | undefined,
+  includeVideo: boolean,
+): ResolvedStreams | undefined {
+  if (!participant) return undefined;
+
+  const { loopbackAudioStream, loopbackVideoStream } = getLoopbackStreamsFor(
+    participant,
+    cameraStream,
+    microphoneStream,
+  );
+
+  const audioTrack = loopbackAudioStream?.getAudioTracks()[0];
+  const videoTrack = includeVideo
+    ? loopbackVideoStream?.getVideoTracks()[0]
+    : undefined;
+
+  if (!audioTrack || (includeVideo && !videoTrack)) {
+    return undefined;
+  }
+
+  return { audioTrack, videoTrack };
+}

package/src/hooks/useModeration.ts

@@ -37,7 +37,10 @@ export const useModeration = (options?: ModerationOptions) => {
 
       // not scheduling a timeout to enable the camera
       clearTimeout(blurTimeoutRef.current);
-      if (!isSupported) return turnCameraOff();
+      if (!isSupported) {
+        void turnCameraOff();
+        return;
+      }
 
       restoreRef.current = (restoreRef.current || Promise.resolve()).then(() =>
         applyVideoBlurFilter?.('heavy').then(() => {

package/src/icons/index.tsx

@@ -4,21 +4,15 @@ export * from './Mic';
 export * from './MicOff';
 export * from './Phone';
 export * from './PhoneDown';
-export * from './Settings';
 export * from './Video';
 export * from './VideoSlash';
-export * from './ThreeDots';
 export * from './PinVertical';
-export * from './Spotlight';
 export * from './ScreenShareIndicator';
 export * from './ScreenShare';
 export * from './Reaction';
-export * from './TopViewBackground';
 export * from './Eye';
-export * from './ShieldBadge';
 export * from './StartStreamIcon';
 export * from './StopScreenShare';
 export * from './EndStreamIcon';
-export * from './LeaveStreamIcon';
 export * from './IconWrapper';
 export * from './Maximize';

package/src/providers/BusyTonePlayer.tsx

@@ -16,15 +16,14 @@ const BusyTonePlayer = () => {
       return;
     }
 
+    const logger = videoLoggerSystem.getLogger('RejectCallWhenBusy');
+    let busyToneTimeout: ReturnType<typeof setTimeout> | undefined;
+
     const unsubscribe = client.on('call.rejected', async (event) => {
       const isCallCreatedByMe =
         event.call.created_by.id === client.state.connectedUser?.id;
       const isCalleeBusy = isCallCreatedByMe && event.reason === 'busy';
 
-      let busyToneTimeout: ReturnType<typeof setTimeout> | undefined;
-
-      const logger = videoLoggerSystem.getLogger('RejectCallWhenBusy');
-
       if (isCalleeBusy) {
         if (busyToneTimeout) {
           clearTimeout(busyToneTimeout);
@@ -51,14 +50,15 @@ const BusyTonePlayer = () => {
             logger.error('playBusyTone failed:', error);
           });
       }
-      return () => {
-        StreamVideoRN.stopBusyTone().catch((err) =>
-          logger.error('stopBusyTone on cleanup failed:', err),
-        );
-        clearTimeout(busyToneTimeout);
-        unsubscribe();
-      };
     });
+
+    return () => {
+      clearTimeout(busyToneTimeout);
+      StreamVideoRN.stopBusyTone().catch((err) =>
+        logger.error('stopBusyTone on cleanup failed:', err),
+      );
+      unsubscribe();
+    };
   }, [client]);
 
   return null;

package/src/providers/StreamCall/AppStateListener.tsx

@@ -31,6 +31,7 @@ export const AppStateListener = () => {
       return;
     }
 
+    let cancelled = false;
     const disablePiP = RxUtils.getCurrentValue(disablePiPMode$);
     const logger = videoLoggerSystem.getLogger('AppStateListener');
     const initialPipMode =
@@ -40,6 +41,7 @@ export const AppStateListener = () => {
 
     NativeModules?.StreamVideoReactNative?.isInPiPMode().then(
       (isInPiP: boolean | null | undefined) => {
+        if (cancelled) return;
         isInPiPMode$.next(!!isInPiP);
         logger.debug(
           'Initial PiP mode on mount (after asking native module) set to ',
@@ -60,6 +62,7 @@ export const AppStateListener = () => {
     );
 
     return () => {
+      cancelled = true;
       subscriptionPiPChange.remove();
     };
   }, []);

package/src/providers/StreamCall/DeviceStats.tsx

@@ -8,7 +8,6 @@ import {
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 
 const { StreamVideoReactNative } = NativeModules;
-const eventEmitter = new NativeEventEmitter(StreamVideoReactNative);
 /**
  * This is a renderless component to get the device stats like thermal state and power saver mode.
  */
@@ -20,6 +19,8 @@ export const DeviceStats = () => {
   useEffect(() => {
     if (!call || callingState !== CallingState.JOINED) return;
 
+    const eventEmitter = new NativeEventEmitter(StreamVideoReactNative);
+
     StreamVideoReactNative.isLowPowerModeEnabled().then(
       (initialPowerMode: boolean) => {
         setPowerState(initialPowerMode);

package/src/utils/StreamVideoRN/index.ts

@@ -62,7 +62,6 @@ const DEFAULT_STREAM_VIDEO_CONFIG: StreamVideoConfig = {
 
 export class StreamVideoRN {
   private static config = DEFAULT_STREAM_VIDEO_CONFIG;
-  private static busyToneTimeout: NodeJS.Timeout | null = null;
 
   /**
    * Update the global config for StreamVideoRN except for push config.

package/src/utils/internal/callingx/callingx.ts

@@ -31,16 +31,18 @@ export function getCallDisplayName(
 
   if (callMembers.length > 0) {
     // for ringing calls, members array contains all call members from the very early state and participants array is empty in the beginning
-    names = callMembers
-      .filter((member) => member.user.id !== currentUserId)
-      .map((member) => member.user.name)
-      .filter((name): name is string => name !== undefined);
+    names = callMembers.flatMap((member) =>
+      member.user.id !== currentUserId && member.user.name
+        ? [member.user.name]
+        : [],
+    );
   } else if (participants.length > 0) {
     // for non-ringing calls, members array is empty and we rely on participants array there
-    names = participants
-      .filter((participant) => participant.userId !== currentUserId)
-      .map((participant) => participant.name)
-      .filter(Boolean);
+    names = participants.flatMap((participant) =>
+      participant.userId !== currentUserId && participant.name
+        ? [participant.name]
+        : [],
+    );
   }
 
   // if no names are found, we use the name of the current user
@@ -66,7 +68,11 @@ function getCallDisplayNameFromCall(call: Call): string {
 }
 
 export async function registerOutgoingCall(call: Call) {
-  if (!CallingxModule || !CallingxModule.isSetup) {
+  if (
+    !CallingxModule ||
+    !CallingxModule.isSetup ||
+    call.isOwnTracksLoopbackAllowed
+  ) {
     return;
   }
 
@@ -103,7 +109,11 @@ export async function registerOutgoingCall(call: Call) {
  * 3. Optionally for non-ringing calls also when ongoing calls are enabled.
  */
 export async function joinCallingxCall(call: Call, activeCalls: Call[]) {
-  if (!CallingxModule || !CallingxModule.isSetup) {
+  if (
+    !CallingxModule ||
+    !CallingxModule.isSetup ||
+    call.isOwnTracksLoopbackAllowed
+  ) {
     return;
   }
 

package/src/utils/internal/registerSDKGlobals.ts

@@ -128,7 +128,7 @@ const streamRNVideoSDKGlobals: StreamRNVideoSDKGlobals = {
 // @stream-io/video-client/src/types.ts and is automatically available when
 // importing from the client package.
 export function registerSDKGlobals() {
-  if (!global.streamRNVideoSDK) {
-    global.streamRNVideoSDK = streamRNVideoSDKGlobals;
+  if (!globalThis.streamRNVideoSDK) {
+    globalThis.streamRNVideoSDK = streamRNVideoSDKGlobals;
   }
 }

package/src/utils/push/libs/firebaseMessaging/index.ts

@@ -7,7 +7,7 @@ export type FirebaseMessagingType = Type;
 const INSTALLATION_INSTRUCTION =
   'Please see https://rnfirebase.io/messaging/usage#installation for installation instructions';
 
-export function getFirebaseMessagingLib() {
+export function getFirebaseMessagingLib(): FirebaseMessagingType {
   if (!lib) {
     throw Error(
       '@react-native-firebase/messaging is not installed. ' +
@@ -17,7 +17,9 @@ export function getFirebaseMessagingLib() {
   return lib;
 }
 
-export function getFirebaseMessagingLibNoThrow(isExpo: boolean) {
+export function getFirebaseMessagingLibNoThrow(
+  isExpo: boolean,
+): FirebaseMessagingType | undefined {
   if (!lib) {
     const logger = videoLoggerSystem.getLogger(
       'getFirebaseMessagingLibNoThrow',

package/src/version.ts

@@ -1 +1 @@
-export const version = '1.39.0';
+export const version = '1.40.0';

package/dist/commonjs/icons/LeaveStreamIcon.js

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.LeaveStreamIcon = void 0;
-var _react = _interopRequireDefault(require("react"));
-var _reactNativeSvg = require("react-native-svg");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const LeaveStreamIcon = () => {
-  return /*#__PURE__*/_react.default.createElement(_reactNativeSvg.Svg, {
-    viewBox: "0 0 25 24",
-    fill: "none"
-  }, /*#__PURE__*/_react.default.createElement(_reactNativeSvg.Path, {
-    d: "M18.75 5.75L16.9875 7.5125L20.2125 10.75H7.5V13.25H20.2125L16.9875 16.475L18.75 18.25L25 12L18.75 5.75ZM2.5 3.25H12.5V0.75H2.5C1.125 0.75 0 1.875 0 3.25V20.75C0 22.125 1.125 23.25 2.5 23.25H12.5V20.75H2.5V3.25Z",
-    fill: "#FCFCFC"
-  }));
-};
-exports.LeaveStreamIcon = LeaveStreamIcon;
-//# sourceMappingURL=LeaveStreamIcon.js.map

package/dist/commonjs/icons/LeaveStreamIcon.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_react","_interopRequireDefault","require","_reactNativeSvg","e","__esModule","default","LeaveStreamIcon","createElement","Svg","viewBox","fill","Path","d","exports"],"sourceRoot":"../../../src","sources":["icons/LeaveStreamIcon.tsx"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,eAAA,GAAAD,OAAA;AAA6C,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEtC,MAAMG,eAAe,GAAGA,CAAA,KAAM;EACnC,oBACEP,MAAA,CAAAM,OAAA,CAAAE,aAAA,CAACL,eAAA,CAAAM,GAAG;IAACC,OAAO,EAAC,WAAW;IAACC,IAAI,EAAC;EAAM,gBAClCX,MAAA,CAAAM,OAAA,CAAAE,aAAA,CAACL,eAAA,CAAAS,IAAI;IACHC,CAAC,EAAC,oNAAoN;IACtNF,IAAI,EAAC;EAAS,CACf,CACE,CAAC;AAEV,CAAC;AAACG,OAAA,CAAAP,eAAA,GAAAA,eAAA","ignoreList":[]}