@symbiote-native/localization 0.0.1

package/build-ngc/core/types.js

@@ -0,0 +1,60 @@
+// 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 = {}));
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,+FAA+F;AAC/F,+FAA+F;AA+F/F;;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;;GAEG;AACH,MAAM,CAAN,IAAY,kBAsCX;AAtCD,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;yEACqE;IACrE,yCAAmB,CAAA;IACnB,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,EAtCW,kBAAkB,KAAlB,kBAAkB,QAsC7B"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-localization",
+    "modules": [
+      {
+        "importPath": "expo.modules.localization.LocalizationModule",
+        "className": "LocalizationModule",
+        "nativeName": "ExpoLocalization"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/localization",
+  "version": "0.0.1",
+  "description": "expo-localization wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Two independent synchronous getters (getLocales, getCalendars), each with its own native change listener and its own reactive hook per adapter.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/localization"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/localization#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-localization": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/engine": "0.1.7"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,17 @@
+// 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,
+  type Locale,
+  type Calendar,
+  type EventSubscription,
+} from '../core';

package/src/angular/services/calendars.service/calendars.service.test.ts

@@ -0,0 +1,102 @@
+// Co-located Angular-driven test (ADR 0025) for CalendarsService. See locales.service.test.ts for
+// the shared rationale.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import { CalendarIdentifier, Weekday, type Calendar } from '../../../core/types';
+import { CalendarsService } from './index';
+
+const FAKE_CALENDARS_INITIAL: Calendar[] = [
+  {
+    calendar: CalendarIdentifier.GREGORY,
+    uses24hourClock: true,
+    firstWeekday: Weekday.SUNDAY,
+    timeZone: 'Europe/Warsaw',
+  },
+];
+
+const FAKE_CALENDARS_UPDATED: Calendar[] = [
+  {
+    calendar: CalendarIdentifier.ISO8601,
+    uses24hourClock: false,
+    firstWeekday: Weekday.MONDAY,
+    timeZone: 'America/New_York',
+  },
+];
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const getCalendarsMock = vi.fn(() => FAKE_CALENDARS_INITIAL);
+
+vi.mock('../../../core', () => ({
+  addCalendarListener: (listener: () => void) => addListenerMock(listener),
+  getCalendars: () => getCalendarsMock(),
+}));
+
+const ROOT_TAG = 975;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+let capturedResult: Signal<Calendar[]> | undefined;
+let capturedListener: (() => void) | undefined;
+
+@Component({
+  selector: 'symbiote-calendars-host',
+  standalone: true,
+  template: '',
+})
+class CalendarsHost {
+  readonly calendars = inject(CalendarsService).connect();
+
+  constructor() {
+    capturedResult = this.calendars;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  getCalendarsMock.mockReturnValue(FAKE_CALENDARS_INITIAL);
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('CalendarsService.connect', () => {
+  it('reads the current calendars synchronously', () => {
+    mount(ROOT_TAG, CalendarsHost);
+
+    expect(capturedResult?.()).toEqual(FAKE_CALENDARS_INITIAL);
+  });
+
+  it('recomputes the signal when the registered listener fires', async () => {
+    mount(ROOT_TAG, CalendarsHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    getCalendarsMock.mockReturnValue(FAKE_CALENDARS_UPDATED);
+    capturedListener();
+
+    expect(capturedResult?.()).toEqual(FAKE_CALENDARS_UPDATED);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, CalendarsHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+});

package/src/angular/services/calendars.service/index.ts

@@ -0,0 +1,26 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addCalendarListener, getCalendars, type Calendar } from '../../../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() }}
+@Injectable({ providedIn: 'root' })
+export class CalendarsService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<Calendar[]> {
+    const calendars = signal<Calendar[]>(getCalendars());
+
+    effect(
+      onCleanup => {
+        const subscription = addCalendarListener(() => calendars.set(getCalendars()));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return calendars.asReadonly();
+  }
+}

package/src/angular/services/locales.service/index.ts

@@ -0,0 +1,27 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addLocaleListener, getLocales, type Locale } from '../../../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() }}
+@Injectable({ providedIn: 'root' })
+export class LocalesService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<Locale[]> {
+    const locales = signal<Locale[]>(getLocales());
+
+    effect(
+      onCleanup => {
+        const subscription = addLocaleListener(() => locales.set(getLocales()));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return locales.asReadonly();
+  }
+}

package/src/angular/services/locales.service/locales.service.test.ts

@@ -0,0 +1,122 @@
+// Co-located Angular-driven test (ADR 0025) for LocalesService. See packages/battery's
+// battery-state.service.test.ts for the shared rationale.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import type { Locale } from '../../../core';
+import { LocalesService } from './index';
+
+const FAKE_LOCALES_INITIAL: Locale[] = [
+  {
+    languageTag: 'pl-PL',
+    languageCode: 'pl',
+    languageScriptCode: 'Latn',
+    regionCode: 'PL',
+    languageRegionCode: 'PL',
+    currencyCode: 'PLN',
+    currencySymbol: 'zł',
+    languageCurrencyCode: 'PLN',
+    languageCurrencySymbol: 'zł',
+    decimalSeparator: ',',
+    digitGroupingSeparator: ' ',
+    textDirection: 'ltr',
+    measurementSystem: 'metric',
+    temperatureUnit: 'celsius',
+  },
+];
+
+const FAKE_LOCALES_UPDATED: Locale[] = [
+  {
+    languageTag: 'en-US',
+    languageCode: 'en',
+    languageScriptCode: 'Latn',
+    regionCode: 'US',
+    languageRegionCode: 'US',
+    currencyCode: 'USD',
+    currencySymbol: '$',
+    languageCurrencyCode: 'USD',
+    languageCurrencySymbol: '$',
+    decimalSeparator: '.',
+    digitGroupingSeparator: ',',
+    textDirection: 'ltr',
+    measurementSystem: 'us',
+    temperatureUnit: 'fahrenheit',
+  },
+];
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const getLocalesMock = vi.fn(() => FAKE_LOCALES_INITIAL);
+
+vi.mock('../../../core', () => ({
+  addLocaleListener: (listener: () => void) => addListenerMock(listener),
+  getLocales: () => getLocalesMock(),
+}));
+
+const ROOT_TAG = 974;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+let capturedResult: Signal<Locale[]> | undefined;
+let capturedListener: (() => void) | undefined;
+
+@Component({
+  selector: 'symbiote-locales-host',
+  standalone: true,
+  template: '',
+})
+class LocalesHost {
+  readonly locales = inject(LocalesService).connect();
+
+  constructor() {
+    capturedResult = this.locales;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  getLocalesMock.mockReturnValue(FAKE_LOCALES_INITIAL);
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('LocalesService.connect', () => {
+  it('reads the current locales synchronously', () => {
+    mount(ROOT_TAG, LocalesHost);
+
+    expect(capturedResult?.()).toEqual(FAKE_LOCALES_INITIAL);
+  });
+
+  it('recomputes the signal when the registered listener fires', async () => {
+    mount(ROOT_TAG, LocalesHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    getLocalesMock.mockReturnValue(FAKE_LOCALES_UPDATED);
+    capturedListener();
+
+    expect(capturedResult?.()).toEqual(FAKE_LOCALES_UPDATED);
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, LocalesHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+});

package/src/core/index.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/src/core/localization.test.ts

@@ -0,0 +1,64 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { CalendarIdentifier, Weekday, type Calendar, type Locale } from './types';
+
+const FAKE_LOCALES: Locale[] = [
+  {
+    languageTag: 'pl-PL',
+    languageCode: 'pl',
+    languageScriptCode: 'Latn',
+    regionCode: 'PL',
+    languageRegionCode: 'PL',
+    currencyCode: 'PLN',
+    currencySymbol: 'zł',
+    languageCurrencyCode: 'PLN',
+    languageCurrencySymbol: 'zł',
+    decimalSeparator: ',',
+    digitGroupingSeparator: ' ',
+    textDirection: 'ltr',
+    measurementSystem: 'metric',
+    temperatureUnit: 'celsius',
+  },
+];
+
+const FAKE_CALENDARS: Calendar[] = [
+  {
+    calendar: CalendarIdentifier.GREGORY,
+    uses24hourClock: true,
+    firstWeekday: Weekday.MONDAY,
+    timeZone: 'Europe/Warsaw',
+  },
+];
+
+const getLocalesMock = vi.fn(() => FAKE_LOCALES);
+const getCalendarsMock = vi.fn(() => FAKE_CALENDARS);
+
+// The real ExpoLocalization native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, the same
+// pattern packages/battery/src/core/battery.test.ts uses.
+vi.mock('./native-module', () => ({
+  default: {
+    getLocales: getLocalesMock,
+    getCalendars: getCalendarsMock,
+  },
+}));
+
+const { getLocales, getCalendars } = await import('./localization');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('getLocales', () => {
+  it('delegates to the native module', () => {
+    expect(getLocales()).toEqual(FAKE_LOCALES);
+    expect(getLocalesMock).toHaveBeenCalledOnce();
+  });
+});
+
+describe('getCalendars', () => {
+  it('delegates to the native module', () => {
+    expect(getCalendars()).toEqual(FAKE_CALENDARS);
+    expect(getCalendarsMock).toHaveBeenCalledOnce();
+  });
+});

package/src/core/localization.ts

@@ -0,0 +1,45 @@
+// 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';
+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 const getLocales: () => Locale[] = 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: () => Calendar[] = ExpoLocalizationModule.getCalendars;

package/src/core/native-module.ts

@@ -0,0 +1,43 @@
+// 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 { type EventSubscription, requireNativeModule } from 'expo-modules-core';
+import type { Calendar, Locale } from './types';
+
+const EXPO_LOCALIZATION_MODULE_NAME = 'ExpoLocalization';
+
+export type INativeLocalizationModule = {
+  getLocales(): Locale[];
+  getCalendars(): Calendar[];
+  addListener(
+    eventName: 'onLocaleSettingsChanged',
+    listener: (event?: unknown) => void,
+  ): EventSubscription;
+  addListener(
+    eventName: 'onCalendarSettingsChanged',
+    listener: (event?: unknown) => void,
+  ): EventSubscription;
+};
+
+const ExpoLocalizationModule = requireNativeModule<INativeLocalizationModule>(
+  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: (event?: unknown) => void,
+): EventSubscription {
+  return ExpoLocalizationModule.addListener('onLocaleSettingsChanged', listener);
+}
+
+export function addCalendarListener(listener: (event?: unknown) => void): EventSubscription {
+  return ExpoLocalizationModule.addListener('onCalendarSettingsChanged', listener);
+}
+
+export default ExpoLocalizationModule;