@amazon-devices/expo-localization 2.0.1758683737

package/build/Localization.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Localization.types.js","sourceRoot":"","sources":["../src/Localization.types.ts"],"names":[],"mappings":"AA2HA;;GAEG;AACH,MAAM,CAAN,IAAY,OAQX;AARD,WAAY,OAAO;IACjB,yCAAU,CAAA;IACV,yCAAU,CAAA;IACV,2CAAW,CAAA;IACX,+CAAa,CAAA;IACb,6CAAY,CAAA;IACZ,yCAAU,CAAA;IACV,6CAAY,CAAA;AACd,CAAC,EARW,OAAO,KAAP,OAAO,QAQlB;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,kBAuCX;AAvCD,WAAY,kBAAkB;IAC5B,6BAA6B;IAC7B,2CAAqB,CAAA;IACrB,mCAAmC;IACnC,yCAAmB,CAAA;IACnB,sBAAsB;IACtB,uCAAiB,CAAA;IACjB,kCAAkC;IAClC,qCAAe,CAAA;IACf,+DAA+D;IAC/D,yCAAmB,CAAA;IACnB,6DAA6D;IAC7D,2CAAqB,CAAA;IACrB,yBAAyB;IACzB,yCAAmB,CAAA;IACnB,iCAAiC;IACjC,2CAAqB,CAAA;IACrB,kCAAkC;IAClC,uCAAiB,CAAA;IACjB,sBAAsB;IACtB,uCAAiB,CAAA;IACjB,uBAAuB;IACvB,yCAAmB,CAAA;IACnB,kGAAkG;IAClG,qDAA+B,CAAA;IAC/B,8CAA8C;IAC9C,mDAA6B,CAAA;IAC7B,wGAAwG;IACxG,mDAA6B,CAAA;IAC7B,oCAAoC;IACpC,2DAAqC,CAAA;IACrC,+EAA+E;IAC/E,yCAAmB,CAAA;IACnB,iCAAiC;IACjC,2CAAqB,CAAA;IACrB,uBAAuB;IACvB,yCAAmB,CAAA;IACnB,0CAA0C;IAC1C,iCAAW,CAAA;AACb,CAAC,EAvCW,kBAAkB,KAAlB,kBAAkB,QAuC7B","sourcesContent":["// @needsAudit\nexport type Localization = {\n  /**\n   * Three-character ISO 4217 currency code. Returns `null` on web.\n   *\n   * @example `'USD'`, `'EUR'`, `'CNY'`, `null`\n   */\n  currency: string | null;\n  /**\n   * Decimal separator used for formatting numbers.\n   *\n   * @example `','`, `'.'`\n   */\n  decimalSeparator: string;\n  /**\n   * Digit grouping separator used when formatting numbers larger than 1000.\n   *\n   * @example `'.'`, `''`, `','`\n   */\n  digitGroupingSeparator: string;\n  /**\n   * A list of all the supported language ISO codes.\n   */\n  isoCurrencyCodes: string[];\n  /**\n   * Boolean value that indicates whether the system uses the metric system.\n   * On Android and web, this is inferred from the current region.\n   */\n  isMetric: boolean;\n  /**\n   * Returns if the system's language is written from Right-to-Left.\n   * This can be used to build features like [bidirectional icons](https://material.io/design/usability/bidirectionality.html).\n   *\n   * Returns `false` in Server Side Rendering (SSR) environments.\n   */\n  isRTL: boolean;\n  /**\n   * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag),\n   * consisting of a two-character language code and optional script, region and variant codes.\n   *\n   * @example `'en'`, `'en-US'`, `'zh-Hans'`, `'zh-Hans-CN'`, `'en-emodeng'`\n   */\n  locale: string;\n  /**\n   * List of all the native languages provided by the user settings.\n   * These are returned in the order that the user defined in the device settings.\n   *\n   * @example `['en', 'en-US', 'zh-Hans', 'zh-Hans-CN', 'en-emodeng']`\n   */\n  locales: string[];\n  /**\n   * The region code for your device that comes from the Region setting under Language & Region on iOS.\n   * This value is always available on iOS, but might return `null` on Android or web.\n   *\n   * @example `'US'`, `'NZ'`, `null`\n   */\n  region: string | null;\n  /**\n   * The current time zone in display format.\n   * On Web time zone is calculated with Intl.DateTimeFormat().resolvedOptions().timeZone. For a\n   * better estimation you could use the moment-timezone package but it will add significant bloat to\n   * your website's bundle size.\n   *\n   * @example `'America/Los_Angeles'`\n   */\n  timezone: string;\n};\n\nexport type Locale = {\n  /**\n   * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) with a region code.\n   * @example `'en-US'`, `'es-419'`, `'pl-PL'`.\n   */\n  languageTag: string;\n  /**\n   * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) without the region code.\n   * @example `'en'`, `'es'`, `'pl'`.\n   */\n  languageCode: string;\n  /**\n   * The region code for your device that comes from the Region setting under Language & Region on iOS, Region settings on Android and is parsed from locale on Web (can be `null` on Web).\n   */\n  regionCode: string | null;\n  /**\n   * Currency code for the locale.\n   * Is `null` on Web, use a table lookup based on region instead.\n   * @example `'USD'`, `'EUR'`, `'PLN'`.\n   */\n  currencyCode: string | null;\n  /**\n   * Currency symbol for the locale.\n   * Is `null` on Web, use a table lookup based on region (if available) instead.\n   * @example `'$'`, `'€'`, `'zł'`.\n   */\n  currencySymbol: string | null;\n  /**\n   * Decimal separator used for formatting numbers with fractional parts.\n   * @example `'.'`, `','`.\n   */\n  decimalSeparator: string | null;\n  /**\n   * Digit grouping separator used for formatting large numbers.\n   * @example `'.'`, `','`.\n   */\n  digitGroupingSeparator: string | null;\n  /**\n   * Text direction for the locale. One of: `'ltr'`, `'rtl'`, but can also be `null` on some browsers without support for the [textInfo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/textInfo) property in [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) API.\n   */\n  textDirection: 'ltr' | 'rtl' | null;\n  /**\n   * The measurement system used in the locale.\n   * Is `null` on Web, as user chosen measurement system is not exposed on the web and using locale to determine measurement systems is unreliable.\n   * Ask for user preferences if possible.\n   */\n  measurementSystem: `metric` | `us` | `uk` | null;\n\n  /**\n   * The temperature unit used in the locale.\n   * Returns `null` if the region code is unknown.\n   */\n  temperatureUnit: 'celsius' | 'fahrenheit' | null;\n};\n\n/**\n * An enum mapping days of the week in Gregorian calendar to their index as returned by the `firstWeekday` property.\n */\nexport enum Weekday {\n  SUNDAY = 1,\n  MONDAY = 2,\n  TUESDAY = 3,\n  WEDNESDAY = 4,\n  THURSDAY = 5,\n  FRIDAY = 6,\n  SATURDAY = 7,\n}\n\n/**\n * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).\n * Gregorian calendar is aliased and can be referred to as both `CalendarIdentifier.GREGORIAN` and `CalendarIdentifier.GREGORY`.\n */\nexport enum CalendarIdentifier {\n  /** Thai Buddhist calendar */\n  BUDDHIST = 'buddhist',\n  /** Traditional Chinese calendar */\n  CHINESE = 'chinese',\n  /** Coptic calendar */\n  COPTIC = 'coptic',\n  /** Traditional Korean calendar */\n  DANGI = 'dangi',\n  /** Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E) */\n  ETHIOAA = 'ethioaa',\n  /** Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.) */\n  ETHIOPIC = 'ethiopic',\n  /** Gregorian calendar */\n  GREGORY = 'gregory',\n  /** Gregorian calendar (alias) */\n  GREGORIAN = 'gregory',\n  /** Traditional Hebrew calendar */\n  HEBREW = 'hebrew',\n  /** Indian calendar */\n  INDIAN = 'indian',\n  /** Islamic calendar */\n  ISLAMIC = 'islamic',\n  /** Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - civil epoch) */\n  ISLAMIC_CIVIL = 'islamic-civil',\n  /** Islamic calendar, Saudi Arabia sighting */\n  ISLAMIC_RGSA = 'islamic-rgsa',\n  /**Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - astronomical epoch) */\n  ISLAMIC_TBLA = 'islamic-tbla',\n  /** Islamic calendar, Umm al-Qura */\n  ISLAMIC_UMALQURA = 'islamic-umalqura',\n  /** ISO calendar (Gregorian calendar using the ISO 8601 calendar week rules) */\n  ISO8601 = 'iso8601',\n  /** Japanese imperial calendar */\n  JAPANESE = 'japanese',\n  /** Persian calendar */\n  PERSIAN = 'persian',\n  /** Civil (algorithmic) Arabic calendar */\n  ROC = 'roc',\n}\n\nexport type Calendar = {\n  /**\n   * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).\n   *\n   * On Android is limited to one of device's [available calendar types](https://developer.android.com/reference/java/util/Calendar#getAvailableCalendarTypes()).\n   *\n   * On iOS uses [calendar identifiers](https://developer.apple.com/documentation/foundation/calendar/identifier), but maps them to the corresponding Unicode types, will also never contain `'dangi'` or `'islamic-rgsa'` due to it not being implemented on iOS.\n   */\n  calendar: CalendarIdentifier | null;\n  /**\n   * True when current device settings use 24 hour time format.\n   * Can be null on some browsers that don't support the [hourCycle](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/hourCycle) property in [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) API.\n   */\n  uses24hourClock: boolean | null;\n  /**\n   * The first day of the week. For most calendars Sunday is numbered `1`, with Saturday being number `7`.\n   * Can be null on some browsers that don't support the [weekInfo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/weekInfo) property in [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) API.\n   * @example `1`, `7`.\n   */\n  firstWeekday: Weekday | null;\n  /**\n   * Time zone for the calendar. Can be `null` on Web.\n   * @example `'America/Los_Angeles'`, `'Europe/Warsaw'`, `'GMT+1'`.\n   */\n  timeZone: string | null;\n};\n"]}

