shakebug-react-native 1.0.14

package/NetInfo/src/internal/internetReachability.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 * as PrivateTypes from './privateTypes';
+import * as Types from './types';
+
+interface InternetReachabilityCheckHandler {
+  promise: Promise<void>;
+  cancel: () => void;
+}
+
+export default class InternetReachability {
+  private _configuration: Types.NetInfoConfiguration;
+  private _listener: PrivateTypes.NetInfoInternetReachabilityChangeListener;
+  private _isInternetReachable: boolean | null | undefined = undefined;
+  private _currentInternetReachabilityCheckHandler: InternetReachabilityCheckHandler | null = null;
+  private _currentTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(
+    configuration: Types.NetInfoConfiguration,
+    listener: PrivateTypes.NetInfoInternetReachabilityChangeListener,
+  ) {
+    this._configuration = configuration;
+    this._listener = listener;
+  }
+
+  private _setIsInternetReachable = (
+    isInternetReachable: boolean | null,
+  ): void => {
+    if (this._isInternetReachable === isInternetReachable) {
+      return;
+    }
+
+    this._isInternetReachable = isInternetReachable;
+    this._listener(this._isInternetReachable);
+  };
+
+  private _setExpectsConnection = (expectsConnection: boolean | null): void => {
+    // Cancel any pending check
+    if (this._currentInternetReachabilityCheckHandler !== null) {
+      this._currentInternetReachabilityCheckHandler.cancel();
+      this._currentInternetReachabilityCheckHandler = null;
+    }
+    // Cancel any pending timeout
+    if (this._currentTimeoutHandle !== null) {
+      clearTimeout(this._currentTimeoutHandle);
+      this._currentTimeoutHandle = null;
+    }
+
+    if (expectsConnection && this._configuration.reachabilityShouldRun()) {
+      // If we expect a connection, start the process for finding if we have one
+      // Set the state to "null" if it was previously false
+      if (!this._isInternetReachable) {
+        this._setIsInternetReachable(null);
+      }
+      // Start a network request to check for internet
+      this._currentInternetReachabilityCheckHandler = this._checkInternetReachability();
+    } else {
+      // If we don't expect a connection or don't run reachability check, just change the state to "false"
+      this._setIsInternetReachable(false);
+    }
+  };
+
+  private _checkInternetReachability = (): InternetReachabilityCheckHandler => {
+    const controller = new AbortController();
+
+    const responsePromise = fetch(this._configuration.reachabilityUrl, {
+      headers: this._configuration.reachabilityHeaders,
+      method: this._configuration.reachabilityMethod,
+      cache: 'no-cache',
+      signal: controller.signal,
+    });
+
+    // Create promise that will reject after the request timeout has been reached
+    let timeoutHandle: ReturnType<typeof setTimeout>;
+    const timeoutPromise = new Promise<Response>((_, reject): void => {
+      timeoutHandle = setTimeout(
+        (): void => reject('timedout'),
+        this._configuration.reachabilityRequestTimeout,
+      );
+    });
+
+    // Create promise that makes it possible to cancel a pending request through a reject
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    let cancel: () => void = (): void => {};
+    const cancelPromise = new Promise<Response>((_, reject): void => {
+      cancel = (): void => reject('canceled');
+    });
+
+    const promise = Promise.race([
+      responsePromise,
+      timeoutPromise,
+      cancelPromise,
+    ])
+      .then(
+        (response): Promise<boolean> => {
+          return this._configuration.reachabilityTest(response);
+        },
+      )
+      .then(
+        (result): void => {
+          this._setIsInternetReachable(result);
+          const nextTimeoutInterval = this._isInternetReachable
+            ? this._configuration.reachabilityLongTimeout
+            : this._configuration.reachabilityShortTimeout;
+          this._currentTimeoutHandle = setTimeout(
+            this._checkInternetReachability,
+            nextTimeoutInterval,
+          );
+        },
+      )
+      .catch(
+        (error: Error | 'timedout' | 'canceled'): void => {
+          if ('canceled' === error) {
+            controller.abort();
+          } else {
+            if ('timedout' === error) {
+              controller.abort();
+            }
+            
+            this._setIsInternetReachable(false);
+            this._currentTimeoutHandle = setTimeout(
+              this._checkInternetReachability,
+              this._configuration.reachabilityShortTimeout,
+            );
+          }
+        },
+      )
+      // Clear request timeout and propagate any errors
+      .then(
+        (): void => {
+          clearTimeout(timeoutHandle);
+        },
+        (error: Error): void => {
+          clearTimeout(timeoutHandle);
+          throw error;
+        },
+      );
+
+    return {
+      promise,
+      cancel,
+    };
+  };
+
+  public update = (state: PrivateTypes.NetInfoNativeModuleState): void => {
+    if (
+      typeof state.isInternetReachable === 'boolean' &&
+      this._configuration.useNativeReachability
+    ) {
+      this._setIsInternetReachable(state.isInternetReachable);
+    } else {
+      this._setExpectsConnection(state.isConnected);
+    }
+  };
+
+  public currentState = (): boolean | null | undefined => {
+    return this._isInternetReachable;
+  };
+
+  public tearDown = (): void => {
+    // Cancel any pending check
+    if (this._currentInternetReachabilityCheckHandler !== null) {
+      this._currentInternetReachabilityCheckHandler.cancel();
+      this._currentInternetReachabilityCheckHandler = null;
+    }
+
+    // Cancel any pending timeout
+    if (this._currentTimeoutHandle !== null) {
+      clearTimeout(this._currentTimeoutHandle);
+      this._currentTimeoutHandle = null;
+    }
+  };
+}

