shakebug-react-native 1.0.14

package/ImageOrVedioPicker/src/index.ts

@@ -0,0 +1,28 @@
+import {Platform} from 'react-native';
+
+import {CameraOptions, ImageLibraryOptions, Callback} from './types';
+import {
+  imageLibrary as nativeImageLibrary,
+  camera as nativeCamera,
+} from './platforms/native';
+import {
+  imageLibrary as webImageLibrary,
+  camera as webCamera,
+} from './platforms/web';
+
+export * from './types';
+
+export function launchCamera(options: CameraOptions, callback?: Callback) {
+  return Platform.OS === 'web'
+    ? webCamera(options, callback)
+    : nativeCamera(options, callback);
+}
+
+export function launchImageLibrary(
+  options: ImageLibraryOptions,
+  callback?: Callback,
+) {
+  return Platform.OS === 'web'
+    ? webImageLibrary(options, callback)
+    : nativeImageLibrary(options, callback);
+}

package/ImageOrVedioPicker/src/platforms/NativeImagePicker.ts

@@ -0,0 +1,10 @@
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  launchCamera(options: Object, callback: () => void): void;
+  launchImageLibrary(options: Object, callback: () => void): void;
+}
+export default TurboModuleRegistry.get<Spec>(
+  'ShakebugSDKImagePicker'
+);

package/ImageOrVedioPicker/src/platforms/native.ts

@@ -0,0 +1,61 @@
+import {NativeModules} from 'react-native';
+
+import {
+  CameraOptions,
+  ImageLibraryOptions,
+  Callback,
+  ImagePickerResponse,
+} from 'react-native-library-testing/ImageOrVedioPicker/src/types';
+
+const DEFAULT_OPTIONS: ImageLibraryOptions & CameraOptions = {
+  mediaType: 'photo',
+  videoQuality: 'high',
+  quality: 1,
+  maxWidth: 0,
+  maxHeight: 0,
+  includeBase64: false,
+  cameraType: 'back',
+  selectionLimit: 1,
+  saveToPhotos: false,
+  durationLimit: 0,
+  includeExtra: false,
+  presentationStyle: 'pageSheet',
+  assetRepresentationMode: 'auto',
+};
+
+// @ts-ignore We want to check whether __turboModuleProxy exitst, it may not
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+
+const nativeImagePicker = isTurboModuleEnabled ?
+  require("./NativeImagePicker").default :
+  NativeModules.ShakebugSDKImagePicker;
+
+export function camera(
+  options: CameraOptions,
+  callback?: Callback,
+): Promise<ImagePickerResponse> {
+  return new Promise((resolve) => {
+    nativeImagePicker.launchCamera(
+      {...DEFAULT_OPTIONS, ...options},
+      (result: ImagePickerResponse) => {
+        if (callback) callback(result);
+        resolve(result);
+      },
+    );
+  });
+}
+
+export function imageLibrary(
+  options: ImageLibraryOptions,
+  callback?: Callback,
+): Promise<ImagePickerResponse> {
+  return new Promise((resolve) => {
+    nativeImagePicker.launchImageLibrary(
+      {...DEFAULT_OPTIONS, ...options},
+      (result: ImagePickerResponse) => {
+        if (callback) callback(result);
+        resolve(result);
+      },
+    );
+  });
+}

package/ImageOrVedioPicker/src/platforms/web.ts