package/expo-module.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "expo-localization",
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modulesClassNames": ["LocalizationModule"]
+  },
+  "android": {
+    "modulesClassNames": ["expo.modules.localization.LocalizationModule"]
+  }
+}

package/ios/ExpoLocalization.podspec

@@ -0,0 +1,32 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoLocalization'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = { :ios => '13.0', :tvos => '13.0' }
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
+    s.source_files = "**/*.h"
+    s.vendored_frameworks = "#{s.name}.xcframework"
+  else
+    s.source_files = "**/*.{h,m,swift}"
+  end
+end

package/ios/LocalizationModule.swift

@@ -0,0 +1,212 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import Foundation
+import ExpoModulesCore
+
+let LOCALE_SETTINGS_CHANGED = "onLocaleSettingsChanged"
+let CALENDAR_SETTINGS_CHANGED = "onCalendarSettingsChanged"
+
+public class LocalizationModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoLocalization")
+
+    Constants {
+      return Self.getCurrentLocalization()
+    }
+    AsyncFunction("getLocalizationAsync") {
+      return Self.getCurrentLocalization()
+    }
+    Function("getLocales") {
+      return Self.getLocales()
+    }
+    Function("getCalendars") {
+      return Self.getCalendars()
+    }
+    OnCreate {
+      if let enableRTL = Bundle.main.object(forInfoDictionaryKey: "ExpoLocalization_supportsRTL") as? Bool {
+        self.setSupportsRTL(enableRTL)
+      }
+    }
+
+    Events(LOCALE_SETTINGS_CHANGED, CALENDAR_SETTINGS_CHANGED)
+
+    OnStartObserving {
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(LocalizationModule.localeChanged),
+        name: NSLocale.currentLocaleDidChangeNotification, // swiftlint:disable:this legacy_objc_type
+        object: nil
+      )
+    }
+
+    OnStopObserving {
+      NotificationCenter.default.removeObserver(
+        self,
+        name: NSLocale.currentLocaleDidChangeNotification, // swiftlint:disable:this legacy_objc_type
+        object: nil
+      )
+    }
+  }
+
+  func isRTLPreferredForCurrentLocale() -> Bool {
+    // swiftlint:disable:next legacy_objc_type
+    return NSLocale.characterDirection(forLanguage: NSLocale.preferredLanguages.first ?? "en-US") == NSLocale.LanguageDirection.rightToLeft
+  }
+
+  func setSupportsRTL(_ supportsRTL: Bool) {
+    // These keys are used by React Native here: https://github.com/facebook/react-native/blob/main/React/Modules/RCTI18nUtil.m
+    // We set them before React loads to ensure it gets rendered correctly the first time the app is opened.
+    // On iOS we need to set both forceRTL and allowRTL so apps don't have to include localization strings.
+    UserDefaults.standard.set(supportsRTL, forKey: "RCTI18nUtil_allowRTL")
+    UserDefaults.standard.set(supportsRTL ? isRTLPreferredForCurrentLocale() : false, forKey: "RCTI18nUtil_forceRTL")
+    UserDefaults.standard.synchronize()
+  }
+
+  // If the application isn't manually localized for the device language then the
+  // native `Locale.current` will fallback on using English US
+  // [cite](https://stackoverflow.com/questions/48136456/locale-current-reporting-wrong-language-on-device).
+  // This method will attempt to return the locale that the device is using regardless of the app,
+  // providing better parity across platforms.
+  static func getLocale() -> Locale {
+    guard let preferredIdentifier = Locale.preferredLanguages.first else {
+      return Locale.current
+    }
+    return Locale(identifier: preferredIdentifier)
+  }
+  /**
+   Maps ios unique identifiers to [BCP 47 calendar types]
+   (https://github.com/unicode-org/cldr/blob/main/common/bcp47/calendar.xml)
+   */
+  static func getUnicodeCalendarIdentifier(calendar: Calendar) -> String {
+    switch calendar.identifier {
+    case .buddhist:
+      return "buddhist"
+    case .chinese:
+      return "chinese"
+    case .coptic:
+      return "coptic"
+    case .ethiopicAmeteAlem:
+      return "ethioaa"
+    case .ethiopicAmeteMihret:
+      return "ethiopic"
+    case .gregorian:
+      return "gregory"
+    case .hebrew:
+      return "hebrew"
+    case .indian:
+      return "indian"
+    case .islamic:
+      return "islamic"
+    case .islamicCivil:
+      return "islamic-civil"
+    case .islamicTabular:
+      return "islamic-tbla"
+    case .islamicUmmAlQura:
+      return "islamic-umalqura"
+    case .japanese:
+      return "japanese"
+    case .persian:
+      return "persian"
+    case .republicOfChina:
+      return "roc"
+    case .iso8601:
+      return "iso8601"
+    }
+  }
+
+  static func getMeasurementSystemForLocale(_ locale: Locale) -> String {
+    if #available(iOS 16, tvOS 16, *) {
+      let measurementSystems = [
+        Locale.MeasurementSystem.us: "us",
+        Locale.MeasurementSystem.uk: "uk",
+        Locale.MeasurementSystem.metric: "metric"
+      ]
+      return measurementSystems[locale.measurementSystem] ?? "metric"
+    }
+    return locale.usesMetricSystem ? "metric" : "us"
+  }
+
+  static func getLocales() -> [[String: Any?]] {
+    let userSettingsLocale = Locale.current
+
+    return (Locale.preferredLanguages.isEmpty ? [Locale.current.identifier] : Locale.preferredLanguages)
+      .map { languageTag -> [String: Any?] in
+        let languageLocale = Locale.init(identifier: languageTag)
+
+        return [
+          "languageTag": languageTag,
+          "languageCode": languageLocale.languageCode,
+          "regionCode": languageLocale.regionCode,
+          "textDirection": Locale.characterDirection(forLanguage: languageTag) == .rightToLeft ? "rtl" : "ltr",
+          "decimalSeparator": userSettingsLocale.decimalSeparator,
+          "digitGroupingSeparator": userSettingsLocale.groupingSeparator,
+          "measurementSystem": getMeasurementSystemForLocale(userSettingsLocale),
+          "currencyCode": languageLocale.currencyCode,
+          "currencySymbol": languageLocale.currencySymbol,
+          "temperatureUnit": getTemperatureUnit()
+        ]
+      }
+  }
+
+  @objc
+  private func localeChanged() {
+    // we send both events since on iOS it means both calendar and locale needs an update
+    sendEvent(LOCALE_SETTINGS_CHANGED)
+    sendEvent(CALENDAR_SETTINGS_CHANGED)
+  }
+
+  static func getTemperatureUnit() -> String? {
+    let formatter = MeasurementFormatter()
+    formatter.locale = Locale.current
+
+    let temperature = Measurement(value: 0, unit: UnitTemperature.celsius)
+    let formatted = formatter.string(from: temperature)
+
+    guard let unitCharacter = formatted.last else {
+      return nil
+    }
+
+    return unitCharacter == "F" ? "fahrenheit" : "celsius"
+  }
+
+  // https://stackoverflow.com/a/28183182
+  static func uses24HourClock() -> Bool {
+    let dateFormat = DateFormatter.dateFormat(fromTemplate: "j", options: 0, locale: Locale.current)!
+
+    return dateFormat.firstIndex(of: "a") == nil
+  }
+
+  static func getCalendars() -> [[String: Any?]] {
+    var calendar = Locale.current.calendar
+    return [
+      [
+        "calendar": getUnicodeCalendarIdentifier(calendar: calendar),
+        "timeZone": "\(calendar.timeZone.identifier)",
+        "uses24hourClock": uses24HourClock(),
+        "firstWeekday": calendar.firstWeekday
+      ]
+    ]
+  }
+
+  static func getCurrentLocalization() -> [String: Any?] {
+    let locale = getLocale()
+    let languageCode = locale.languageCode ?? "en"
+    var languageIds = Locale.preferredLanguages
+
+    if languageIds.isEmpty {
+      languageIds.append("en-US")
+    }
+    return [
+      "currency": locale.currencyCode ?? "USD",
+      "decimalSeparator": locale.decimalSeparator ?? ".",
+      "digitGroupingSeparator": locale.groupingSeparator ?? ",",
+      "isoCurrencyCodes": Locale.isoCurrencyCodes,
+      "isMetric": locale.usesMetricSystem,
+      "isRTL": Locale.characterDirection(forLanguage: languageCode) == .rightToLeft,
+      "locale": languageIds.first,
+      "locales": languageIds,
+      "region": locale.regionCode ?? "US",
+      "timezone": TimeZone.current.identifier
+    ]
+  }
+}

