gt-react-native 10.20.4 → 11.0.0-odysseus.1

package/src/hooks/selectors.ts

@@ -0,0 +1,17 @@
+import { useSetLocale, useSetRegion } from './condition-store';
+import {
+  useInternalLocaleSelector,
+  useInternalRegionSelector,
+} from '@generaltranslation/react-core/hooks';
+import type { InternalRegionSelectorOptions } from '@generaltranslation/react-core/hooks';
+
+export function useLocaleSelector(locales?: string[]) {
+  const setLocale = useSetLocale();
+  return { setLocale, ...useInternalLocaleSelector(locales) };
+}
+
+export function useRegionSelector(options?: InternalRegionSelectorOptions) {
+  const setLocale = useSetLocale();
+  const setRegion = useSetRegion();
+  return { setLocale, setRegion, ...useInternalRegionSelector(options) };
+}

package/src/hooks/utils.ts

@@ -0,0 +1,14 @@
+import { getVersionId } from '@generaltranslation/react-core/pure';
+import {
+  useLocale,
+  useLocaleDirection as useCoreLocaleDirection,
+} from '@generaltranslation/react-core/hooks';
+
+export function useLocaleDirection(locale?: string): 'ltr' | 'rtl' {
+  const currentLocale = useLocale();
+  return useCoreLocaleDirection(locale ?? currentLocale);
+}
+
+export function useVersionId(): string | undefined {
+  return getVersionId();
+}

package/src/index.tsx

@@ -1,80 +1,98 @@
 import { GTProvider } from './provider/GTProvider';
+import {
+  useSetLocale,
+  useSetRegion,
+  useSetEnableI18n,
+} from './hooks/condition-store';
+import { useLocaleSelector, useRegionSelector } from './hooks/selectors';
+import { useLocaleDirection, useVersionId } from './hooks/utils';
 import { getLocaleFromNativeStore } from './utils/nativeStore';
+import { getLocale } from './utils/getLocale';
+import { initializeGT } from './setup/initializeGT';
+import type { GTProviderProps } from './provider/GTProvider';
+import type { GetLocaleParams } from './utils/getLocale';
+import type { InitializeGTParams } from './setup/initializeGT';
 
-import {
+import type {
+  DictionaryTranslationOptions,
+  InlineTranslationOptions,
+  RuntimeTranslationOptions,
+} from '@generaltranslation/react-core/pure';
+import type {
+  RenderPipeline,
+  RenderPreparedT,
+} from '@generaltranslation/react-core/pure';
+
+export {
+  // ===== Components ===== //
+  Branch,
+  Plural,
+  Derive,
   T,
-  useGT,
-  useTranslations,
-  useDefaultLocale,
-  useLocale,
-  useRegion,
-  Var,
-  Num,
   Currency,
   DateTime,
   RelativeTime,
-  Static,
-  Plural,
-  Branch,
-  useVersionId,
+  Var,
+  Num,
+} from '@generaltranslation/react-core/components';
+
+export {
+  // ===== Hooks ===== //
+  useLocale,
+  useCustomMapping,
+  useDefaultLocale,
+  useEnableI18n,
   useLocales,
-  useLocaleSelector,
-  useSetLocale,
-  useGTClass,
-  useLocaleProperties,
-  useRegionSelector,
-  useLocaleDirection,
+  useFormatLocales,
+  useGT,
   useMessages,
+  useTranslations,
+} from '@generaltranslation/react-core/hooks';
+
+export {
+  // ===== Functions ===== //
   msg,
   decodeMsg,
   decodeOptions,
-  gtFallback,
-  mFallback,
-  declareStatic,
+  derive,
   declareVar,
   decodeVars,
-} from '@generaltranslation/react-core';
-import type {
-  DictionaryTranslationOptions,
-  InlineTranslationOptions,
-  RuntimeTranslationOptions,
-} from '@generaltranslation/react-core/types';
+  mFallback,
+  gtFallback,
+  getFormatLocales,
+  getTranslationsSnapshot,
+  getReactI18nCache,
+  setReactI18nCache,
+  createRenderPipeline,
+} from '@generaltranslation/react-core/pure';
+
+export {
+  useRegion,
+  useGTClass,
+  useLocaleProperties,
+} from '@generaltranslation/react-core/hooks';
 
 export {
-  Static,
-  Var,
-  Num,
-  Currency,
-  DateTime,
-  RelativeTime,
-  T,
   GTProvider,
-  Plural,
-  Branch,
-  useGT,
-  useTranslations,
-  useDefaultLocale,
-  useLocale,
-  useLocales,
   useSetLocale,
+  useSetRegion,
+  useSetEnableI18n,
   useLocaleSelector,
-  useRegion,
   useRegionSelector,
-  useGTClass,
-  useLocaleProperties,
   useLocaleDirection,
   useVersionId,
   getLocaleFromNativeStore,
-  type DictionaryTranslationOptions,
-  type InlineTranslationOptions,
-  type RuntimeTranslationOptions,
-  msg,
-  decodeMsg,
-  decodeOptions,
-  useMessages,
-  gtFallback,
-  mFallback,
-  declareStatic,
-  declareVar,
-  decodeVars,
+  getLocale,
+  initializeGT,
+};
+
+export type {
+  DictionaryTranslationOptions,
+  InlineTranslationOptions,
+  RuntimeTranslationOptions,
+  RenderPipeline,
+  RenderPreparedT,
+  GTProviderProps,
+  GetLocaleParams,
+  InitializeGTParams,
 };