@@ -0,0 +1,159 @@
+import {
+    CameraOptions,
+    ImageLibraryOptions,
+    Callback,
+    ImagePickerResponse,
+    ErrorCode,
+    Asset,
+    MediaType,
+  } from 'react-native-library-testing/ImageOrVedioPicker/src/types';
+  
+  const DEFAULT_OPTIONS: Pick<
+    ImageLibraryOptions & CameraOptions,
+    'mediaType' | 'includeBase64' | 'selectionLimit'
+  > = {
+    mediaType: 'photo',
+    includeBase64: false,
+    selectionLimit: 1,
+  };
+  
+  export function camera(
+    options: ImageLibraryOptions = DEFAULT_OPTIONS,
+    callback?: Callback,
+  ): Promise<ImagePickerResponse> {
+    return new Promise((resolve) => {
+      const result = {
+        errorCode: 'camera_unavailable' as ErrorCode,
+        errorMessage: 'launchCamera is not supported for web yet',
+      };
+  
+      if (callback) callback(result);
+  
+      resolve(result);
+    });
+  }
+  
+  export function imageLibrary(
+    options: ImageLibraryOptions = DEFAULT_OPTIONS,
+    callback?: Callback,
+  ): Promise<ImagePickerResponse> {
+    // Only supporting 'photo' mediaType for now.
+    if (options.mediaType !== 'photo') {
+      const result = {
+        errorCode: 'others' as ErrorCode,
+        errorMessage: 'For now, only photo mediaType is supported for web',
+      };
+  
+      if (callback) callback(result);
+  
+      return Promise.resolve(result);
+    }
+  
+    const input = document.createElement('input');
+    input.style.display = 'none';
+    input.setAttribute('type', 'file');
+    input.setAttribute('accept', getWebMediaType(options.mediaType));
+  
+    if (options.selectionLimit! > 1) {
+      input.setAttribute('multiple', 'multiple');
+    }
+  
+    document.body.appendChild(input);
+  
+    return new Promise((resolve) => {
+      input.addEventListener('change', async () => {
+        if (input.files) {
+          if (options.selectionLimit! <= 1) {
+            const img = await readFile(input.files[0], {
+              includeBase64: options.includeBase64,
+            });
+  
+            const result = {assets: [img]};
+  
+            if (callback) callback(result);
+  
+            resolve(result);
+          } else {
+            const imgs = await Promise.all(
+              Array.from(input.files).map((file) =>
+                readFile(file, {includeBase64: options.includeBase64}),
+              ),
+            );
+  
+            const result = {
+              didCancel: false,
+              assets: imgs,
+            };
+  
+            if (callback) callback(result);
+  
+            resolve(result);
+          }
+        }
+        document.body.removeChild(input);
+      });
+  
+      const event = new MouseEvent('click');
+      input.dispatchEvent(event);
+    });
+  }
+  
+  function readFile(
+    targetFile: Blob,
+    options: Partial<ImageLibraryOptions>,
+  ): Promise<Asset> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onerror = () => {
+        reject(
+          new Error(
+            `Failed to read the selected media because the operation failed.`,
+          ),
+        );
+      };
+      reader.onload = ({target}) => {
+        const uri = target?.result;
+  
+        const returnRaw = () =>
+          resolve({
+            uri: uri as string,
+            width: 0,
+            height: 0,
+          });
+  
+        if (typeof uri === 'string') {
+          const image = new Image();
+          image.src = uri;
+          image.onload = () =>
+            resolve({
+              uri,
+              width: image.naturalWidth ?? image.width,
+              height: image.naturalHeight ?? image.height,
+              // The blob's result cannot be directly decoded as Base64 without
+              // first removing the Data-URL declaration preceding the
+              // Base64-encoded data. To retrieve only the Base64 encoded string,
+              // first remove data:*/*;base64, from the result.
+              // https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsDataURL
+              ...(options.includeBase64 && {
+                base64: uri.substr(uri.indexOf(',') + 1),
+              }),
+            });
+          image.onerror = () => returnRaw();
+        } else {
+          returnRaw();
+        }
+      };
+  
+      reader.readAsDataURL(targetFile);
+    });
+  }
+  
+  function getWebMediaType(mediaType: MediaType) {
+    const webMediaTypes = {
+      photo: 'image/*',
+      video: 'video/*',
+      mixed: 'image/*,video/*',
+    };
+  
+    return webMediaTypes[mediaType] ?? webMediaTypes.photo;
+  }

package/ImageOrVedioPicker/src/types.ts

@@ -0,0 +1,74 @@
+export type Callback = (response: ImagePickerResponse) => any;
+
+export interface OptionsCommon {
+  mediaType: MediaType;
+  maxWidth?: number;
+  maxHeight?: number;
+  quality?: PhotoQuality;
+  videoQuality?: AndroidVideoOptions | iOSVideoOptions;
+  includeBase64?: boolean;
+  includeExtra?: boolean;
+  formatAsMp4?: boolean;
+  presentationStyle?:
+    | 'currentContext'
+    | 'fullScreen'
+    | 'pageSheet'
+    | 'formSheet'
+    | 'popover'
+    | 'overFullScreen'
+    | 'overCurrentContext'
+    assetRepresentationMode?:
+    | 'auto'
+    | 'current'
+    | 'compatible';
+}
+
+export interface ImageLibraryOptions extends OptionsCommon {
+  selectionLimit?: number;
+}
+
+export interface CameraOptions extends OptionsCommon {
+  durationLimit?: number;
+  saveToPhotos?: boolean;
+  cameraType?: CameraType;
+}
+
+export interface Asset {
+  base64?: string;
+  uri?: string;
+  width?: number;
+  height?: number;
+  originalPath?: string;
+  fileSize?: number;
+  type?: string;
+  fileName?: string;
+  duration?: number;
+  bitrate?: number;
+  timestamp?: string;
+  id?: string;
+}
+
+export interface ImagePickerResponse {
+  didCancel?: boolean;
+  errorCode?: ErrorCode;
+  errorMessage?: string;
+  assets?: Asset[];
+}
+
+export type PhotoQuality =
+  | 0
+  | 0.1
+  | 0.2
+  | 0.3
+  | 0.4
+  | 0.5
+  | 0.6
+  | 0.7
+  | 0.8
+  | 0.9
+  | 1;
+export type CameraType = 'back' | 'front';
+export type MediaType = 'photo' | 'video' | 'mixed';
+export type AndroidVideoOptions = 'low' | 'high';
+export type iOSVideoOptions = 'low' | 'medium' | 'high';
+export type ErrorCode = 'camera_unavailable' | 'permission' | 'others';