package/kepler/ExpoLocalization.cpp

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ExpoLocalization.h"
+
+#include <Volta/i18n/I18nManager.h>
+#include <uchar.h>
+#include <unicode/currunit.h>
+#include <unicode/dcfmtsym.h>
+#include <unicode/dtptngen.h>
+#include <unicode/numfmt.h>
+#include <unicode/ulocdata.h>
+
+#include <memory>
+
+std::string toUTF8String(icu::UnicodeString from) {
+    std::string result;
+    from.toUTF8String(result);
+    return result;
+}
+
+ExpoLocalization::ExpoLocalization() : volta::react::KeplerTurboModule("ExpoLocalization") {}
+
+volta::react::NativeJSArray ExpoLocalization::getLocales() {
+    volta::react::NativeJSObject result;
+    UErrorCode status = U_ZERO_ERROR;
+
+    auto appLocale = volta::i18n::I18nManager::getInstance().getAppLocale();
+    icu::Locale loc(appLocale.c_str());
+
+    result["languageCode"] = std::string(loc.getLanguage());
+    result["languageTag"] = appLocale;
+
+    std::unique_ptr<icu::NumberFormat> nf(icu::NumberFormat::createInstance(loc, status));
+    if (U_SUCCESS(status)) {
+        result["currencyCode"] = toUTF8String(nf->getCurrency());
+    } else {
+        result["currencyCode"] = nullptr;
+    }
+
+    status = U_ZERO_ERROR;
+    icu::DecimalFormatSymbols dfs(loc, status);
+    if (U_SUCCESS(status)) {
+        result["currencySymbol"] = toUTF8String(dfs.getSymbol(icu::DecimalFormatSymbols::kCurrencySymbol));
+        result["decimalSeparator"] = toUTF8String(dfs.getSymbol(icu::DecimalFormatSymbols::kDecimalSeparatorSymbol));
+        result["digitGroupingSeparator"] =
+                toUTF8String(dfs.getSymbol(icu::DecimalFormatSymbols::kGroupingSeparatorSymbol));
+    } else {
+        result["currencySymbol"] = nullptr;
+        result["decimalSeparator"] = nullptr;
+        result["digitGroupingSeparator"] = nullptr;
+    }
+
+    status = U_ZERO_ERROR;
+    auto measurementSystem = ulocdata_getMeasurementSystem(loc.getLanguage(), &status);
+    if (measurementSystem == UMS_SI) {
+        result["measurementSystem"] = "metric";
+    } else if (measurementSystem == UMS_US) {
+        result["measurementSystem"] = "imperial";
+    } else if (measurementSystem == UMS_UK) {
+        result["measurementSystem"] = "uk";
+    } else {
+        result["measurementSystem"] = nullptr;
+    }
+
+    result["textDirection"] = loc.isRightToLeft() ? "rtl" : "ltr";
+
+    result["regionCode"] = nullptr;
+
+    return {result};
+}
+
+volta::react::NativeJSArray ExpoLocalization::getCalendars() {
+    volta::react::NativeJSObject calendar;
+
+    auto appLocale = volta::i18n::I18nManager::getInstance().getAppLocale();
+    icu::Locale loc(appLocale.c_str());
+
+    std::string timezone = volta::i18n::I18nManager::getInstance().getTimezone();
+    icu::UnicodeString timezoneUc(timezone.c_str());
+    std::unique_ptr<icu::TimeZone> tz(icu::TimeZone::createTimeZone(timezoneUc));
+
+    UErrorCode status = U_ZERO_ERROR;
+    std::unique_ptr<icu::Calendar> c(icu::Calendar::createInstance(loc, status));
+    if (U_SUCCESS(status)) {
+        calendar["calendar"] = std::string(c->getType());
+    } else {
+        calendar["calendar"] = nullptr;
+    }
+
+    status = U_ZERO_ERROR;
+    int firstWeekday = (int) c->getFirstDayOfWeek(status);
+    if (U_SUCCESS(status)) {
+        calendar["firstWeekday"] = firstWeekday;
+    } else {
+        calendar["firstWeekday"] = nullptr;
+    }
+
+    calendar["uses24hourClock"] = nullptr;
+    status = U_ZERO_ERROR;
+    std::unique_ptr<icu::DateTimePatternGenerator> dtp(icu::DateTimePatternGenerator::createInstance(loc, status));
+    if (U_SUCCESS(status)) {
+        status = U_ZERO_ERROR;
+        auto cycle = dtp->getDefaultHourCycle(status);
+        if (U_SUCCESS(status)) {
+            calendar["uses24hourClock"] = (cycle == UDAT_HOUR_CYCLE_23 || cycle == UDAT_HOUR_CYCLE_24);
+        }
+    }
+
+    if (timezone.length() == 0) {
+        calendar["timezone"] = nullptr;
+    } else {
+        calendar["timezone"] = timezone;
+    }
+
+    return {calendar};
+}
+
+void ExpoLocalization::aggregateMethods(
+        volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept {
+    methodAggregator.addMethod("getLocales", 0, &ExpoLocalization::getLocales);
+    methodAggregator.addMethod("getCalendars", 0, &ExpoLocalization::getCalendars);
+}

package/kepler/ExpoLocalization.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <KeplerScript/modules/KeplerTurboModule.h>
+
+class KEPLERSCRIPT_EXPORT ExpoLocalization : public volta::react::KeplerTurboModule {
+public:
+    ExpoLocalization();
+    volta::react::NativeJSArray getLocales();
+    volta::react::NativeJSArray getCalendars();
+
+protected:
+    void aggregateMethods(
+            volta::react::MethodAggregator<volta::react::KeplerTurboModule>& methodAggregator) const noexcept override;
+};

package/kepler/KeplerInit.cpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/logger/KPLog.h>
+#include <KeplerScript/utils/autolink/KeplerAutoLinkInfo.h>
+#include <keplerui-072/keplerscript-export.h>
+
+#include "ExpoLocalization.h"
+#include "RegisterModule.h"
+
+extern "C" {
+KEPLERSCRIPT_EXPORT void keplerAutoLinkInitV1(const kepler::autolink::v1::KeplerAutoLinkInfo* autoLinkInfo) noexcept {
+    volta::react::KPLog.debug("keplerAutoLinkInitV1 for ExpoLocalization");
+
+    REGISTER_MODULE(autoLinkInfo, ExpoLocalization, "ExpoLocalization");
+}
+}
+
+int main() {
+    return 0;
+}

package/kepler/test/ExpoLocalization.cpp

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "../ExpoLocalization.h"
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+namespace {
+template<typename T>
+void assertKey(const volta::react::NativeJSObject& object, const std::string& key, const T& expectedValue) {
+    EXPECT_TRUE(object.find(key) != std::end(object)) << "Expected key: " << key;
+    EXPECT_EQ(std::get<T>(object.at(key)), expectedValue);
+}
+
+void assertKey(const volta::react::NativeJSObject& object, const std::string& key) {
+    EXPECT_TRUE(object.find(key) != std::end(object)) << "Expected key: " << key;
+}
+}  // namespace
+
+namespace volta::react {
+
+TEST_CASE("ExpoLocalization") {
+    SECTION("getLocales") {
+        ExpoLocalization module;
+
+        auto locales = module.getLocales();
+        EXPECT_EQ(locales.size(), 1);
+
+        auto locale = std::get<NativeJSObject>(locales[0]);
+
+        assertKey(locale, "languageCode");
+        assertKey(locale, "languageTag");
+
+        assertKey(locale, "currencyCode");
+        assertKey(locale, "currencySymbol");
+        assertKey(locale, "digitGroupingSeparator");
+        assertKey(locale, "measurementSystem");
+
+        assertKey<std::string>(locale, "textDirection", "ltr");
+        assertKey<std::nullptr_t>(locale, "regionCode", nullptr);
+    }
+
+    SECTION("getCalendars") {
+        ExpoLocalization module;
+
+        auto calendars = module.getCalendars();
+        EXPECT_EQ(calendars.size(), 1);
+
+        auto calendar = std::get<NativeJSObject>(calendars[0]);
+
+        assertKey<std::string>(calendar, "calendar", "gregorian");
+        assertKey(calendar, "firstWeekday");
+        assertKey(calendar, "uses24hourClock");
+        assertKey<std::nullptr_t>(calendar, "timezone", nullptr);
+    }
+
+    SECTION("aggregateMethods") {
+        ExpoLocalization module;
+
+        std::weak_ptr<facebook::react::Instance> instance;
+
+        module.triggerMethodAggregation(*module.jsQueue_, instance);
+
+        auto end = module.methodContainerMap_.end();
+        REQUIRE(module.methodContainerMap_.find("getLocales") != end);
+        REQUIRE(module.methodContainerMap_.find("getCalendars") != end);
+    }
+}
+}  // namespace volta::react

package/package.json

@@ -0,0 +1 @@
+{"name": "@amazon-devices/expo-localization", "version": "2.0.1758683737+14.6.0", "description": "Provides an interface for native user localization information.", "main": "build/Localization.js", "types": "build/Localization.d.ts", "sideEffects": false, "scripts": {"build": "expo-module build", "clean": "expo-module clean", "lint": "expo-module lint", "test": "expo-module test", "expo-module": "expo-module"}, "kepler": {"temporary-alias-for-package": {"name": "expo-localization", "version": "14.6.0"}}, "keywords": ["react-native", "expo", "localization", "locales", "l10n"], "repository": {"type": "git", "url": "https://github.com/expo/expo.git", "directory": "packages/expo-localization"}, "bugs": {"url": "https://github.com/expo/expo/issues"}, "contributors": ["Evan Bacon <bacon@expo.io> (https://github.com/evanbacon)"], "author": "650 Industries, Inc.", "license": "See license in LICENSE", "homepage": "https://docs.expo.dev/versions/latest/sdk/localization/", "jest": {"preset": "expo-module-scripts"}, "dependencies": {"rtl-detect": "^1.0.2"}, "devDependencies": {"expo-module-scripts": "^3.0.0", "i18n-js": "^3.1.0"}, "peerDependencies": {"expo": "*"}}

package/plugin/build/withExpoLocalization.d.ts

@@ -0,0 +1,7 @@
+import { ExpoConfig } from '@expo/config-types';
+type ConfigPluginProps = {
+    supportsRTL?: boolean;
+    allowDynamicLocaleChangesAndroid?: boolean;
+};
+declare function withExpoLocalization(config: ExpoConfig, data?: ConfigPluginProps): ExpoConfig;
+export default withExpoLocalization;

package/plugin/build/withExpoLocalization.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+const config_plugins_1 = require("expo/config-plugins");
+function withExpoLocalizationIos(config) {
+    if (config.extra?.supportsRTL == null)
+        return config;
+    if (!config.ios)
+        config.ios = {};
+    if (!config.ios.infoPlist)
+        config.ios.infoPlist = {};
+    config.ios.infoPlist.ExpoLocalization_supportsRTL = config.extra?.supportsRTL || false;
+    return config;
+}
+function withExpoLocalizationAndroid(config, data) {
+    if (data.allowDynamicLocaleChangesAndroid) {
+        config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+            const mainActivity = (0, Manifest_1.getMainActivityOrThrow)(config.modResults);
+            if (!mainActivity.$['android:configChanges']?.includes('locale')) {
+                mainActivity.$['android:configChanges'] += '|locale';
+            }
+            if (!mainActivity.$['android:configChanges']?.includes('layoutDirection')) {
+                mainActivity.$['android:configChanges'] += '|layoutDirection';
+            }
+            return config;
+        });
+    }
+    return (0, config_plugins_1.withStringsXml)(config, (config) => {
+        config.modResults = config_plugins_1.AndroidConfig.Strings.setStringItem([
+            {
+                $: { name: 'ExpoLocalization_supportsRTL', translatable: 'false' },
+                _: String(data.supportsRTL ?? config.extra?.supportsRTL),
+            },
+        ], config.modResults);
+        return config;
+    });
+}
+function withExpoLocalization(config, data = {
+    allowDynamicLocaleChangesAndroid: true,
+}) {
+    return (0, config_plugins_1.withPlugins)(config, [
+        [withExpoLocalizationIos, data],
+        [withExpoLocalizationAndroid, data],
+    ]);
+}
+exports.default = withExpoLocalization;

