@symbiote-native/localization 0.0.1

package/build/core/types.js

@@ -0,0 +1,59 @@
+// Hand-ported verbatim from .vendors/expo/packages/expo-localization/src/Localization.types.ts
+// (sdk-57) — plain data shapes, no expo-modules-core dependency at all. Every JSDoc comment is
+// kept as-is: they document real, per-platform behavior differences, not restated obviousness.
+/**
+ * An enum mapping days of the week in Gregorian calendar to their index as returned by the `firstWeekday` property.
+ */
+export var Weekday;
+(function (Weekday) {
+    Weekday[Weekday["SUNDAY"] = 1] = "SUNDAY";
+    Weekday[Weekday["MONDAY"] = 2] = "MONDAY";
+    Weekday[Weekday["TUESDAY"] = 3] = "TUESDAY";
+    Weekday[Weekday["WEDNESDAY"] = 4] = "WEDNESDAY";
+    Weekday[Weekday["THURSDAY"] = 5] = "THURSDAY";
+    Weekday[Weekday["FRIDAY"] = 6] = "FRIDAY";
+    Weekday[Weekday["SATURDAY"] = 7] = "SATURDAY";
+})(Weekday || (Weekday = {}));
+/**
+ * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).
+ */
+export var CalendarIdentifier;
+(function (CalendarIdentifier) {
+    /** Thai Buddhist calendar */
+    CalendarIdentifier["BUDDHIST"] = "buddhist";
+    /** Traditional Chinese calendar */
+    CalendarIdentifier["CHINESE"] = "chinese";
+    /** Coptic calendar */
+    CalendarIdentifier["COPTIC"] = "coptic";
+    /** Traditional Korean calendar */
+    CalendarIdentifier["DANGI"] = "dangi";
+    /** Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E) */
+    CalendarIdentifier["ETHIOAA"] = "ethioaa";
+    /** Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.) */
+    CalendarIdentifier["ETHIOPIC"] = "ethiopic";
+    /** Gregorian calendar (also referred to upstream as "gregorian" — dropped as a separate
+     * member here since this repo's lint bans duplicate enum values). */
+    CalendarIdentifier["GREGORY"] = "gregory";
+    /** Traditional Hebrew calendar */
+    CalendarIdentifier["HEBREW"] = "hebrew";
+    /** Indian calendar */
+    CalendarIdentifier["INDIAN"] = "indian";
+    /** Islamic calendar */
+    CalendarIdentifier["ISLAMIC"] = "islamic";
+    /** Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - civil epoch) */
+    CalendarIdentifier["ISLAMIC_CIVIL"] = "islamic-civil";
+    /** Islamic calendar, Saudi Arabia sighting */
+    CalendarIdentifier["ISLAMIC_RGSA"] = "islamic-rgsa";
+    /**Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - astronomical epoch) */
+    CalendarIdentifier["ISLAMIC_TBLA"] = "islamic-tbla";
+    /** Islamic calendar, Umm al-Qura */
+    CalendarIdentifier["ISLAMIC_UMALQURA"] = "islamic-umalqura";
+    /** ISO calendar (Gregorian calendar using the ISO 8601 calendar week rules) */
+    CalendarIdentifier["ISO8601"] = "iso8601";
+    /** Japanese imperial calendar */
+    CalendarIdentifier["JAPANESE"] = "japanese";
+    /** Persian calendar */
+    CalendarIdentifier["PERSIAN"] = "persian";
+    /** Civil (algorithmic) Arabic calendar */
+    CalendarIdentifier["ROC"] = "roc";
+})(CalendarIdentifier || (CalendarIdentifier = {}));

package/build/react/hooks/use-calendars/index.d.ts

@@ -0,0 +1,2 @@
+import { type Calendar } from '../../../core';
+export declare function useCalendars(): Calendar[];

package/build/react/hooks/use-calendars/index.js

@@ -0,0 +1,13 @@
+// React lifecycle wiring over the framework-agnostic core — mirrors use-locales' shape exactly.
+// Ported from expo-localization's own useCalendars hook (sdk-57).
+import { useEffect, useMemo, useReducer } from 'react';
+import { addCalendarListener, getCalendars } from '../../../core';
+export function useCalendars() {
+    const [invalidationKey, invalidate] = useReducer((key) => key + 1, 0);
+    const calendars = useMemo(() => getCalendars(), [invalidationKey]);
+    useEffect(() => {
+        const subscription = addCalendarListener(invalidate);
+        return () => subscription.remove();
+    }, []);
+    return calendars;
+}

