shakebug-react-native 1.0.14

package/DeviceInfo/internal/privateTypes.ts

@@ -0,0 +1,231 @@
+import { Platform } from 'react-native';
+import type { DeviceType, LocationProviderInfo, PowerState, AsyncHookResult } from './types';
+
+export type NotchDevice = {
+  brand: string;
+  model: string;
+
+  [key: string]: string;
+};
+
+interface NativeConstants {
+  appName: string;
+  appVersion: string;
+  brand: string;
+  buildNumber: string;
+  bundleId: string;
+  deviceId: string;
+  deviceType: DeviceType;
+  isTablet: boolean;
+  isLowRamDevice: boolean;
+  isDisplayZoomed: boolean;
+  model: string;
+  systemName: string;
+  systemVersion: string;
+}
+
+interface HiddenNativeMethods {
+  getPowerState: () => Promise<PowerState>;
+  getPowerStateSync: () => PowerState;
+  getSupported32BitAbis: () => Promise<string[]>;
+  getSupported32BitAbisSync: () => string[];
+  getSupported64BitAbis: () => Promise<string[]>;
+  getSupported64BitAbisSync: () => string[];
+  getSupportedAbis: () => Promise<string[]>;
+  getSupportedAbisSync: () => string[];
+  getSystemManufacturer: () => Promise<string>;
+  getSystemManufacturerSync: () => string;
+}
+
+interface ExposedNativeMethods {
+  getAndroidId: () => Promise<string>;
+  getAndroidIdSync: () => string;
+  getApiLevel: () => Promise<number>;
+  getApiLevelSync: () => number;
+  getAvailableLocationProviders: () => Promise<LocationProviderInfo>;
+  getAvailableLocationProvidersSync: () => LocationProviderInfo;
+  getBaseOs: () => Promise<string>;
+  getBaseOsSync: () => string;
+  getBatteryLevel: () => Promise<number>;
+  getBatteryLevelSync: () => number;
+  getBootloader: () => Promise<string>;
+  getBootloaderSync: () => string;
+  getBuildId: () => Promise<string>;
+  getBuildIdSync: () => string;
+  getCarrier: () => Promise<string>;
+  getCarrierSync: () => string;
+  getCodename: () => Promise<string>;
+  getCodenameSync: () => string;
+  getDevice: () => Promise<string>;
+  getDeviceName: () => Promise<string>;
+  getDeviceNameSync: () => string;
+  getDeviceSync: () => string;
+  getDeviceToken: () => Promise<string>;
+  getDisplay: () => Promise<string>;
+  getDisplaySync: () => string;
+  getFingerprint: () => Promise<string>;
+  getFingerprintSync: () => string;
+  getFirstInstallTime: () => Promise<number>;
+  getFirstInstallTimeSync: () => number;
+  getFontScale: () => Promise<number>;
+  getFontScaleSync: () => number;
+  getFreeDiskStorage: () => Promise<number>;
+  getFreeDiskStorageOld: () => Promise<number>;
+  getFreeDiskStorageSync: () => number;
+  getFreeDiskStorageOldSync: () => number;
+  getHardware: () => Promise<string>;
+  getHardwareSync: () => string;
+  getHost: () => Promise<string>;
+  getHostSync: () => string;
+  getHostNames: () => Promise<string[]>;
+  getHostNamesSync: () => string[];
+  getIncremental: () => Promise<string>;
+  getIncrementalSync: () => string;
+  getInstallerPackageName: () => Promise<string>;
+  getInstallerPackageNameSync: () => string;
+  getInstallReferrer: () => Promise<string>;
+  getInstallReferrerSync: () => string;
+  getInstanceId: () => Promise<string>;
+  getInstanceIdSync: () => string;
+  getIpAddress: () => Promise<string>;
+  getIpAddressSync: () => string;
+  getLastUpdateTime: () => Promise<number>;
+  getLastUpdateTimeSync: () => number;
+  getMacAddress: () => Promise<string>;
+  getMacAddressSync: () => string;
+  getMaxMemory: () => Promise<number>;
+  getMaxMemorySync: () => number;
+  getPhoneNumber: () => Promise<string>;
+  getPhoneNumberSync: () => string;
+  getPreviewSdkInt: () => Promise<number>;
+  getPreviewSdkIntSync: () => number;
+  getProduct: () => Promise<string>;
+  getProductSync: () => string;
+  getSecurityPatch: () => Promise<string>;
+  getSecurityPatchSync: () => string;
+  getSerialNumber: () => Promise<string>;
+  getSerialNumberSync: () => string;
+  getSystemAvailableFeatures: () => Promise<string[]>;
+  getSystemAvailableFeaturesSync: () => string[];
+  getTags: () => Promise<string>;
+  getTagsSync: () => string;
+  getTotalDiskCapacity: () => Promise<number>;
+  getTotalDiskCapacityOld: () => Promise<number>;
+  getTotalDiskCapacitySync: () => number;
+  getTotalDiskCapacityOldSync: () => number;
+  getTotalMemory: () => Promise<number>;
+  getTotalMemorySync: () => number;
+  getType: () => Promise<string>;
+  getTypeSync: () => string;
+  getUniqueId: () => Promise<string>;
+  getUniqueIdSync: () => string;
+  getUsedMemory: () => Promise<number>;
+  getUsedMemorySync: () => number;
+  getUserAgent: () => Promise<string>;
+  getUserAgentSync: () => string;
+  getBrightness: () => Promise<number>;
+  getBrightnessSync: () => number;
+  hasGms: () => Promise<boolean>;
+  hasGmsSync: () => boolean;
+  hasHms: () => Promise<boolean>;
+  hasHmsSync: () => boolean;
+  hasSystemFeature: (feature: string) => Promise<boolean>;
+  hasSystemFeatureSync: (feature: string) => boolean;
+  isAirplaneMode: () => Promise<boolean>;
+  isAirplaneModeSync: () => boolean;
+  isBatteryCharging: () => Promise<boolean>;
+  isBatteryChargingSync: () => boolean;
+  isCameraPresent: () => Promise<boolean>;
+  isCameraPresentSync: () => boolean;
+  isEmulator: () => Promise<boolean>;
+  isEmulatorSync: () => boolean;
+  isHeadphonesConnected: () => Promise<boolean>;
+  isHeadphonesConnectedSync: () => boolean;
+  isLocationEnabled: () => Promise<boolean>;
+  isLocationEnabledSync: () => boolean;
+  isPinOrFingerprintSet: () => Promise<boolean>;
+  isPinOrFingerprintSetSync: () => boolean;
+  isMouseConnected: () => Promise<boolean>;
+  isMouseConnectedSync: () => boolean;
+  isKeyboardConnected: () => Promise<boolean>;
+  isKeyboardConnectedSync: () => boolean;
+  isTabletMode: () => Promise<boolean>;
+  syncUniqueId: () => Promise<string>;
+  getSupportedMediaTypeList: () => Promise<string[]>
+  getSupportedMediaTypeListSync: () => string[]
+}
+
+export interface DeviceInfoNativeModule
+  extends NativeConstants,
+    HiddenNativeMethods,
+    ExposedNativeMethods {}
+
+export interface DeviceInfoModule extends ExposedNativeMethods {
+  getApplicationName: () => string;
+  getBrand: () => string;
+  getBuildNumber: () => string;
+  getBundleId: () => string;
+  getDeviceId: () => string;
+  getDeviceType: () => string;
+  getManufacturer: () => Promise<string>;
+  getManufacturerSync: () => string;
+  getModel: () => string;
+  getPowerState: () => Promise<Partial<PowerState>>;
+  getPowerStateSync: () => Partial<PowerState>;
+  getReadableVersion: () => string;
+  getSystemName: () => string;
+  getSystemVersion: () => string;
+  getUniqueId: () => Promise<string>;
+  getUniqueIdSync: () => string;
+  getVersion: () => string;
+  hasNotch: () => boolean;
+  hasDynamicIsland: () => boolean;
+  hasSystemFeature: (feature: string) => Promise<boolean>;
+  hasSystemFeatureSync: (feature: string) => boolean;
+  isLandscape: () => Promise<boolean>;
+  isLandscapeSync: () => boolean;
+  isTablet: () => boolean;
+  isLowRamDevice: () => boolean;
+  isDisplayZoomed: () => boolean;
+  supported32BitAbis: () => Promise<string[]>;
+  supported32BitAbisSync: () => string[];
+  supported64BitAbis: () => Promise<string[]>;
+  supported64BitAbisSync: () => string[];
+  supportedAbis: () => Promise<string[]>;
+  supportedAbisSync: () => string[];
+  useBatteryLevel: () => number | null;
+  useBatteryLevelIsLow: () => number | null;
+  useDeviceName: () => AsyncHookResult<string>;
+  useFirstInstallTime: () => AsyncHookResult<number>;
+  useHasSystemFeature: (feature: string) => AsyncHookResult<boolean>;
+  useIsEmulator: () => AsyncHookResult<boolean>;
+  usePowerState: () => Partial<PowerState>;
+  useManufacturer: () => AsyncHookResult<string>;
+  useIsHeadphonesConnected: () => AsyncHookResult<boolean>;
+  useBrightness: () => number | null;
+}
+
+export type Getter<T> = () => T;
+export type PlatformArray = typeof Platform.OS[];
+
+export interface GetSupportedPlatformInfoSyncParams<T> {
+  getter: Getter<T>;
+  supportedPlatforms: PlatformArray;
+  defaultValue: T;
+  memoKey?: string;
+}
+
+export interface GetSupportedPlatformInfoAsyncParams<T>
+  extends Omit<GetSupportedPlatformInfoSyncParams<T>, 'getter'> {
+  getter: Getter<Promise<T>>;
+}
+
+export interface GetFilterPlatformFunctionsParams<T>
+  extends GetSupportedPlatformInfoAsyncParams<T> {
+  syncGetter: Getter<T>;
+}
+
+export interface GetSupportedPlatformInfoFunctionsParams<T>
+  extends GetSupportedPlatformInfoAsyncParams<T> {
+  syncGetter: Getter<T>;
+}

