shakebug-react-native 1.0.14

package/GetLocals/src/constants.ts

@@ -0,0 +1,269 @@
+export const USES_FAHRENHEIT: string[] = ["BS", "BZ", "KY", "PR", "PW", "US"];
+
+export const USES_IMPERIAL: string[] = ["LR", "MM", "US"];
+
+export const USES_RTL_LAYOUT: string[] = [
+  "ar",
+  "ckb",
+  "fa",
+  "he",
+  "ks",
+  "lrc",
+  "mzn",
+  "ps",
+  "ug",
+  "ur",
+  "yi",
+];
+
+export const CURRENCIES: Record<string, string> = {
+  AD: "EUR",
+  AE: "AED",
+  AF: "AFN",
+  AG: "XCD",
+  AI: "XCD",
+  AL: "ALL",
+  AM: "AMD",
+  AN: "ANG",
+  AO: "AOA",
+  AR: "ARS",
+  AS: "USD",
+  AT: "EUR",
+  AU: "AUD",
+  AW: "AWG",
+  AX: "EUR",
+  AZ: "AZN",
+  BA: "BAM",
+  BB: "BBD",
+  BD: "BDT",
+  BE: "EUR",
+  BF: "XOF",
+  BG: "BGN",
+  BH: "BHD",
+  BI: "BIF",
+  BJ: "XOF",
+  BL: "EUR",
+  BM: "BMD",
+  BN: "BND",
+  BO: "BOB",
+  BQ: "USD",
+  BR: "BRL",
+  BS: "BSD",
+  BT: "BTN",
+  BV: "NOK",
+  BW: "BWP",
+  BY: "BYN",
+  BZ: "BZD",
+  CA: "CAD",
+  CC: "AUD",
+  CD: "CDF",
+  CF: "XAF",
+  CG: "XAF",
+  CH: "CHF",
+  CI: "XOF",
+  CK: "NZD",
+  CL: "CLP",
+  CM: "XAF",
+  CN: "CNY",
+  CO: "COP",
+  CR: "CRC",
+  CU: "CUP",
+  CV: "CVE",
+  CW: "ANG",
+  CX: "AUD",
+  CY: "EUR",
+  CZ: "CZK",
+  DE: "EUR",
+  DJ: "DJF",
+  DK: "DKK",
+  DM: "XCD",
+  DO: "DOP",
+  DZ: "DZD",
+  EC: "USD",
+  EE: "EUR",
+  EG: "EGP",
+  EH: "MAD",
+  ER: "ERN",
+  ES: "EUR",
+  ET: "ETB",
+  FI: "EUR",
+  FJ: "FJD",
+  FK: "FKP",
+  FM: "USD",
+  FO: "DKK",
+  FR: "EUR",
+  GA: "XAF",
+  GB: "GBP",
+  GD: "XCD",
+  GE: "GEL",
+  GF: "EUR",
+  GG: "GBP",
+  GH: "GHS",
+  GI: "GIP",
+  GL: "DKK",
+  GM: "GMD",
+  GN: "GNF",
+  GP: "EUR",
+  GQ: "XAF",
+  GR: "EUR",
+  GS: "GBP",
+  GT: "GTQ",
+  GU: "USD",
+  GW: "XOF",
+  GY: "GYD",
+  HK: "HKD",
+  HM: "AUD",
+  HN: "HNL",
+  HR: "HRK",
+  HT: "HTG",
+  HU: "HUF",
+  ID: "IDR",
+  IE: "EUR",
+  IL: "ILS",
+  IM: "GBP",
+  IN: "INR",
+  IO: "USD",
+  IQ: "IQD",
+  IR: "IRR",
+  IS: "ISK",
+  IT: "EUR",
+  JE: "GBP",
+  JM: "JMD",
+  JO: "JOD",
+  JP: "JPY",
+  KE: "KES",
+  KG: "KGS",
+  KH: "KHR",
+  KI: "AUD",
+  KM: "KMF",
+  KN: "XCD",
+  KP: "KPW",
+  KR: "KRW",
+  KW: "KWD",
+  KY: "KYD",
+  KZ: "KZT",
+  LA: "LAK",
+  LB: "LBP",
+  LC: "XCD",
+  LI: "CHF",
+  LK: "LKR",
+  LR: "LRD",
+  LS: "LSL",
+  LT: "EUR",
+  LU: "EUR",
+  LV: "EUR",
+  LY: "LYD",
+  MA: "MAD",
+  MC: "EUR",
+  MD: "MDL",
+  ME: "EUR",
+  MF: "EUR",
+  MG: "MGA",
+  MH: "USD",
+  MK: "MKD",
+  ML: "XOF",
+  MM: "MMK",
+  MN: "MNT",
+  MO: "MOP",
+  MP: "USD",
+  MQ: "EUR",
+  MR: "MRO",
+  MS: "XCD",
+  MT: "EUR",
+  MU: "MUR",
+  MV: "MVR",
+  MW: "MWK",
+  MX: "MXN",
+  MY: "MYR",
+  MZ: "MZN",
+  NA: "NAD",
+  NC: "XPF",
+  NE: "XOF",
+  NF: "AUD",
+  NG: "NGN",
+  NI: "NIO",
+  NL: "EUR",
+  NO: "NOK",
+  NP: "NPR",
+  NR: "AUD",
+  NU: "NZD",
+  NZ: "NZD",
+  OM: "OMR",
+  PA: "PAB",
+  PE: "PEN",
+  PF: "XPF",
+  PG: "PGK",
+  PH: "PHP",
+  PK: "PKR",
+  PL: "PLN",
+  PM: "EUR",
+  PN: "NZD",
+  PR: "USD",
+  PS: "ILS",
+  PT: "EUR",
+  PW: "USD",
+  PY: "PYG",
+  QA: "QAR",
+  RE: "EUR",
+  RO: "RON",
+  RS: "RSD",
+  RU: "RUB",
+  RW: "RWF",
+  SA: "SAR",
+  SB: "SBD",
+  SC: "SCR",
+  SD: "SDG",
+  SE: "SEK",
+  SG: "SGD",
+  SH: "SHP",
+  SI: "EUR",
+  SJ: "NOK",
+  SK: "EUR",
+  SL: "SLL",
+  SM: "EUR",
+  SN: "XOF",
+  SO: "SOS",
+  SR: "SRD",
+  SS: "SSP",
+  ST: "STD",
+  SV: "SVC",
+  SX: "ANG",
+  SY: "SYP",
+  SZ: "SZL",
+  TC: "USD",
+  TD: "XAF",
+  TF: "EUR",
+  TG: "XOF",
+  TH: "THB",
+  TJ: "TJS",
+  TK: "NZD",
+  TL: "USD",
+  TM: "TMT",
+  TN: "TND",
+  TO: "TOP",
+  TR: "TRY",
+  TT: "TTD",
+  TV: "AUD",
+  TW: "TWD",
+  TZ: "TZS",
+  UA: "UAH",
+  UG: "UGX",
+  UM: "USD",
+  US: "USD",
+  UY: "UYU",
+  UZ: "UZS",
+  VA: "EUR",
+  VC: "XCD",
+  VE: "VEF",
+  VG: "USD",
+  VI: "USD",
+  VN: "VND",
+  VU: "VUV",
+  WF: "XPF",
+  WS: "WST",
+  YE: "YER",
+  YT: "EUR",
+  ZA: "ZAR",
+  ZM: "ZMW",
+  ZW: "ZWL",
+};