package/src/provider/GTProvider.tsx

@@ -1,20 +1,110 @@
-import { useDetermineLocale } from './hooks/locale/useDetermineLocale';
-import type { GTProviderProps } from '../types/config';
-import { GTProvider as _GTProvider } from '@generaltranslation/react-core';
-import { readAuthFromEnv } from '../utils/utils';
-import { useRegionState } from './hooks/useRegionState';
+import type { InternalGTProviderProps } from '@generaltranslation/react-core/components';
+import { Suspense, use, useCallback, useMemo, useState } from 'react';
+import type { ReactNode } from 'react';
+import { ActivityIndicator, StyleSheet, View } from 'react-native';
+import type { LocaleCandidates, Locale } from 'gt-i18n/internal/types';
+import type {
+  NativeConditionStoreParams,
+  NativeConditionStoreState,
+} from '../condition-store/NativeConditionStore';
+import { getLocale } from '../utils/getLocale';
+import {
+  getInitialEnableI18n,
+  getInitialRegion,
+} from '../utils/getInitialNativeConditions';
+import { resolveLocale } from '../utils/resolveLocale';
+import { loadTranslations, type LocaleTranslations } from './loadTranslations';
+import { NativeGTProvider } from './NativeGTProvider';
+
+export type GTProviderProps = Omit<
+  InternalGTProviderProps,
+  'conditionStore' | 'i18nStore' | 'translations'
+> &
+  Omit<NativeConditionStoreParams, 'locale' | '_reload'> & {
+    children?: ReactNode;
+    locale?: LocaleCandidates;
+    loadingFallback?: ReactNode;
+  };
+
+type LoadableGTProviderProps = Omit<GTProviderProps, 'loadingFallback'>;
+type TranslationSnapshot = Record<Locale, LocaleTranslations>;
+
+export function GTProvider(props: GTProviderProps) {
+  const { loadingFallback, ...providerProps } = props;
+
+  return (
+    <Suspense fallback={loadingFallback ?? <DefaultLoadingFallback />}>
+      <LoadableGTProvider {...providerProps} />
+    </Suspense>
+  );
+}
+
+/**
+ * This wrapper takes the place of a loader that would be present in
+ * SSR style applications.
+ */
+function LoadableGTProvider(props: LoadableGTProviderProps) {
+  const {
+    locale,
+    localeStoreKey,
+    region,
+    regionStoreKey,
+    enableI18n,
+    enableI18nStoreKey,
+  } = props;
+  // Keep native conditions in React state so condition-store writes trigger rerenders.
+  const [nativeConditions, setNativeConditions] =
+    useState<NativeConditionStoreState>(() => ({
+      locale: getLocale({ localeStoreKey }),
+      region: getInitialRegion({ region, regionStoreKey }),
+      enableI18n: getInitialEnableI18n({ enableI18n, enableI18nStoreKey }),
+    }));
+  const activeLocale = resolveLocale(locale ?? nativeConditions.locale);
+  const activeRegion = region ?? nativeConditions.region;
+  const activeEnableI18n = enableI18n ?? nativeConditions.enableI18n;
+  const localeTranslations = use(loadTranslations(activeLocale));
+  const translations = useMemo<TranslationSnapshot>(
+    () => ({ [activeLocale]: localeTranslations }),
+    [activeLocale, localeTranslations]
+  );
+  const reload = useCallback(
+    (state: NativeConditionStoreState) => {
+      setNativeConditions((previousState) => ({
+        locale: locale === undefined ? state.locale : previousState.locale,
+        region: region === undefined ? state.region : previousState.region,
+        enableI18n:
+          enableI18n === undefined
+            ? state.enableI18n
+            : previousState.enableI18n,
+      }));
+    },
+    [enableI18n, locale, region]
+  );
 
-export function GTProvider(props: GTProviderProps): React.JSX.Element {
   return (
-    <_GTProvider
-      ssr={false}
-      environment={__DEV__ ? 'development' : 'production'}
+    <NativeGTProvider
       {...props}
-      readAuthFromEnv={readAuthFromEnv}
-      useDetermineLocale={useDetermineLocale}
-      useRegionState={useRegionState}
+      locale={activeLocale}
+      region={activeRegion}
+      enableI18n={activeEnableI18n}
+      translations={translations}
+      _reload={reload}
     />
   );
 }
 
-export default GTProvider;
+function DefaultLoadingFallback() {
+  return (
+    <View style={styles.loadingContainer}>
+      <ActivityIndicator />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  loadingContainer: {
+    flex: 1,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+});

package/src/provider/NativeGTProvider.tsx

@@ -0,0 +1,44 @@
+import {
+  I18nStore,
+  InternalGTProvider,
+  type InternalGTProviderProps,
+} from '@generaltranslation/react-core/components';
+import { useMemo, useRef } from 'react';
+import type { LocaleCandidates } from 'gt-i18n/internal/types';
+import type { NativeConditionStoreParams } from '../condition-store/NativeConditionStore';
+import { NativeConditionStore } from '../condition-store/NativeConditionStore';
+
+export type NativeGTProviderProps = Omit<
+  InternalGTProviderProps,
+  'conditionStore' | 'i18nStore'
+> &
+  Omit<NativeConditionStoreParams, 'locale'> & {
+    locale: LocaleCandidates;
+  };
+
+export function NativeGTProvider(props: NativeGTProviderProps) {
+  const conditionStore = useMemo(() => {
+    return new NativeConditionStore(props);
+  }, [
+    props.locale,
+    props.region,
+    props.enableI18n,
+    props.localeStoreKey,
+    props.regionStoreKey,
+    props.enableI18nStoreKey,
+    props._reload,
+  ]);
+
+  const i18nStoreRef = useRef<I18nStore | null>(null);
+  if (i18nStoreRef.current == null) {
+    i18nStoreRef.current = new I18nStore();
+  }
+
+  return (
+    <InternalGTProvider
+      {...props}
+      conditionStore={conditionStore}
+      i18nStore={i18nStoreRef.current}
+    />
+  );
+}

package/src/provider/loadTranslations.ts

@@ -0,0 +1,34 @@
+import { getReactI18nCache } from '@generaltranslation/react-core/pure';
+import type { Hash } from 'gt-i18n/internal/types';
+import type { Translation } from 'gt-i18n/types';
+
+export type LocaleTranslations = Record<Hash, Translation>;
+
+const translationPromises = new WeakMap<
+  object,
+  Map<string, Promise<LocaleTranslations>>
+>();
+
+export function loadTranslations(locale: string): Promise<LocaleTranslations> {
+  const i18nCache = getReactI18nCache();
+  let i18nCacheTranslationPromises = translationPromises.get(i18nCache);
+  if (i18nCacheTranslationPromises == null) {
+    i18nCacheTranslationPromises = new Map();
+    translationPromises.set(i18nCache, i18nCacheTranslationPromises);
+  }
+
+  let promise = i18nCacheTranslationPromises.get(locale);
+  if (promise == null) {
+    // TODO: Support promise caching in i18nCache in a separate PR.
+    promise = i18nCache.loadTranslations(locale).catch((error: unknown) => {
+      i18nCacheTranslationPromises.delete(locale);
+      console.warn(
+        `Failed to load translations for locale "${locale}". Falling back to an empty translation snapshot.`,
+        error
+      );
+      return {};
+    });
+    i18nCacheTranslationPromises.set(locale, promise);
+  }
+  return promise;
+}

package/src/setup/initializeGT.ts

@@ -0,0 +1,23 @@
+import {
+  initializeI18nConfig,
+  setReactI18nCache,
+} from '@generaltranslation/react-core/pure';
+import { ReactI18nCache } from '@generaltranslation/react-core/pure';
+import type { ReactI18nCacheParams } from '@generaltranslation/react-core/pure';
+import { setupGTServicesEnabled } from 'gt-i18n/internal';
+import type {
+  GTServicesEnabledParams,
+  I18nConfigParams,
+} from 'gt-i18n/internal/types';
+
+export type InitializeGTParams = I18nConfigParams &
+  GTServicesEnabledParams &
+  ReactI18nCacheParams;
+
+export function initializeGT(config: InitializeGTParams): void {
+  setupGTServicesEnabled(config);
+  initializeI18nConfig(config, 'server-render');
+
+  const i18nCache = new ReactI18nCache(config);
+  setReactI18nCache(i18nCache);
+}

package/src/utils/getInitialNativeConditions.ts

@@ -0,0 +1,35 @@
+import type { WritableConditionStoreParams } from 'gt-i18n/internal/types';
+import {
+  defaultEnableI18nCookieName as defaultEnableI18nStoreKey,
+  defaultRegionCookieName as defaultRegionStoreKey,
+} from '@generaltranslation/react-core/pure';
+import { nativeStoreGet } from './nativeStore';
+
+type InitialRegionParams = Pick<WritableConditionStoreParams, 'region'> & {
+  regionStoreKey?: string;
+};
+
+type InitialEnableI18nParams = Pick<
+  WritableConditionStoreParams,
+  'enableI18n'
+> & {
+  enableI18nStoreKey?: string;
+};
+
+export function getInitialRegion({
+  region,
+  regionStoreKey = defaultRegionStoreKey,
+}: InitialRegionParams): string | undefined {
+  if (region !== undefined) return region;
+  return nativeStoreGet(regionStoreKey) || undefined;
+}
+
+export function getInitialEnableI18n({
+  enableI18n,
+  enableI18nStoreKey = defaultEnableI18nStoreKey,
+}: InitialEnableI18nParams): boolean {
+  if (enableI18n !== undefined) return enableI18n;
+  const storedEnableI18n = nativeStoreGet(enableI18nStoreKey);
+  if (storedEnableI18n === null) return true;
+  return storedEnableI18n === 'true';
+}

package/src/utils/getLocale.ts

@@ -0,0 +1,34 @@
+import type { LocaleCandidates } from 'gt-i18n/internal/types';
+import { defaultLocaleCookieName as defaultLocaleStoreKey } from '@generaltranslation/react-core/pure';
+import { getNativeLocales } from './getNativeLocales';
+import { nativeStoreGet } from './nativeStore';
+import { resolveLocale } from './resolveLocale';
+
+export type GetLocaleParams = {
+  localeStoreKey?: string;
+};
+
+/**
+ * @internal
+ */
+export function getLocale({
+  localeStoreKey = defaultLocaleStoreKey,
+}: GetLocaleParams = {}): string {
+  const candidates: string[] = [];
+  pushLocaleCandidates(candidates, nativeStoreGet(localeStoreKey));
+  candidates.push(...getNativeLocales());
+
+  return resolveLocale(candidates);
+}
+
+function pushLocaleCandidates(
+  target: string[],
+  locale: LocaleCandidates | null
+) {
+  if (!locale) return;
+  if (Array.isArray(locale)) {
+    target.push(...locale);
+    return;
+  }
+  target.push(locale);
+}

package/src/utils/nativeStore.ts

@@ -1,4 +1,4 @@
-import { defaultLocaleCookieName } from '@generaltranslation/react-core/internal';
+import { defaultLocaleCookieName as defaultLocaleStoreKey } from '@generaltranslation/react-core/pure';
 import { Platform } from 'react-native';
 import GtReactNative from '../NativeGtReactNative';
 import { ssrUnsupportedWarning } from '../errors-dir/warnings';
@@ -9,13 +9,13 @@ import { ssrUnsupportedWarning } from '../errors-dir/warnings';
  * This reads persisted native storage directly, so it can temporarily be out of
  * sync with React state while a locale change is in progress.
  *
- * If GTProvider uses a custom localeCookieName, pass that same value as the key.
+ * If GTProvider uses a custom localeStoreKey, pass that same value as the key.
  *
  * @param key - The key to get the locale from
  * @returns The locale from the native store
  */
 export function getLocaleFromNativeStore(
-  key = defaultLocaleCookieName
+  key = defaultLocaleStoreKey
 ): string | null {
   return nativeStoreGet(key);
 }

package/src/utils/resolveLocale.ts

@@ -0,0 +1,10 @@
+import { getI18nConfig } from 'gt-i18n/internal';
+import type { LocaleCandidates } from 'gt-i18n/internal/types';
+
+export function resolveLocale(candidates?: LocaleCandidates | null): string {
+  const i18nConfig = getI18nConfig();
+  return (
+    i18nConfig.determineLocale(candidates ?? undefined) ||
+    i18nConfig.getDefaultLocale()
+  );
+}

package/src/utils/utils.ts

@@ -1,7 +1,7 @@
 import type {
   AuthFromEnvParams,
   AuthFromEnvReturn,
-} from '@generaltranslation/react-core/types';
+} from '@generaltranslation/react-core/pure';
 
 export function readAuthFromEnv(params: AuthFromEnvParams): AuthFromEnvReturn {
   const { projectId, devApiKey } = params;

package/dist/commonjs/provider/hooks/locale/useDetermineLocale.js

@@ -1,102 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../../../_virtual/_rolldown/runtime.js");
-const require_errors_dir_constants = require("../../../errors-dir/constants.js");
-const require_utils_getNativeLocales = require("../../../utils/getNativeLocales.js");
-const require_utils_nativeStore = require("../../../utils/nativeStore.js");
-let react = require("react");
-let _generaltranslation_format = require("@generaltranslation/format");
-let _generaltranslation_react_core_internal = require("@generaltranslation/react-core/internal");
-let generaltranslation_internal = require("generaltranslation/internal");
-let _generaltranslation_react_core_errors = require("@generaltranslation/react-core/errors");
-//#region src/provider/hooks/locale/useDetermineLocale.ts
-function useDetermineLocale({ locale: _locale = "", defaultLocale = generaltranslation_internal.libraryDefaultLocale, locales = [], localeCookieName = _generaltranslation_react_core_internal.defaultLocaleCookieName, ssr = false, customMapping, enableI18n }) {
-	_locale = (0, _generaltranslation_format.resolveAliasLocale)(_locale, customMapping);
-	locales = locales.map((locale) => (0, _generaltranslation_format.resolveAliasLocale)(locale, customMapping));
-	const initializeLocale = () => {
-		if (!enableI18n) return defaultLocale;
-		return (0, _generaltranslation_format.resolveAliasLocale)(ssr ? _locale ? (0, _generaltranslation_format.determineLocale)(_locale, locales, customMapping) || "" : "" : getNewLocale({
-			_locale,
-			locale: _locale,
-			locales,
-			defaultLocale,
-			localeCookieName,
-			customMapping,
-			enableI18n
-		}), customMapping);
-	};
-	const [locale, _setLocale] = (0, react.useState)(initializeLocale());
-	const [setLocale, setLocaleWithoutPersist] = createSetLocale({
-		locale,
-		locales,
-		defaultLocale,
-		localeCookieName,
-		_setLocale,
-		customMapping,
-		enableI18n
-	});
-	(0, react.useEffect)(() => {
-		setLocaleWithoutPersist(getNewLocale({
-			_locale,
-			locale,
-			locales,
-			defaultLocale,
-			localeCookieName,
-			customMapping,
-			enableI18n
-		}));
-	}, [
-		_locale,
-		locale,
-		locales,
-		defaultLocale,
-		localeCookieName,
-		customMapping,
-		enableI18n
-	]);
-	return [locale, setLocale];
-}
-/**
-* Choose a locale to use
-* (1) use provided locale
-* (2) use cookie locale
-* (3) use preferred locale
-* (5) fallback to defaultLocale
-* Update the cookie locale to be correct
-*/
-function getNewLocale({ _locale, locale, locales, defaultLocale, localeCookieName, customMapping, enableI18n }) {
-	if (!enableI18n) return defaultLocale;
-	if (_locale && _locale === locale && (0, _generaltranslation_format.determineLocale)(_locale, locales, customMapping) === locale) return (0, _generaltranslation_format.resolveAliasLocale)(_locale, customMapping);
-	let storedLocale = require_utils_nativeStore.nativeStoreGet(localeCookieName);
-	if (storedLocale) storedLocale = (0, _generaltranslation_format.resolveAliasLocale)(storedLocale, customMapping);
-	let preferredLocales = require_utils_getNativeLocales.getNativeLocales();
-	if (preferredLocales.length === 0) preferredLocales = [defaultLocale];
-	preferredLocales = preferredLocales.map((l) => (0, _generaltranslation_format.resolveAliasLocale)(l, customMapping));
-	let newLocale = (0, _generaltranslation_format.determineLocale)([
-		..._locale ? [_locale] : [],
-		...storedLocale ? [storedLocale] : [],
-		...preferredLocales
-	], locales, customMapping) || defaultLocale;
-	if (newLocale) newLocale = (0, _generaltranslation_format.resolveAliasLocale)(newLocale, customMapping);
-	if (storedLocale && storedLocale !== newLocale) require_utils_nativeStore.nativeStoreSet(localeCookieName, newLocale);
-	return newLocale;
-}
-function createSetLocale({ locale, locales, defaultLocale, _setLocale, localeCookieName, customMapping, enableI18n }) {
-	locale = (0, _generaltranslation_format.resolveAliasLocale)(locale, customMapping);
-	const setLocaleWithoutPersist = (newLocale) => {
-		if (!enableI18n) return defaultLocale;
-		const validatedLocale = (0, _generaltranslation_format.resolveAliasLocale)((0, _generaltranslation_format.determineLocale)(newLocale, locales, customMapping) || locale || defaultLocale, customMapping);
-		if (validatedLocale !== newLocale) console.warn((0, _generaltranslation_react_core_errors.createUnsupportedLocaleWarning)(validatedLocale, newLocale, require_errors_dir_constants.PACKAGE_NAME));
-		_setLocale(validatedLocale);
-		return validatedLocale;
-	};
-	const setLocale = (newLocale) => {
-		if (!enableI18n) return;
-		newLocale = (0, _generaltranslation_format.resolveAliasLocale)(newLocale, customMapping);
-		require_utils_nativeStore.nativeStoreSet(localeCookieName, setLocaleWithoutPersist(newLocale));
-	};
-	return [setLocale, setLocaleWithoutPersist];
-}
-//#endregion
-exports.useDetermineLocale = useDetermineLocale;
-
-//# sourceMappingURL=useDetermineLocale.js.map

package/dist/commonjs/provider/hooks/locale/useDetermineLocale.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useDetermineLocale.js","names":["libraryDefaultLocale","defaultLocaleCookieName","nativeStoreGet","getNativeLocales","PACKAGE_NAME"],"sources":["../../../../../src/provider/hooks/locale/useDetermineLocale.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport type { Dispatch, SetStateAction } from 'react';\nimport {\n  determineLocale,\n  resolveAliasLocale,\n} from '@generaltranslation/format';\nimport { defaultLocaleCookieName } from '@generaltranslation/react-core/internal';\nimport { libraryDefaultLocale } from 'generaltranslation/internal';\nimport type { CustomMapping } from '@generaltranslation/format/types';\nimport type {\n  UseDetermineLocaleParams,\n  UseDetermineLocaleReturn,\n} from '@generaltranslation/react-core/types';\nimport { createUnsupportedLocaleWarning } from '@generaltranslation/react-core/errors';\nimport { PACKAGE_NAME } from '../../../errors-dir/constants';\nimport { getNativeLocales } from '../../../utils/getNativeLocales';\nimport { nativeStoreGet, nativeStoreSet } from '../../../utils/nativeStore';\n\nexport function useDetermineLocale({\n  locale: _locale = '',\n  defaultLocale = libraryDefaultLocale,\n  locales = [],\n  localeCookieName = defaultLocaleCookieName,\n  ssr = false, // not relevant\n  customMapping,\n  enableI18n,\n}: UseDetermineLocaleParams): UseDetermineLocaleReturn {\n  // resolve alias locale\n  _locale = resolveAliasLocale(_locale, customMapping);\n  locales = locales.map((locale) => resolveAliasLocale(locale, customMapping));\n\n  const initializeLocale = () => {\n    if (!enableI18n) {\n      return defaultLocale;\n    }\n    const result = resolveAliasLocale(\n      ssr\n        ? _locale\n          ? determineLocale(_locale, locales, customMapping) || ''\n          : ''\n        : getNewLocale({\n            _locale,\n            locale: _locale,\n            locales,\n            defaultLocale,\n            localeCookieName,\n            customMapping,\n            enableI18n,\n          }),\n      customMapping\n    );\n    return result;\n  };\n\n  // maintaining the state of locale\n  const [locale, _setLocale] = useState<string>(initializeLocale());\n\n  // Functions for setting internal locale state\n  const [setLocale, setLocaleWithoutPersist] = createSetLocale({\n    locale,\n    locales,\n    defaultLocale,\n    localeCookieName,\n    _setLocale,\n    customMapping,\n    enableI18n,\n  });\n\n  // check browser for locales\n  useEffect(() => {\n    const newLocale = getNewLocale({\n      _locale,\n      locale,\n      locales,\n      defaultLocale,\n      localeCookieName,\n      customMapping,\n      enableI18n,\n    });\n    setLocaleWithoutPersist(newLocale);\n  }, [\n    _locale,\n    locale,\n    locales,\n    defaultLocale,\n    localeCookieName,\n    customMapping,\n    enableI18n,\n  ]);\n\n  return [locale, setLocale];\n}\n\n// ----- HELPER FUNCTIONS ---- //\n\n/**\n * Choose a locale to use\n * (1) use provided locale\n * (2) use cookie locale\n * (3) use preferred locale\n * (5) fallback to defaultLocale\n * Update the cookie locale to be correct\n */\nfunction getNewLocale({\n  _locale,\n  locale,\n  locales,\n  defaultLocale,\n  localeCookieName,\n  customMapping,\n  enableI18n,\n}: {\n  _locale: string;\n  locale: string;\n  locales: string[];\n  defaultLocale: string;\n  localeCookieName: string;\n  customMapping?: CustomMapping;\n  enableI18n: boolean;\n}): string {\n  if (!enableI18n) {\n    return defaultLocale;\n  }\n  // No change, return\n  if (\n    _locale &&\n    _locale === locale &&\n    determineLocale(_locale, locales, customMapping) === locale\n  ) {\n    return resolveAliasLocale(_locale, customMapping);\n  }\n\n  // Check for locale in native store\n  let storedLocale = nativeStoreGet(localeCookieName);\n  if (storedLocale) {\n    storedLocale = resolveAliasLocale(storedLocale, customMapping);\n  }\n\n  // check user's configured locales\n  let preferredLocales = getNativeLocales();\n  if (preferredLocales.length === 0) preferredLocales = [defaultLocale];\n  preferredLocales = preferredLocales.map((l) =>\n    resolveAliasLocale(l, customMapping)\n  );\n\n  // determine locale\n  let newLocale =\n    determineLocale(\n      [\n        ...(_locale ? [_locale] : []), // prefer user passed locale\n        ...(storedLocale ? [storedLocale] : []), // then prefer stored locale\n        ...preferredLocales, // then prefer browser locale\n      ],\n      locales,\n      customMapping\n    ) || defaultLocale;\n  if (newLocale) {\n    newLocale = resolveAliasLocale(newLocale, customMapping);\n  }\n\n  // if stored locale not valid, change it back to whatever we use for fallback\n  if (storedLocale && storedLocale !== newLocale) {\n    nativeStoreSet(localeCookieName, newLocale);\n  }\n\n  // return new locale\n  return newLocale;\n}\n\nfunction createSetLocale({\n  locale,\n  locales,\n  defaultLocale,\n  _setLocale,\n  localeCookieName,\n  customMapping,\n  enableI18n,\n}: {\n  locale: string;\n  locales: string[];\n  defaultLocale: string;\n  localeCookieName: string;\n  _setLocale: Dispatch<SetStateAction<string>>;\n  customMapping?: CustomMapping;\n  enableI18n: boolean;\n}): [(newLocale: string) => void, (newLocale: string) => void] {\n  locale = resolveAliasLocale(locale, customMapping);\n  // Just update the internal state, don't persist it\n  const setLocaleWithoutPersist = (newLocale: string): string => {\n    if (!enableI18n) {\n      return defaultLocale;\n    }\n    // validate locale\n    const validatedLocale = resolveAliasLocale(\n      determineLocale(newLocale, locales, customMapping) ||\n        locale ||\n        defaultLocale,\n      customMapping\n    );\n    if (validatedLocale !== newLocale) {\n      console.warn(\n        createUnsupportedLocaleWarning(validatedLocale, newLocale, PACKAGE_NAME)\n      );\n    }\n    // persist locale\n    _setLocale(validatedLocale);\n\n    return validatedLocale;\n  };\n  // update locale and persist it in native store\n  const setLocale = (newLocale: string): void => {\n    if (!enableI18n) {\n      return;\n    }\n    newLocale = resolveAliasLocale(newLocale, customMapping);\n    const validatedLocale = setLocaleWithoutPersist(newLocale);\n    nativeStoreSet(localeCookieName, validatedLocale);\n  };\n  return [setLocale, setLocaleWithoutPersist];\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,mBAAmB,EACjC,QAAQ,UAAU,IAClB,gBAAgBA,4BAAAA,sBAChB,UAAU,EAAE,EACZ,mBAAmBC,wCAAAA,yBACnB,MAAM,OACN,eACA,cACqD;AAErD,YAAA,GAAA,2BAAA,oBAA6B,SAAS,cAAc;AACpD,WAAU,QAAQ,KAAK,YAAA,GAAA,2BAAA,oBAA8B,QAAQ,cAAc,CAAC;CAE5E,MAAM,yBAAyB;AAC7B,MAAI,CAAC,WACH,QAAO;AAkBT,UAAA,GAAA,2BAAA,oBAfE,MACI,WAAA,GAAA,2BAAA,iBACkB,SAAS,SAAS,cAAc,IAAI,KACpD,KACF,aAAa;GACX;GACA,QAAQ;GACR;GACA;GACA;GACA;GACA;GACD,CAAC,EACN,cAEW;;CAIf,MAAM,CAAC,QAAQ,eAAA,GAAA,MAAA,UAA+B,kBAAkB,CAAC;CAGjE,MAAM,CAAC,WAAW,2BAA2B,gBAAgB;EAC3D;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;AAGF,EAAA,GAAA,MAAA,iBAAgB;AAUd,0BATkB,aAAa;GAC7B;GACA;GACA;GACA;GACA;GACA;GACA;GACD,CACgC,CAAC;IACjC;EACD;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;AAEF,QAAO,CAAC,QAAQ,UAAU;;;;;;;;;;AAa5B,SAAS,aAAa,EACpB,SACA,QACA,SACA,eACA,kBACA,eACA,cASS;AACT,KAAI,CAAC,WACH,QAAO;AAGT,KACE,WACA,YAAY,WAAA,GAAA,2BAAA,iBACI,SAAS,SAAS,cAAc,KAAK,OAErD,SAAA,GAAA,2BAAA,oBAA0B,SAAS,cAAc;CAInD,IAAI,eAAeC,0BAAAA,eAAe,iBAAiB;AACnD,KAAI,aACF,iBAAA,GAAA,2BAAA,oBAAkC,cAAc,cAAc;CAIhE,IAAI,mBAAmBC,+BAAAA,kBAAkB;AACzC,KAAI,iBAAiB,WAAW,EAAG,oBAAmB,CAAC,cAAc;AACrE,oBAAmB,iBAAiB,KAAK,OAAA,GAAA,2BAAA,oBACpB,GAAG,cAAc,CACrC;CAGD,IAAI,aAAA,GAAA,2BAAA,iBAEA;EACE,GAAI,UAAU,CAAC,QAAQ,GAAG,EAAE;EAC5B,GAAI,eAAe,CAAC,aAAa,GAAG,EAAE;EACtC,GAAG;EACJ,EACD,SACA,cACD,IAAI;AACP,KAAI,UACF,cAAA,GAAA,2BAAA,oBAA+B,WAAW,cAAc;AAI1D,KAAI,gBAAgB,iBAAiB,UACnC,2BAAA,eAAe,kBAAkB,UAAU;AAI7C,QAAO;;AAGT,SAAS,gBAAgB,EACvB,QACA,SACA,eACA,YACA,kBACA,eACA,cAS6D;AAC7D,WAAA,GAAA,2BAAA,oBAA4B,QAAQ,cAAc;CAElD,MAAM,2BAA2B,cAA8B;AAC7D,MAAI,CAAC,WACH,QAAO;EAGT,MAAM,mBAAA,GAAA,2BAAA,qBAAA,GAAA,2BAAA,iBACY,WAAW,SAAS,cAAc,IAChD,UACA,eACF,cACD;AACD,MAAI,oBAAoB,UACtB,SAAQ,MAAA,GAAA,sCAAA,gCACyB,iBAAiB,WAAWC,6BAAAA,aAAa,CACzE;AAGH,aAAW,gBAAgB;AAE3B,SAAO;;CAGT,MAAM,aAAa,cAA4B;AAC7C,MAAI,CAAC,WACH;AAEF,eAAA,GAAA,2BAAA,oBAA+B,WAAW,cAAc;AAExD,4BAAA,eAAe,kBADS,wBAAwB,UACA,CAAC;;AAEnD,QAAO,CAAC,WAAW,wBAAwB"}