package/NetInfo/src/internal/nativeInterface.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 {NativeEventEmitter} from 'react-native';
+import RNCNetInfo from './nativeModule';
+
+// Produce an error if we don't have the native module
+if (!RNCNetInfo) {
+  throw new Error(`@react-native-community/netinfo: NativeModule.RNCNetInfo is null. To fix this issue try these steps:
+
+• Run \`react-native link @react-native-community/netinfo\` in the project root.
+• Rebuild and re-run the app.
+• If you are using CocoaPods on iOS, run \`pod install\` in the \`ios\` directory and then rebuild and re-run the app. You may also need to re-open Xcode to get the new pods.
+• Check that the library was linked correctly when you used the link command by running through the manual installation instructions in the README.
+* If you are getting this error while unit testing you need to mock the native module. Follow the guide in the README.
+
+If none of these fix the issue, please open an issue on the Github repository: https://github.com/react-native-community/react-native-netinfo`);
+}
+
+/**
+ * We export the native interface in this way to give easy shared access to it between the
+ * JavaScript code and the tests
+ */
+let nativeEventEmitter: NativeEventEmitter | null = null;
+const nativeInterface = Object.assign(RNCNetInfo, {
+  get eventEmitter(): NativeEventEmitter {
+    if (!nativeEventEmitter) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      /// @ts-ignore
+      nativeEventEmitter = new NativeEventEmitter(RNCNetInfo);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    /// @ts-ignore
+    return nativeEventEmitter;
+  },
+});
+export default nativeInterface;

package/NetInfo/src/internal/nativeInterface.web.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 {NativeEventEmitter} from 'react-native';
+import RNCNetInfo from './nativeModule';
+import {DEVICE_CONNECTIVITY_EVENT} from './privateTypes';
+
+const nativeEventEmitter = new NativeEventEmitter();
+
+// Listen to connectivity events
+RNCNetInfo.addListener(
+  DEVICE_CONNECTIVITY_EVENT,
+  (event): void => {
+    nativeEventEmitter.emit(DEVICE_CONNECTIVITY_EVENT, event);
+  },
+);
+
+export default {
+  ...RNCNetInfo,
+  eventEmitter: nativeEventEmitter,
+};

package/NetInfo/src/internal/nativeModule.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 {NativeModules} from 'react-native';
+import {NetInfoNativeModule} from './privateTypes';
+
+const RNCNetInfo: NetInfoNativeModule = NativeModules.ShakebugSDKRNCNetInfo;
+
+export default RNCNetInfo;

package/NetInfo/src/internal/nativeModule.web.ts