package/GetLocals/src/index.ts

@@ -0,0 +1,56 @@
+import { getLocales } from "./module";
+
+export function findBestLanguageTag<T extends string>(
+  languageTags: ReadonlyArray<T>,
+): { languageTag: T; isRTL: boolean } | undefined {
+  const locales = getLocales();
+  const loweredLanguageTags = languageTags.map((tag) => tag.toLowerCase());
+
+  for (let i = 0; i < locales.length; i++) {
+    const currentLocale = locales[i];
+
+    if (!currentLocale) {
+      continue;
+    }
+
+    const { languageTag, languageCode, scriptCode, countryCode, isRTL } =
+      currentLocale;
+
+    const combinaisons = [
+      languageTag,
+      !!scriptCode ? languageCode + "-" + scriptCode : null,
+      languageCode + "-" + countryCode,
+      languageCode,
+    ].filter((value): value is string => !!value);
+
+    for (let j = 0; j < combinaisons.length; j++) {
+      const combinaison = combinaisons[j]?.toLowerCase();
+
+      if (!combinaison) {
+        continue;
+      }
+
+      const tagIndex = loweredLanguageTags.indexOf(combinaison);
+      const languageTag = languageTags[tagIndex];
+
+      if (languageTag && tagIndex !== -1) {
+        return { languageTag, isRTL };
+      }
+    }
+  }
+}
+
+export {
+  getCalendar,
+  getCountry,
+  getCurrencies,
+  getLocales,
+  getNumberFormatSettings,
+  getTemperatureUnit,
+  getTimeZone,
+  uses24HourClock,
+  usesAutoDateAndTime,
+  usesAutoTimeZone,
+  usesMetricSystem,
+} from "./module";
+export * from "./types";