package/build/react/hooks/use-locales/index.d.ts

@@ -0,0 +1,2 @@
+import { type Locale } from '../../../core';
+export declare function useLocales(): Locale[];

package/build/react/hooks/use-locales/index.js

@@ -0,0 +1,15 @@
+// React lifecycle wiring over the framework-agnostic core (core/localization.ts /
+// core/native-module.ts). Ported from expo-localization's own useLocales hook (sdk-57): a
+// useReducer-driven invalidation counter that useMemo recomputes getLocales() from, whenever the
+// native module fires onLocaleSettingsChanged.
+import { useEffect, useMemo, useReducer } from 'react';
+import { addLocaleListener, getLocales } from '../../../core';
+export function useLocales() {
+    const [invalidationKey, invalidate] = useReducer((key) => key + 1, 0);
+    const locales = useMemo(() => getLocales(), [invalidationKey]);
+    useEffect(() => {
+        const subscription = addLocaleListener(invalidate);
+        return () => subscription.remove();
+    }, []);
+    return locales;
+}

package/build/react/index.d.ts

@@ -0,0 +1,3 @@
+export { useLocales } from './hooks/use-locales';
+export { useCalendars } from './hooks/use-calendars';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, type Locale, type Calendar, type EventSubscription, } from '../core';

package/build/react/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/localization/react: the React entry over the framework-agnostic core. Locales
+// and calendars each get their own lifecycle hook, matching upstream's own useLocales/
+// useCalendars being two separate hooks, not one combined hook — mirrors the lifecycle-bucket
+// naming convention of adapters/react/src/hooks (never `composables`, that's Vue's term).
+export { useLocales } from './hooks/use-locales';
+export { useCalendars } from './hooks/use-calendars';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, } from '../core';

package/build/vue/composables/use-calendars/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type Calendar } from '../../../core';
+export declare function useCalendars(): Ref<Calendar[]>;

package/build/vue/composables/use-calendars/index.js