@@ -0,0 +1,306 @@
+/**
+ * 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 {
+  DEVICE_CONNECTIVITY_EVENT,
+  NetInfoNativeModule,
+  NetInfoNativeModuleState,
+} from './privateTypes';
+import {
+  NetInfoBluetoothState,
+  NetInfoCellularGeneration,
+  NetInfoCellularState,
+  NetInfoEthernetState,
+  NetInfoNoConnectionState,
+  NetInfoOtherState,
+  NetInfoState,
+  NetInfoStateType,
+  NetInfoUnknownState,
+  NetInfoWifiState,
+  NetInfoWimaxState,
+} from './types';
+
+// See https://wicg.github.io/netinfo/#dom-connectiontype
+type ConnectionType =
+  | 'bluetooth'
+  | 'cellular'
+  | 'ethernet'
+  | 'mixed'
+  | 'none'
+  | 'other'
+  | 'unknown'
+  | 'wifi'
+  | 'wimax';
+
+// See https://wicg.github.io/netinfo/#dom-effectiveconnectiontype
+type ConnectionEffectiveType = '2g' | '3g' | '4g' | 'slow-2g';
+
+// https://wicg.github.io/netinfo/#dom-networkinformation-savedata
+type ConnectionSaveData = boolean;
+
+interface Events {
+  change: Event;
+}
+
+interface Connection {
+  type: ConnectionType;
+  effectiveType: ConnectionEffectiveType;
+  saveData: ConnectionSaveData;
+  addEventListener<K extends keyof Events>(
+    type: K,
+    listener: (event: Events[K]) => void,
+  ): void;
+  removeEventListener<K extends keyof Events>(
+    type: K,
+    listener: (event: Events[K]) => void,
+  ): void;
+}
+
+// Create (optional) connection APIs on navigator
+declare global {
+  interface Navigator {
+    connection?: Connection;
+    mozConnection?: Connection;
+    webkitConnection?: Connection;
+  }
+}
+// Use a constant test of this form because in SSR on next.js, optional chaining is not sufficient,
+// but this test correctly detects that window is not available and allows for conditionals before access
+const isWindowPresent = typeof window !== 'undefined';
+
+// Check if window exists and if the browser supports the connection API
+const connection = (isWindowPresent && !window.hasOwnProperty('tizen') && !window.hasOwnProperty('webOS'))
+  ? window.navigator.connection ||
+    window.navigator.mozConnection ||
+    window.navigator.webkitConnection
+  : undefined;
+
+// Map browser types to native types
+const typeMapping: Record<ConnectionType, NetInfoStateType> = {
+  bluetooth: NetInfoStateType.bluetooth,
+  cellular: NetInfoStateType.cellular,
+  ethernet: NetInfoStateType.ethernet,
+  none: NetInfoStateType.none,
+  other: NetInfoStateType.other,
+  unknown: NetInfoStateType.unknown,
+  wifi: NetInfoStateType.wifi,
+  wimax: NetInfoStateType.wimax,
+  mixed: NetInfoStateType.other,
+};
+const effectiveTypeMapping: Record<
+  ConnectionEffectiveType,
+  NetInfoCellularGeneration
+> = {
+  '2g': NetInfoCellularGeneration['2g'],
+  '3g': NetInfoCellularGeneration['3g'],
+  '4g': NetInfoCellularGeneration['4g'],
+  'slow-2g': NetInfoCellularGeneration['2g'],
+};
+
+// Determine current state of connection
+const getCurrentState = (
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _requestedInterface?: string,
+): Pick<NetInfoState, Exclude<keyof NetInfoState, 'isInternetReachable'>> => {
+  const isConnected = isWindowPresent ? navigator.onLine : false;
+  const baseState = {
+    isInternetReachable: null,
+  };
+
+  // If we don't have a connection object, we return minimal information
+  if (!connection) {
+    if (isConnected) {
+      const state: NetInfoOtherState = {
+        ...baseState,
+        isConnected: true,
+        type: NetInfoStateType.other,
+        details: {
+          isConnectionExpensive: false,
+        },
+      };
+      return state;
+    }
+
+    const state: NetInfoNoConnectionState = {
+      ...baseState,
+      isConnected: false,
+      isInternetReachable: false,
+      type: NetInfoStateType.none,
+      details: null,
+    };
+    return state;
+  }
+
+  // Otherwise try to return detailed information
+  const isConnectionExpensive = connection.saveData;
+  const type: NetInfoStateType = connection.type
+    ? typeMapping[connection.type]
+    : isConnected
+    ? NetInfoStateType.other
+    : NetInfoStateType.unknown;
+
+  if (type === NetInfoStateType.bluetooth) {
+    const state: NetInfoBluetoothState = {
+      ...baseState,
+      isConnected: true,
+      type,
+      details: {
+        isConnectionExpensive,
+      },
+    };
+    return state;
+  } else if (type === NetInfoStateType.cellular) {
+    const state: NetInfoCellularState = {
+      ...baseState,
+      isConnected: true,
+      type,
+      details: {
+        isConnectionExpensive,
+        cellularGeneration:
+          effectiveTypeMapping[connection.effectiveType] || null,
+        carrier: null,
+      },
+    };
+    return state;
+  } else if (type === NetInfoStateType.ethernet) {
+    const state: NetInfoEthernetState = {
+      ...baseState,
+      isConnected: true,
+      type,
+      details: {
+        isConnectionExpensive,
+        ipAddress: null,
+        subnet: null,
+      },
+    };
+    return state;
+  } else if (type === NetInfoStateType.wifi) {
+    const state: NetInfoWifiState = {
+      ...baseState,
+      isConnected: true,
+      type,
+      details: {
+        isConnectionExpensive,
+        ssid: null,
+        bssid: null,
+        strength: null,
+        ipAddress: null,
+        subnet: null,
+        frequency: null,
+        linkSpeed: null,
+        rxLinkSpeed: null,
+        txLinkSpeed: null,
+      },
+    };
+    return state;
+  } else if (type === NetInfoStateType.wimax) {
+    const state: NetInfoWimaxState = {
+      ...baseState,
+      isConnected: true,
+      type,
+      details: {
+        isConnectionExpensive,
+      },
+    };
+    return state;
+  } else if (type === NetInfoStateType.none) {
+    const state: NetInfoNoConnectionState = {
+      ...baseState,
+      isConnected: false,
+      isInternetReachable: false,
+      type,
+      details: null,
+    };
+    return state;
+  } else if (type === NetInfoStateType.unknown) {
+    const state: NetInfoUnknownState = {
+      ...baseState,
+      isConnected,
+      isInternetReachable: null,
+      type,
+      details: null,
+    };
+    return state;
+  }
+
+  const state: NetInfoOtherState = {
+    ...baseState,
+    isConnected: true,
+    type: NetInfoStateType.other,
+    details: {
+      isConnectionExpensive,
+    },
+  };
+  return state;
+};
+
+const handlers: ((state: NetInfoNativeModuleState) => void)[] = [];
+const nativeHandlers: (() => void)[] = [];
+
+const RNCNetInfo: NetInfoNativeModule = {
+  addListener(type, handler): void {
+    switch (type) {
+      case DEVICE_CONNECTIVITY_EVENT: {
+        const nativeHandler = (): void => {
+          handler(getCurrentState());
+        };
+
+        if (connection) {
+          connection.addEventListener('change', nativeHandler);
+        } else {
+          if (isWindowPresent) {
+            window.addEventListener('online', nativeHandler, false);
+            window.addEventListener('offline', nativeHandler, false);
+          }
+        }
+
+        // Remember handlers
+        handlers.push(handler);
+        nativeHandlers.push(nativeHandler);
+
+        break;
+      }
+    }
+  },
+
+  removeListeners(type, handler): void {
+    switch (type) {
+      case DEVICE_CONNECTIVITY_EVENT: {
+        // Get native handler
+        const index = handlers.indexOf(handler);
+        const nativeHandler = nativeHandlers[index];
+
+        if (connection) {
+          connection.removeEventListener('change', nativeHandler);
+        } else {
+          if (isWindowPresent) {
+            window.removeEventListener('online', nativeHandler);
+            window.removeEventListener('offline', nativeHandler);
+          }
+        }
+
+        // Remove handlers
+        handlers.splice(index, 1);
+        nativeHandlers.splice(index, 1);
+
+        break;
+      }
+    }
+  },
+
+  async getCurrentState(requestedInterface): Promise<NetInfoNativeModuleState> {
+    return getCurrentState(requestedInterface);
+  },
+
+  configure(): void {
+    return;
+  },
+};
+
+export default RNCNetInfo;

package/NetInfo/src/internal/privateTypes.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 {NetInfoConfiguration, NetInfoState} from './types';
+
+export const DEVICE_CONNECTIVITY_EVENT = 'netInfo.networkStatusDidChange';
+
+// Certain properties are optional when sent by the native module and are handled by the JS code
+export type NetInfoNativeModuleState = Pick<
+  NetInfoState,
+  Exclude<keyof NetInfoState, 'isInternetReachable'>
+> & {isInternetReachable?: boolean};
+
+export interface Events {
+  [DEVICE_CONNECTIVITY_EVENT]: NetInfoNativeModuleState;
+}
+
+export interface NetInfoNativeModule {
+  configure: (config: Partial<NetInfoConfiguration>) => void;
+  getCurrentState: (
+    requestedInterface?: string,
+  ) => Promise<NetInfoNativeModuleState>;
+  addListener<K extends keyof Events>(
+    type: K,
+    listener: (event: Events[K]) => void,
+  ): void;
+  removeListeners<K extends keyof Events>(
+    type: K,
+    listener: (event: Events[K]) => void,
+  ): void;
+}
+
+export type NetInfoInternetReachabilityChangeListener = (
+  isInternetReachable: boolean | null | undefined,
+) => void;