package/GetLocals/src/module.ts

@@ -0,0 +1,51 @@
+import NativeModule from "./NativeRNLocalize";
+import type {
+  Calendar,
+  Locale,
+  NumberFormatSettings,
+  TemperatureUnit,
+} from "./types";
+
+export function getCalendar(): Calendar {
+  return NativeModule.getCalendar() as Calendar;
+}
+
+export function getCountry(): string {
+  return NativeModule.getCountry();
+}
+
+export function getCurrencies(): string[] {
+  return NativeModule.getCurrencies();
+}
+
+export function getLocales(): Locale[] {
+  return NativeModule.getLocales() as Locale[];
+}
+
+export function getNumberFormatSettings(): NumberFormatSettings {
+  return NativeModule.getNumberFormatSettings() as NumberFormatSettings;
+}
+
+export function getTemperatureUnit(): TemperatureUnit {
+  return NativeModule.getTemperatureUnit() as TemperatureUnit;
+}
+
+export function getTimeZone(): string {
+  return NativeModule.getTimeZone();
+}
+
+export function uses24HourClock(): boolean {
+  return NativeModule.uses24HourClock();
+}
+
+export function usesMetricSystem(): boolean {
+  return NativeModule.usesMetricSystem();
+}
+
+export function usesAutoDateAndTime(): boolean | undefined {
+  return NativeModule.usesAutoDateAndTime() ?? undefined;
+}
+
+export function usesAutoTimeZone(): boolean | undefined {
+  return NativeModule.usesAutoTimeZone() ?? undefined;
+}

package/GetLocals/src/module.web.ts