package/DeviceInfo/internal/supported-platform-info.ts

@@ -0,0 +1,97 @@
+import { Platform } from 'react-native';
+
+import {
+  PlatformArray,
+  Getter,
+  GetSupportedPlatformInfoAsyncParams,
+  GetSupportedPlatformInfoSyncParams,
+  GetSupportedPlatformInfoFunctionsParams,
+} from './privateTypes';
+
+type MemoType = { [key: string]: any };
+// centralized memo object
+let memo: MemoType = {};
+
+export function clearMemo() {
+  memo = {};
+}
+
+/**
+ * function returns the proper getter based current platform X supported platforms
+ * @param supportedPlatforms array of supported platforms (OS)
+ * @param getter desired function used to get info
+ * @param defaultGetter getter that returns a default value if desired getter is not supported by current platform
+ */
+function getSupportedFunction<T>(
+  supportedPlatforms: PlatformArray,
+  getter: Getter<T>,
+  defaultGetter: Getter<T>
+): Getter<T> {
+  let supportedMap: any = {};
+  supportedPlatforms
+    .filter((key) => Platform.OS == key)
+    .forEach((key) => (supportedMap[key] = getter));
+  return Platform.select({
+    ...supportedMap,
+    default: defaultGetter,
+  });
+}
+
+/**
+ * function used to get desired info synchronously — with optional memoization
+ * @param param0
+ */
+export function getSupportedPlatformInfoSync<T>({
+  getter,
+  supportedPlatforms,
+  defaultValue,
+  memoKey,
+}: GetSupportedPlatformInfoSyncParams<T>): T {
+  if (memoKey && memo[memoKey] != undefined) {
+    return memo[memoKey];
+  } else {
+    const output = getSupportedFunction(supportedPlatforms, getter, () => defaultValue)();
+    if (memoKey) {
+      memo[memoKey] = output;
+    }
+    return output;
+  }
+}
+
+/**
+ * function used to get desired info asynchronously — with optional memoization
+ * @param param0
+ */
+export async function getSupportedPlatformInfoAsync<T>({
+  getter,
+  supportedPlatforms,
+  defaultValue,
+  memoKey,
+}: GetSupportedPlatformInfoAsyncParams<T>): Promise<T> {
+  if (memoKey && memo[memoKey] != undefined) {
+    return memo[memoKey];
+  } else {
+    const output = await getSupportedFunction(supportedPlatforms, getter, () =>
+      Promise.resolve(defaultValue)
+    )();
+    if (memoKey) {
+      memo[memoKey] = output;
+    }
+
+    return output;
+  }
+}
+
+/**
+ * function that returns array of getter functions [async, sync]
+ * @param param0
+ */
+export function getSupportedPlatformInfoFunctions<T>({
+  syncGetter,
+  ...asyncParams
+}: GetSupportedPlatformInfoFunctionsParams<T>): [Getter<Promise<T>>, Getter<T>] {
+  return [
+    () => getSupportedPlatformInfoAsync(asyncParams),
+    () => getSupportedPlatformInfoSync({ ...asyncParams, getter: syncGetter }),
+  ];
+}