package/NetInfo/src/__tests__/eventListenerCallbacks.spec.ts

@@ -0,0 +1,332 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import fetchMock from 'jest-fetch-mock';
+import NetInfo from '../index';
+import NativeInterface from '../internal/nativeInterface';
+import {DEVICE_CONNECTIVITY_EVENT} from '../internal/privateTypes';
+import {NetInfoStateType, NetInfoCellularGeneration} from '../internal/types';
+
+// Mock modules
+fetchMock.enableMocks();
+jest.mock('../internal/nativeModule');
+const mockNativeModule = jest.requireMock('../internal/nativeModule').default;
+
+beforeAll(() => {
+  mockNativeModule.getCurrentState.mockResolvedValue({
+    type: NetInfoStateType.cellular,
+    isConnected: true,
+    isInternetReachable: true,
+    details: {
+      isConnectionExpensive: true,
+      cellularGeneration: NetInfoCellularGeneration['4g'],
+    },
+  });
+});
+
+describe('@react-native-community/netinfo listener', () => {
+  describe('Event listener callbacks', () => {
+    it('should call the listener on listening', done => {
+      const listener = jest.fn();
+      NetInfo.addEventListener(listener);
+
+      setTimeout(() => {
+        expect(listener).toBeCalled();
+        done();
+      }, 0);
+    });
+
+    it('should call the listener on listening with multiple listeners', done => {
+      const listener1 = jest.fn();
+      const listener2 = jest.fn();
+      NetInfo.addEventListener(listener1);
+      NetInfo.addEventListener(listener2);
+
+      setTimeout(() => {
+        expect(listener1).toBeCalled();
+        expect(listener2).toBeCalled();
+        done();
+      }, 0);
+    });
+
+    it('should call the listener when the native event is emmitted', () => {
+      const listener = jest.fn();
+      NetInfo.addEventListener(listener);
+
+      const expectedConnectionType = 'wifi';
+      const expectedEffectiveConnectionType = 'unknown';
+      const expectedConnectionInfo = {
+        type: expectedConnectionType,
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: expectedEffectiveConnectionType,
+        },
+      };
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        expectedConnectionInfo,
+      );
+
+      expect(listener).toBeCalledWith(expectedConnectionInfo);
+    });
+
+    it('should call the listener multiple times when multiple native events are emmitted', () => {
+      const listener = jest.fn();
+      NetInfo.addEventListener(listener);
+
+      const cellularInfo = {
+        type: 'cellular',
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: '3g',
+        },
+      };
+
+      const wifiInfo = {
+        type: 'wifi',
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: 'unknown',
+        },
+      };
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        cellularInfo,
+      );
+
+      expect(listener).toBeCalledWith(cellularInfo);
+
+      NativeInterface.eventEmitter.emit(DEVICE_CONNECTIVITY_EVENT, wifiInfo);
+
+      expect(listener).toBeCalledWith(wifiInfo);
+
+      // The additional time is from the call on listen
+      expect(listener).toBeCalledTimes(3);
+    });
+
+    it('should call the listener with the correct data when transitioning state from connected to unconnected', () => {
+      const listener = jest.fn();
+      NetInfo.addEventListener(listener);
+
+      const cellularInfo = {
+        type: 'cellular',
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: '4g',
+        },
+      };
+
+      const airplaneModeInfo = {
+        type: 'none',
+        isConnected: false,
+        isInternetReachable: true,
+        details: null,
+      };
+
+      // Clear the stats from the call on listen
+      listener.mockClear();
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        cellularInfo,
+      );
+
+      expect(listener).toBeCalledWith(cellularInfo);
+      expect(listener).toBeCalledTimes(1);
+
+      // Clear the stats from the call on listen
+      listener.mockClear();
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        airplaneModeInfo,
+      );
+
+      expect(listener).toBeCalledWith(airplaneModeInfo);
+      expect(listener).toBeCalledTimes(1);
+
+      // Clear the stats from the call on listen
+      listener.mockClear();
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        cellularInfo,
+      );
+
+      expect(listener).toBeCalledWith(cellularInfo);
+      expect(listener).toBeCalledTimes(1);
+    });
+
+    it('should call all listeners when the native event is emmitted', () => {
+      const listener1 = jest.fn();
+      const listener2 = jest.fn();
+      NetInfo.addEventListener(listener1);
+      NetInfo.addEventListener(listener2);
+
+      const expectedConnectionType = 'wifi';
+      const expectedEffectiveConnectionType = 'unknown';
+
+      const expectedConnectionInfo = {
+        type: expectedConnectionType,
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: expectedEffectiveConnectionType,
+        },
+      };
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        expectedConnectionInfo,
+      );
+
+      expect(listener1).toBeCalledWith(expectedConnectionInfo);
+      expect(listener2).toBeCalledWith(expectedConnectionInfo);
+    });
+
+    it('should not call the listener after being removed', () => {
+      const listener = jest.fn();
+      const unsubscribe = NetInfo.addEventListener(listener);
+      unsubscribe();
+
+      // Clear the stats from the call on listen
+      listener.mockClear();
+
+      NativeInterface.eventEmitter.emit(DEVICE_CONNECTIVITY_EVENT, {
+        type: 'cellular',
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: '3g',
+        },
+      });
+
+      expect(listener).not.toBeCalled();
+    });
+
+    it('should call the remaining listeners when one has been removed', () => {
+      const listener1 = jest.fn();
+      const listener2 = jest.fn();
+      const unsubscribe1 = NetInfo.addEventListener(listener1);
+      NetInfo.addEventListener(listener2);
+
+      unsubscribe1();
+
+      // Clear the stats from the call on listen
+      listener1.mockClear();
+
+      const expectedConnectionType = 'wifi';
+      const expectedEffectiveConnectionType = 'unknown';
+
+      const expectedConnectionInfo = {
+        type: expectedConnectionType,
+        isConnected: true,
+        isInternetReachable: true,
+        details: {
+          isConnectionExpensive: true,
+          cellularGeneration: expectedEffectiveConnectionType,
+        },
+      };
+
+      NativeInterface.eventEmitter.emit(
+        DEVICE_CONNECTIVITY_EVENT,
+        expectedConnectionInfo,
+      );
+
+      expect(listener1).not.toBeCalled();
+      expect(listener2).toBeCalledWith(expectedConnectionInfo);
+    });
+
+    describe('with configuration options', () => {
+      beforeAll(() => {
+        // Prevent `_checkInternetReachability` from rescheduling.
+        jest.useFakeTimers();
+      });
+
+      beforeEach(() => {
+        fetchMock.resetMocks();
+      });
+
+      describe('reachabilityShouldRun', () => {
+        function dataProvider() {
+          return [
+            {
+              description: 'reachabilityShouldRun returns true',
+              configuration: {
+                reachabilityShouldRun: () => true,
+              },
+              expectedConnectionInfo: {
+                type: 'wifi',
+                isConnected: true,
+                details: {
+                  isConnectionExpensive: true,
+                  cellularGeneration: 'unknown',
+                },
+              },
+              expectedIsInternetReachable: null,
+              expectFetchToBeCalled: true,
+            },
+            {
+              description: 'reachabilityShouldRun returns false',
+              configuration: {
+                reachabilityShouldRun: () => false,
+              },
+              expectedConnectionInfo: {
+                type: 'wifi',
+                isConnected: true,
+                details: {
+                  isConnectionExpensive: true,
+                  cellularGeneration: 'unknown',
+                },
+              },
+              expectedIsInternetReachable: false,
+              expectFetchToBeCalled: false,
+            },
+          ];
+        }
+
+        dataProvider().forEach(testCase => {
+          it(testCase.description, () => {
+            NetInfo.configure(testCase.configuration);
+
+            const listener = jest.fn();
+            NetInfo.addEventListener(listener);
+
+            NativeInterface.eventEmitter.emit(
+              DEVICE_CONNECTIVITY_EVENT,
+              testCase.expectedConnectionInfo,
+            );
+
+            expect(listener).toBeCalledWith({
+              ...testCase.expectedConnectionInfo,
+              isInternetReachable: testCase.expectedIsInternetReachable,
+            });
+            expect(listener).toBeCalledTimes(1);
+
+            testCase.expectFetchToBeCalled
+              ? expect(fetchMock).toHaveBeenCalled()
+              : expect(fetchMock).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+  });
+});