@@ -0,0 +1,16 @@
+// Vue lifecycle wiring over the framework-agnostic core — mirrors use-locales' shape exactly.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { addCalendarListener, getCalendars, } from '../../../core';
+export function useCalendars() {
+    const calendars = ref(getCalendars());
+    let subscription;
+    onMounted(() => {
+        subscription = addCalendarListener(() => {
+            calendars.value = getCalendars();
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return calendars;
+}

package/build/vue/composables/use-locales/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type Locale } from '../../../core';
+export declare function useLocales(): Ref<Locale[]>;

package/build/vue/composables/use-locales/index.js

@@ -0,0 +1,20 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/localization.ts). Unlike
+// packages/network's use-network-state (which seeds a placeholder and fetches asynchronously in
+// onMounted), getLocales() is a synchronous native call, so the ref is computed once, directly at
+// setup — onMounted only wires the change listener, mirroring use-network-state's
+// onMounted/onUnmounted subscription shape otherwise.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { addLocaleListener, getLocales } from '../../../core';
+export function useLocales() {
+    const locales = ref(getLocales());
+    let subscription;
+    onMounted(() => {
+        subscription = addLocaleListener(() => {
+            locales.value = getLocales();
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return locales;
+}

package/build/vue/index.d.ts

@@ -0,0 +1,3 @@
+export { useLocales } from './composables/use-locales';
+export { useCalendars } from './composables/use-calendars';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, type Locale, type Calendar, type EventSubscription, } from '../core';

package/build/vue/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/localization/vue: the Vue entry over the framework-agnostic core. Locales and
+// calendars each get their own lifecycle composable, matching upstream's own useLocales/
+// useCalendars being two separate hooks, not one combined hook — mirrors the lifecycle-bucket
+// naming convention of adapters/vue/src/composables (never `hooks`, that's React's term).
+export { useLocales } from './composables/use-locales';
+export { useCalendars } from './composables/use-calendars';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, } from '../core';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,3 @@
+export { LocalesService } from './services/locales.service';
+export { CalendarsService } from './services/calendars.service';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, type Locale, type Calendar, type EventSubscription, } from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,8 @@
+// LocalesService/CalendarsService are the Angular-only lifecycle half; the free functions and
+// event subscription plumbing all live in core, shared with React/Vue. Two separate services
+// (not one combined service), matching upstream's own useLocales/useCalendars being two separate
+// hooks.
+export { LocalesService } from './services/locales.service';
+export { CalendarsService } from './services/calendars.service';
+export { getLocales, getCalendars, addLocaleListener, addCalendarListener, Weekday, CalendarIdentifier, } from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,6FAA6F;AAC7F,iGAAiG;AACjG,SAAS;AACT,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EACL,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,OAAO,EACP,kBAAkB,GAInB,MAAM,SAAS,CAAC"}

package/build-ngc/angular/services/calendars.service/index.d.ts

@@ -0,0 +1,9 @@
+import { type Signal } from '@angular/core';
+import { type Calendar } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class CalendarsService {
+    private readonly injector;
+    connect(): Signal<Calendar[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarsService>;
+}

package/build-ngc/angular/services/calendars.service/index.js

@@ -0,0 +1,27 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addCalendarListener, getCalendars } from '../../../core';
+import * as i0 from "@angular/core";
+// Angular twin of React's `useCalendars` hook and Vue's `useCalendars` composable — mirrors
+// LocalesService's shape exactly.
+//
+//   readonly calendars = inject(CalendarsService).connect();
+//   // template: {{ calendars() }}
+export class CalendarsService {
+    injector = inject(Injector);
+    connect() {
+        const calendars = signal(getCalendars(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "calendars" }] : /* istanbul ignore next */ []));
+        effect(onCleanup => {
+            const subscription = addCalendarListener(() => calendars.set(getCalendars()));
+            onCleanup(() => subscription.remove());
+        }, { injector: this.injector });
+        return calendars.asReadonly();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: CalendarsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: CalendarsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: CalendarsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/services/calendars.service/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/calendars.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;;AAEjF,4FAA4F;AAC5F,kCAAkC;AAClC,EAAE;AACF,6DAA6D;AAC7D,mCAAmC;AAEnC,MAAM,OAAO,gBAAgB;IACV,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,SAAS,GAAG,MAAM,CAAa,YAAY,EAAE;sFAAC,CAAC;QAErD,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,MAAM,YAAY,GAAG,mBAAmB,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;YAC9E,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,SAAS,CAAC,UAAU,EAAE,CAAC;IAChC,CAAC;uGAfU,gBAAgB;2GAAhB,gBAAgB,cADH,MAAM;;2FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/angular/services/locales.service/index.d.ts

@@ -0,0 +1,9 @@
+import { type Signal } from '@angular/core';
+import { type Locale } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class LocalesService {
+    private readonly injector;
+    connect(): Signal<Locale[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalesService>;
+}

package/build-ngc/angular/services/locales.service/index.js

@@ -0,0 +1,28 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addLocaleListener, getLocales } from '../../../core';
+import * as i0 from "@angular/core";
+// Angular twin of React's `useLocales` hook and Vue's `useLocales` composable. See
+// packages/battery's BatteryStateService for the `connect()` pattern rationale. getLocales() is
+// synchronous, so the signal seeds from it directly rather than an async `.then()` fetch.
+//
+//   readonly locales = inject(LocalesService).connect();
+//   // template: {{ locales() }}
+export class LocalesService {
+    injector = inject(Injector);
+    connect() {
+        const locales = signal(getLocales(), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "locales" }] : /* istanbul ignore next */ []));
+        effect(onCleanup => {
+            const subscription = addLocaleListener(() => locales.set(getLocales()));
+            onCleanup(() => subscription.remove());
+        }, { injector: this.injector });
+        return locales.asReadonly();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: LocalesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: LocalesService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: LocalesService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/services/locales.service/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/locales.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;;AAE3E,mFAAmF;AACnF,gGAAgG;AAChG,0FAA0F;AAC1F,EAAE;AACF,yDAAyD;AACzD,iCAAiC;AAEjC,MAAM,OAAO,cAAc;IACR,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,OAAO,GAAG,MAAM,CAAW,UAAU,EAAE;oFAAC,CAAC;QAE/C,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,MAAM,YAAY,GAAG,iBAAiB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;YACxE,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,OAAO,CAAC,UAAU,EAAE,CAAC;IAC9B,CAAC;uGAfU,cAAc;2GAAd,cAAc,cADD,MAAM;;2FACnB,cAAc;kBAD1B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,4 @@
+export { getLocales, getCalendars } from './localization';
+export { addLocaleListener, addCalendarListener } from './native-module';
+export { Weekday, CalendarIdentifier, type Locale, type Calendar } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build-ngc/core/index.js

@@ -0,0 +1,4 @@
+export { getLocales, getCalendars } from './localization';
+export { addLocaleListener, addCalendarListener } from './native-module';
+export { Weekday, CalendarIdentifier } from './types';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAA8B,MAAM,SAAS,CAAC"}

package/build-ngc/core/localization.d.ts

@@ -0,0 +1,39 @@
+import type { Calendar, Locale } from './types';
+/**
+ * List of user's locales, returned as an array of objects of type `Locale`.
+ * Guaranteed to contain at least 1 element.
+ * These are returned in the order the user defines in their device settings.
+ * On the web currency and measurements systems are not provided, instead returned as null.
+ * If needed, you can infer them from the current region using a lookup table.
+ * @example
+ * ```js
+ * [{
+ *   "languageTag": "pl-PL",
+ *   "languageCode": "pl",
+ *   "textDirection": "ltr",
+ *   "digitGroupingSeparator": " ",
+ *   "decimalSeparator": ",",
+ *   "measurementSystem": "metric",
+ *   "currencyCode": "PLN",
+ *   "currencySymbol": "zł",
+ *   "regionCode": "PL",
+ *   "temperatureUnit": "celsius"
+ * }]
+ * ```
+ */
+export declare const getLocales: () => Locale[];
+/**
+ * List of user's preferred calendars, returned as an array of objects of type `Calendar`.
+ * Guaranteed to contain at least 1 element.
+ * For now always returns a single element, but it's likely to return a user preference list on some platforms in the future.
+ * @example
+ * ```js
+ * [{
+ *   "calendar": "gregory",
+ *   "timeZone": "Europe/Warsaw",
+ *   "uses24hourClock": true,
+ *   "firstWeekday": 1
+ * }]
+ * ```
+ */
+export declare const getCalendars: () => Calendar[];

package/build-ngc/core/localization.js

@@ -0,0 +1,43 @@
+// Hand-ported from .vendors/expo/packages/expo-localization/src/Localization.ts (sdk-57) —
+// both functions delegate straight to the native module, no extra wrapping needed beyond typing
+// them as synchronous getters.
+import ExpoLocalizationModule from './native-module';
+/**
+ * List of user's locales, returned as an array of objects of type `Locale`.
+ * Guaranteed to contain at least 1 element.
+ * These are returned in the order the user defines in their device settings.
+ * On the web currency and measurements systems are not provided, instead returned as null.
+ * If needed, you can infer them from the current region using a lookup table.
+ * @example
+ * ```js
+ * [{
+ *   "languageTag": "pl-PL",
+ *   "languageCode": "pl",
+ *   "textDirection": "ltr",
+ *   "digitGroupingSeparator": " ",
+ *   "decimalSeparator": ",",
+ *   "measurementSystem": "metric",
+ *   "currencyCode": "PLN",
+ *   "currencySymbol": "zł",
+ *   "regionCode": "PL",
+ *   "temperatureUnit": "celsius"
+ * }]
+ * ```
+ */
+export const getLocales = ExpoLocalizationModule.getLocales;
+/**
+ * List of user's preferred calendars, returned as an array of objects of type `Calendar`.
+ * Guaranteed to contain at least 1 element.
+ * For now always returns a single element, but it's likely to return a user preference list on some platforms in the future.
+ * @example
+ * ```js
+ * [{
+ *   "calendar": "gregory",
+ *   "timeZone": "Europe/Warsaw",
+ *   "uses24hourClock": true,
+ *   "firstWeekday": 1
+ * }]
+ * ```
+ */
+export const getCalendars = ExpoLocalizationModule.getCalendars;
+//# sourceMappingURL=localization.js.map

package/build-ngc/core/localization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"localization.js","sourceRoot":"","sources":["../../src/core/localization.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,gGAAgG;AAChG,+BAA+B;AAC/B,OAAO,sBAAsB,MAAM,iBAAiB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAmB,sBAAsB,CAAC,UAAU,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAqB,sBAAsB,CAAC,YAAY,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,12 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { Calendar, Locale } from './types';
+export type INativeLocalizationModule = {
+    getLocales(): Locale[];
+    getCalendars(): Calendar[];
+    addListener(eventName: 'onLocaleSettingsChanged', listener: (event?: unknown) => void): EventSubscription;
+    addListener(eventName: 'onCalendarSettingsChanged', listener: (event?: unknown) => void): EventSubscription;
+};
+declare const ExpoLocalizationModule: INativeLocalizationModule;
+export declare function addLocaleListener(listener: (event?: unknown) => void): EventSubscription;
+export declare function addCalendarListener(listener: (event?: unknown) => void): EventSubscription;
+export default ExpoLocalizationModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,22 @@
+// Hand-ported from .vendors/expo/packages/expo-localization/src/ExpoLocalization.native.ts
+// (sdk-57). getLocales()/getCalendars() are synchronous, JSI-bridged native calls (no await) —
+// the native module itself implements them as sync-bridged functions, the same constants-style
+// read pattern this repo already uses for expo-device's eagerly-resolved fields
+// (packages/device/src/core/native-module.ts). One native module fans out two independent event
+// streams (locale settings vs calendar settings) through the same addListener, keyed by event
+// name — mirrors the three-event-names-on-one-addListener overload trick in
+// packages/battery/src/core/native-module.ts.
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_LOCALIZATION_MODULE_NAME = 'ExpoLocalization';
+const ExpoLocalizationModule = requireNativeModule(EXPO_LOCALIZATION_MODULE_NAME);
+export function addLocaleListener(
+// NOTE: upstream never uses the event's data — the listener is invoked purely as an
+// invalidate signal for useLocales/the Vue composable/the Angular service below.
+listener) {
+    return ExpoLocalizationModule.addListener('onLocaleSettingsChanged', listener);
+}
+export function addCalendarListener(listener) {
+    return ExpoLocalizationModule.addListener('onCalendarSettingsChanged', listener);
+}
+export default ExpoLocalizationModule;
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,+FAA+F;AAC/F,+FAA+F;AAC/F,gFAAgF;AAChF,gGAAgG;AAChG,8FAA8F;AAC9F,4EAA4E;AAC5E,8CAA8C;AAC9C,OAAO,EAA0B,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGhF,MAAM,6BAA6B,GAAG,kBAAkB,CAAC;AAezD,MAAM,sBAAsB,GAAG,mBAAmB,CAChD,6BAA6B,CAC9B,CAAC;AAEF,MAAM,UAAU,iBAAiB;AAC/B,oFAAoF;AACpF,iFAAiF;AACjF,QAAmC;IAEnC,OAAO,sBAAsB,CAAC,WAAW,CAAC,yBAAyB,EAAE,QAAQ,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,QAAmC;IACrE,OAAO,sBAAsB,CAAC,WAAW,CAAC,2BAA2B,EAAE,QAAQ,CAAC,CAAC;AACnF,CAAC;AAED,eAAe,sBAAsB,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,174 @@
+export type Locale = {
+    /**
+     * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) with a region code.
+     * @example
+     * `'en-US'`, `'es-419'`, `'pl-PL'`.
+     */
+    languageTag: string;
+    /**
+     * An [IETF BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) without the region code.
+     * @example
+     * `'en'`, `'es'`, `'pl'`.
+     */
+    languageCode: string | null;
+    /**
+     * An [ISO 15924](https://en.wikipedia.org/wiki/ISO_15924) 4-letter script code. On Android and Web, it may be `null` if none is defined.
+     * @example
+     * `'Latn'`, `'Hans'`, `'Hebr'`.
+     */
+    languageScriptCode: string | null;
+    /**
+     * 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).
+     * @example
+     * `'US'`.
+     */
+    regionCode: string | null;
+    /**
+     * The region code for the preferred language. When the language is not region-specific, it returns the same value as `regionCode`. When the language is region-specific, it returns the region code for the language (`en-CA` -> `CA`).
+     * Prefer using `regionCode` for any internalization purposes.
+     * @example
+     * `'US'`.
+     */
+    languageRegionCode: string | null;
+    /**
+     * Currency code for the locale.
+     * On iOS, it's the currency code from the `Region` setting under Language & Region, not for the current locale.
+     * On Android, it's the currency specifc to the locale in the list, as there are no separate settings for selecting a region.
+     * Is `null` on Web, use a table lookup based on region instead.
+     * @example
+     * `'USD'`, `'EUR'`, `'PLN'`.
+     */
+    currencyCode: string | null;
+    /**
+     * Currency symbol for the currency specified by `currencyCode`.
+     * @example
+     * `'$'`, `'€'`, `'zł'`.
+     */
+    currencySymbol: string | null;
+    /**
+     * Currency code for the locale.
+     * On iOS, it's the currency code for the current locale in the list, not the device region.
+     * On Android, it's equal to `currencyCode`.
+     * Is `null` on Web.
+     * Prefer using `currencyCode` for any internalization purposes.
+     * @example
+     * `'USD'`, `'EUR'`, `'PLN'`.
+     */
+    languageCurrencyCode: string | null;
+    /**
+     * Currency symbol for the currency specified by `languageCurrencyCode`.
+     * Prefer using `currencySymbol` for any internalization purposes.
+     * @example
+     * `'$'`, `'€'`, `'zł'`.
+     */
+    languageCurrencySymbol: string | null;
+    /**
+     * Decimal separator used for formatting numbers with fractional parts.
+     * @example
+     * `'.'`, `','`.
+     */
+    decimalSeparator: string | null;
+    /**
+     * Digit grouping separator used for formatting large numbers.
+     * @example
+     * `'.'`, `','`.
+     */
+    digitGroupingSeparator: string | null;
+    /**
+     * Text direction for the locale. One of: `'ltr'`, `'rtl'`.
+     */
+    textDirection: 'ltr' | 'rtl';
+    /**
+     * The measurement system used in the locale.
+     * Is `null` on Web, as user chosen measurement system is not exposed on the web and using locale to determine measurement systems is unreliable.
+     * Ask for user preferences if possible.
+     */
+    measurementSystem: `metric` | `us` | `uk` | null;
+    /**
+     * The temperature unit used in the locale.
+     * Returns `null` if the region code is unknown.
+     */
+    temperatureUnit: 'celsius' | 'fahrenheit' | null;
+};
+/**
+ * An enum mapping days of the week in Gregorian calendar to their index as returned by the `firstWeekday` property.
+ */
+export declare enum Weekday {
+    SUNDAY = 1,
+    MONDAY = 2,
+    TUESDAY = 3,
+    WEDNESDAY = 4,
+    THURSDAY = 5,
+    FRIDAY = 6,
+    SATURDAY = 7
+}
+/**
+ * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).
+ */
+export declare enum CalendarIdentifier {
+    /** Thai Buddhist calendar */
+    BUDDHIST = "buddhist",
+    /** Traditional Chinese calendar */
+    CHINESE = "chinese",
+    /** Coptic calendar */
+    COPTIC = "coptic",
+    /** Traditional Korean calendar */
+    DANGI = "dangi",
+    /** Ethiopic calendar, Amete Alem (epoch approx. 5493 B.C.E) */
+    ETHIOAA = "ethioaa",
+    /** Ethiopic calendar, Amete Mihret (epoch approx, 8 C.E.) */
+    ETHIOPIC = "ethiopic",
+    /** Gregorian calendar (also referred to upstream as "gregorian" — dropped as a separate
+     * member here since this repo's lint bans duplicate enum values). */
+    GREGORY = "gregory",
+    /** Traditional Hebrew calendar */
+    HEBREW = "hebrew",
+    /** Indian calendar */
+    INDIAN = "indian",
+    /** Islamic calendar */
+    ISLAMIC = "islamic",
+    /** Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - civil epoch) */
+    ISLAMIC_CIVIL = "islamic-civil",
+    /** Islamic calendar, Saudi Arabia sighting */
+    ISLAMIC_RGSA = "islamic-rgsa",
+    /**Islamic calendar, tabular (intercalary years [2,5,7,10,13,16,18,21,24,26,29] - astronomical epoch) */
+    ISLAMIC_TBLA = "islamic-tbla",
+    /** Islamic calendar, Umm al-Qura */
+    ISLAMIC_UMALQURA = "islamic-umalqura",
+    /** ISO calendar (Gregorian calendar using the ISO 8601 calendar week rules) */
+    ISO8601 = "iso8601",
+    /** Japanese imperial calendar */
+    JAPANESE = "japanese",
+    /** Persian calendar */
+    PERSIAN = "persian",
+    /** Civil (algorithmic) Arabic calendar */
+    ROC = "roc"
+}
+export type Calendar = {
+    /**
+     * The calendar identifier, one of [Unicode calendar types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar).
+     *
+     * On Android is limited to one of device's [available calendar types](https://developer.android.com/reference/java/util/Calendar#getAvailableCalendarTypes()).
+     *
+     * 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.
+     */
+    calendar: CalendarIdentifier | null;
+    /**
+     * True when current device settings use 24-hour time format.
+     * 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.
+     */
+    uses24hourClock: boolean | null;
+    /**
+     * The first day of the week. For most calendars Sunday is numbered `1`, with Saturday being number `7`.
+     * 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.
+     * @example
+     * `1`, `7`.
+     */
+    firstWeekday: Weekday | null;
+    /**
+     * Time zone for the calendar. Can be `null` on Web.
+     * @example
+     * `'America/Los_Angeles'`, `'Europe/Warsaw'`, `'GMT+1'`.
+     */
+    timeZone: string | null;
+};