@@ -0,0 +1,148 @@
+import {
+  CURRENCIES,
+  USES_FAHRENHEIT,
+  USES_IMPERIAL,
+  USES_RTL_LAYOUT,
+} from "./constants";
+import type {
+  Calendar,
+  Locale,
+  NumberFormatSettings,
+  TemperatureUnit,
+} from "./types";
+
+function ensureCountryCode(countryCode: string): string {
+  return countryCode === "419" ? "UN" : countryCode.toUpperCase();
+}
+
+function splitLanguageTag(languageTag: string): {
+  languageCode: string;
+  countryCode?: string;
+} {
+  const [languageCode = "en", countryCode] = languageTag.split("-");
+  return { languageCode, countryCode };
+}
+
+function convertLanguageTagToLocale(
+  languageTag: string,
+  countryCodeFallback: string,
+): Locale {
+  let { languageCode, countryCode } = splitLanguageTag(languageTag);
+  languageCode = languageCode.toLowerCase();
+  countryCode = ensureCountryCode(countryCode || countryCodeFallback);
+
+  return {
+    languageCode,
+    countryCode,
+    languageTag: `${languageCode}-${countryCode}`,
+    isRTL: USES_RTL_LAYOUT.includes(languageCode),
+  };
+}
+
+function getCurrentLocale(): Locale {
+  return convertLanguageTagToLocale(navigator.language, getCountry());
+}
+
+export function getCalendar(): Calendar {
+  return "gregorian";
+}
+
+export function getCountry(): string {
+  const { languages = [navigator.language] } = navigator;
+
+  for (let i = 0; i < languages.length; i++) {
+    const language = languages[i];
+
+    if (!language) {
+      continue;
+    }
+
+    const { countryCode } = splitLanguageTag(language);
+
+    if (countryCode) {
+      return ensureCountryCode(countryCode);
+    }
+  }
+
+  return "US";
+}
+
+export function getCurrencies(): string[] {
+  const { languages = [navigator.language] } = navigator;
+  const currencies: string[] = [];
+
+  languages.forEach((language) => {
+    const { countryCode } = splitLanguageTag(language);
+
+    if (countryCode) {
+      const currency = CURRENCIES[ensureCountryCode(countryCode)];
+
+      if (currency && currencies.indexOf(currency) === -1) {
+        currencies.push(currency);
+      }
+    }
+  });
+
+  if (currencies.length === 0) {
+    currencies.push("USD");
+  }
+
+  return currencies;
+}
+
+export function getLocales(): Locale[] {
+  const { languages = [navigator.language] } = navigator;
+  const countryCode = getCountry();
+  const cache: string[] = [];
+  const locales: Locale[] = [];
+
+  languages.forEach((language) => {
+    const locale = convertLanguageTagToLocale(language, countryCode);
+
+    if (cache.indexOf(locale.languageTag) === -1) {
+      locales.push(locale);
+      cache.push(locale.languageTag);
+    }
+  });
+
+  return locales;
+}
+
+export function getNumberFormatSettings(): NumberFormatSettings {
+  const { languageTag } = getCurrentLocale();
+  const formatter = new Intl.NumberFormat(languageTag);
+  const separators = formatter.format(1000000.1).replace(/\d/g, "");
+
+  return {
+    decimalSeparator: separators[separators.length - 1] || ".",
+    groupingSeparator: separators[0] || ",",
+  };
+}
+
+export function getTemperatureUnit(): TemperatureUnit {
+  return USES_FAHRENHEIT.includes(getCountry()) ? "fahrenheit" : "celsius";
+}
+
+export function getTimeZone(): string {
+  const { languageTag } = getCurrentLocale();
+  const formatter = new Intl.DateTimeFormat(languageTag, { hour: "numeric" });
+  return formatter.resolvedOptions().timeZone || "Etc/UTC";
+}
+
+export function uses24HourClock(): boolean {
+  const { languageTag } = getCurrentLocale();
+  const formatter = new Intl.DateTimeFormat(languageTag, { hour: "numeric" });
+  return !formatter.format(new Date(2000, 0, 1, 20)).match(/am|pm/i);
+}
+
+export function usesMetricSystem(): boolean {
+  return !USES_IMPERIAL.includes(getCountry());
+}
+
+export function usesAutoDateAndTime(): boolean | undefined {
+  return;
+}
+
+export function usesAutoTimeZone(): boolean | undefined {
+  return;
+}

package/GetLocals/src/types.ts

@@ -0,0 +1,31 @@
+export type TemperatureUnit = "celsius" | "fahrenheit";
+
+// https://developer.apple.com/documentation/foundation/nscalendaridentifier?language=objc
+export type Calendar =
+  | "gregorian"
+  | "buddhist"
+  | "coptic"
+  | "ethiopic"
+  | "ethiopic-amete-alem"
+  | "hebrew"
+  | "indian"
+  | "islamic"
+  | "islamic-umm-al-qura"
+  | "islamic-civil"
+  | "islamic-tabular"
+  | "iso8601"
+  | "japanese"
+  | "persian";
+
+export type Locale = Readonly<{
+  languageCode: string;
+  scriptCode?: string;
+  countryCode: string;
+  languageTag: string;
+  isRTL: boolean;
+}>;
+
+export type NumberFormatSettings = Readonly<{
+  decimalSeparator: string;
+  groupingSeparator: string;
+}>;

package/GetLocation/LocationError.ts

@@ -0,0 +1,20 @@
+export type LocationErrorCode =
+  | 'CANCELLED'
+  | 'UNAVAILABLE'
+  | 'TIMEOUT'
+  | 'UNAUTHORIZED';
+
+export default class LocationError extends Error {
+  code: LocationErrorCode;
+
+  constructor(code: LocationErrorCode, message: string) {
+    super(message);
+    this.code = code;
+  }
+}
+
+export const isLocationError = (error: unknown): error is LocationError => {
+  return Boolean(
+    typeof error === 'object' && error && 'code' in error && 'message' in error,
+  );
+};