package/plugin/src/withExpoLocalization.ts

@@ -0,0 +1,62 @@
+import { getMainActivityOrThrow } from '@expo/config-plugins/build/android/Manifest';
+import { ExpoConfig } from '@expo/config-types';
+import {
+  AndroidConfig,
+  withAndroidManifest,
+  withPlugins,
+  withStringsXml,
+} from 'expo/config-plugins';
+
+type ConfigPluginProps = {
+  supportsRTL?: boolean;
+  allowDynamicLocaleChangesAndroid?: boolean;
+};
+
+function withExpoLocalizationIos(config: ExpoConfig) {
+  if (config.extra?.supportsRTL == null) return config;
+  if (!config.ios) config.ios = {};
+  if (!config.ios.infoPlist) config.ios.infoPlist = {};
+  config.ios.infoPlist.ExpoLocalization_supportsRTL = config.extra?.supportsRTL || false;
+  return config;
+}
+
+function withExpoLocalizationAndroid(config: ExpoConfig, data: ConfigPluginProps) {
+  if (data.allowDynamicLocaleChangesAndroid) {
+    config = withAndroidManifest(config, (config) => {
+      const mainActivity = getMainActivityOrThrow(config.modResults);
+      if (!mainActivity.$['android:configChanges']?.includes('locale')) {
+        mainActivity.$['android:configChanges'] += '|locale';
+      }
+      if (!mainActivity.$['android:configChanges']?.includes('layoutDirection')) {
+        mainActivity.$['android:configChanges'] += '|layoutDirection';
+      }
+      return config;
+    });
+  }
+  return withStringsXml(config, (config) => {
+    config.modResults = AndroidConfig.Strings.setStringItem(
+      [
+        {
+          $: { name: 'ExpoLocalization_supportsRTL', translatable: 'false' },
+          _: String(data.supportsRTL ?? config.extra?.supportsRTL),
+        },
+      ],
+      config.modResults
+    );
+    return config;
+  });
+}
+
+function withExpoLocalization(
+  config: ExpoConfig,
+  data: ConfigPluginProps = {
+    allowDynamicLocaleChangesAndroid: true,
+  }
+) {
+  return withPlugins(config, [
+    [withExpoLocalizationIos, data],
+    [withExpoLocalizationAndroid, data],
+  ]);
+}
+
+export default withExpoLocalization;

package/plugin/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "expo-module-scripts/tsconfig.plugin",
+  "compilerOptions": {
+    "outDir": "build",
+    "rootDir": "src"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}

package/plugin/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/withExpoLocalization.ts"],"version":"5.7.2"}