package/DeviceInfo/internal/types.ts

@@ -0,0 +1,19 @@
+export type DeviceType = 'Handset' | 'Tablet' | 'Tv' | 'Desktop' | 'GamingConsole' | 'unknown';
+
+export type BatteryState = 'unknown' | 'unplugged' | 'charging' | 'full';
+
+export interface PowerState {
+  batteryLevel: number;
+  batteryState: BatteryState;
+  lowPowerMode: boolean;
+  [key: string]: any;
+}
+
+export interface LocationProviderInfo {
+  [key: string]: boolean;
+}
+
+export interface AsyncHookResult<T> {
+  loading: boolean;
+  result: T;
+}

package/DeviceInfo/web/index.js

@@ -0,0 +1,223 @@
+import { NativeEventEmitter, NativeModules } from 'react-native';
+
+const deviceInfoEmitter = new NativeEventEmitter(NativeModules.RNDeviceInfo);
+
+let batteryCharging = false,
+  batteryLevel = -1,
+  powerState = {};
+
+const _readPowerState = (battery) => {
+  const { level, charging, chargingtime, dischargingtime } = battery;
+
+  return {
+    batteryLevel: level,
+    lowPowerMode: false,
+    batteryState: level === 1 ? 'full' : charging ? 'charging' : 'unplugged',
+    chargingtime,
+    dischargingtime,
+  };
+};
+
+export const getMaxMemorySync = () => {
+  if (window.performance && window.performance.memory) {
+    return window.performance.memory.jsHeapSizeLimit;
+  }
+  return -1;
+};
+
+export const getInstallReferrerSync = () => {
+  return document.referrer;
+};
+
+export const isAirplaneModeSync = () => {
+  return !!navigator.onLine;
+};
+
+export const getUserAgentSync = () => {
+  return window.navigator.userAgent;
+};
+
+export const isLocationEnabledSync = () => {
+  return !!navigator.geolocation;
+};
+
+export const getTotalMemorySync = () => {
+  if (navigator.deviceMemory) {
+    return navigator.deviceMemory * 1000000000;
+  }
+  return -1;
+};
+
+export const getUsedMemorySync = () => {
+  if (window.performance && window.performance.memory) {
+    return window.performance.memory.usedJSHeapSize;
+  }
+  return -1;
+};
+
+const init = () => {
+  if (typeof navigator === 'undefined' || !navigator.getBattery) return;
+
+  navigator.getBattery().then((battery) => {
+    batteryCharging = battery.charging;
+
+    battery.addEventListener('chargingchange', () => {
+      const { charging } = battery;
+
+      batteryCharging = charging;
+      powerState = _readPowerState(battery);
+
+      deviceInfoEmitter.emit('RNDeviceInfo_powerStateDidChange', powerState);
+    });
+
+    battery.addEventListener('levelchange', () => {
+      const { level } = battery;
+
+      batteryLevel = level;
+      powerState = _readPowerState(battery);
+
+      deviceInfoEmitter.emit('RNDeviceInfo_batteryLevelDidChange', level);
+      if (level < 0.2) {
+        deviceInfoEmitter.emit('RNDeviceInfo_batteryLevelIsLow', level);
+      }
+    });
+  });
+};
+
+const getBaseOsSync = () => {
+  const userAgent = window.navigator.userAgent,
+    platform = window.navigator.platform,
+    macosPlatforms = ['Macintosh', 'MacIntel', 'MacPPC', 'Mac68K'],
+    windowsPlatforms = ['Win32', 'Win64', 'Windows', 'WinCE'],
+    iosPlatforms = ['iPhone', 'iPad', 'iPod'];
+
+  let os = platform;
+
+  if (macosPlatforms.indexOf(platform) !== -1) {
+    os = 'Mac OS';
+  } else if (iosPlatforms.indexOf(platform) !== -1) {
+    os = 'iOS';
+  } else if (windowsPlatforms.indexOf(platform) !== -1) {
+    os = 'Windows';
+  } else if (/Android/.test(userAgent)) {
+    os = 'Android';
+  } else if (!os && /Linux/.test(platform)) {
+    os = 'Linux';
+  }
+
+  return os;
+};
+
+init();
+/**
+ * react-native-web empty polyfill.
+ */
+
+export const getInstallReferrer = async () => {
+  return getInstallReferrerSync();
+};
+
+export const getUserAgent = async () => {
+  return getUserAgentSync();
+};
+
+export const isBatteryCharging = async () => {
+  if (navigator.getBattery) {
+    return navigator.getBattery().then(battery => battery.charging);
+  }
+  return false;
+};
+
+export const isBatteryChargingSync = () => {
+  return batteryCharging;
+};
+
+export const isCameraPresent = async () => {
+  if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+    return navigator.mediaDevices.enumerateDevices().then(devices => {
+      return !!devices.find((d) => d.kind === 'videoinput');
+    });
+  }
+  return false;
+};
+
+export const isCameraPresentSync = () => {
+  console.log(
+    '[react-native-device-info] isCameraPresentSync not supported - please use isCameraPresent'
+  );
+  return false;
+};
+
+export const getBatteryLevel = async () => {
+  if (navigator.getBattery) {
+    return navigator.getBattery().then(battery => battery.level);
+  }
+  return -1;
+};
+
+export const getBatteryLevelSync = () => {
+  return batteryLevel;
+};
+
+export const isLocationEnabled = async () => {
+  return isLocationEnabledSync();
+};
+
+export const isAirplaneMode = async () => {
+  return isAirplaneModeSync();
+};
+
+export const getBaseOs = async () => {
+  return getBaseOsSync();
+};
+
+export const getTotalDiskCapacity = async () => {
+  if (navigator.storage && navigator.storage.estimate) {
+    return navigator.storage.estimate().then(({ quota }) => quota)
+  }
+  return -1;
+};
+
+export const getTotalDiskCapacitySync = () => {
+  console.log(
+    '[react-native-device-info] getTotalDiskCapacitySync not supported - please use getTotalDiskCapacity'
+  );
+  return -1;
+};
+
+export const getFreeDiskStorage = async () => {
+  if (navigator.storage && navigator.storage.estimate) {
+    return navigator.storage.estimate().then(({ quota, usage }) => quota - usage)
+  }
+  return -1;
+};
+
+export const getFreeDiskStorageSync = () => {
+  console.log(
+    '[react-native-device-info] getFreeDiskStorageSync not supported - please use getFreeDiskStorage'
+  );
+  return -1;
+};
+
+export const getMaxMemory = async () => {
+  return getMaxMemorySync();
+};
+
+export const getUsedMemory = async () => {
+  return getUsedMemorySync();
+};
+
+export const getTotalMemory = async () => {
+  return getTotalMemorySync();
+};
+
+export const getPowerState = async () => {
+  if (navigator.getBattery) {
+    return navigator.getBattery().then((battery) => _readPowerState(battery))
+  }
+  return {};
+};
+
+export const getPowerStateSync = () => {
+  return powerState;
+};

package/GetLocals/src/NativeRNLocalize.ts

@@ -0,0 +1,18 @@
+import type { TurboModule } from "react-native";
+import { TurboModuleRegistry } from "react-native";
+
+export interface Spec extends TurboModule {
+  getCalendar(): string;
+  getCountry(): string;
+  getCurrencies(): string[];
+  getLocales(): Object[];
+  getNumberFormatSettings(): Object;
+  getTemperatureUnit(): string;
+  getTimeZone(): string;
+  uses24HourClock(): boolean;
+  usesMetricSystem(): boolean;
+  usesAutoDateAndTime(): boolean | null;
+  usesAutoTimeZone(): boolean | null;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("ShakebugSDKRNLocalize");