package/GetLocation/index.ts

@@ -0,0 +1,46 @@
+import {Linking, NativeModules, Platform} from 'react-native';
+
+import {
+  GetCurrentPositionOptions,
+  Location,
+  requestAndroidPermission,
+} from './utils';
+import LocationError, {isLocationError} from './LocationError';
+
+export {default as LocationError, isLocationError} from './LocationError';
+export type {LocationErrorCode} from './LocationError';
+export type {GetCurrentPositionOptions, Location} from './utils';
+
+const {OS} = Platform;
+const {ShakebugSDKReactNativeGetLocation} = NativeModules;
+
+const DEFAULT_OPTIONS: GetCurrentPositionOptions = {
+  enableHighAccuracy: false,
+  timeout: 60000,
+};
+
+const GetLocation = {
+  async getCurrentPosition(
+    options: GetCurrentPositionOptions = DEFAULT_OPTIONS,
+  ): Promise<Location> {
+    const opts = {...DEFAULT_OPTIONS, ...options};
+    // if (OS === 'android') {
+    //   await requestAndroidPermission(opts.enableHighAccuracy, opts.rationale);
+    // }
+
+    try {
+      return ShakebugSDKReactNativeGetLocation.getCurrentPosition(opts);
+    } catch (error) {
+      if (isLocationError(error)) {
+        throw new LocationError(error.code, error.message);
+      }
+      throw error;
+    }
+  },
+
+  openSettings() {
+    return Linking.openSettings();
+  },
+};
+
+export default GetLocation;

package/GetLocation/utils.ts

@@ -0,0 +1,89 @@
+import { PermissionsAndroid, Rationale } from 'react-native';
+
+import LocationError from './LocationError';
+
+const { PERMISSIONS, RESULTS } = PermissionsAndroid;
+
+export type Location = {
+  /**
+   * The latitude, in degrees
+   */
+  latitude: number;
+  /**
+   * The longitude, in degrees
+   */
+  longitude: number;
+  /**
+   * The altitude if available, in meters above the WGS 84 reference ellipsoid
+   */
+  altitude: number;
+  /**
+   * The estimated horizontal accuracy of this location, radial, in meters
+   */
+  accuracy: number;
+  /**
+   * The speed if it is available, in meters/second over ground
+   */
+  speed: any;
+  /**
+   * The UTC time of this fix, in milliseconds since January 1, 1970.
+   */
+  time: number;
+  /**
+   * (Android only) The bearing, in degrees
+   */
+  bearing?: number;
+  /**
+   * (Android only) The name of the provider that generated this fix
+   */
+  provider?: number;
+  /**
+   * (iOS only) The vertical accuracy of the location. Negative if the altitude is invalid
+   */
+  verticalAccuracy?: number;
+  /**
+   * (iOS only) The course of the location in degrees true North. Negative if course is invalid. (0.0 - 359.9 degrees, 0 being true North)
+   */
+  course?: number;
+};
+
+export type GetCurrentPositionOptions = {
+  /**
+   * Set `true` to use 'fine location' (GPS) our `false` to use 'course location' (Wifi, Bluetooth, 3G).
+   *
+   * Default: false
+   */
+  enableHighAccuracy: boolean;
+  /**
+   * The max time (in milliseconds) that you want to wait to receive a location.
+   *
+   * Default: 60000 (60 seconds)
+   */
+  timeout: number;
+  /**
+   * Android only
+   * See the [React Native docs](https://reactnative.dev/docs/permissionsandroid#request)
+   */
+  rationale?: Rationale;
+};
+
+export async function requestAndroidPermission(
+  enableHighAccuracy: boolean = false,
+  rationale?: Rationale,
+) {
+  const permission = enableHighAccuracy
+    ? PERMISSIONS.ACCESS_FINE_LOCATION
+    : PERMISSIONS.ACCESS_COARSE_LOCATION
+
+  const alreadyGranted = await PermissionsAndroid.check(permission);
+
+  if (alreadyGranted) return true;
+
+  const granted = await PermissionsAndroid.request(permission, rationale);
+
+  if (granted !== RESULTS.GRANTED) {
+    throw new LocationError('UNAUTHORIZED', 'Authorization denied');
+  }
+
+  return true;
+}