@jobber/components-native 0.110.0 → 0.111.1-fixselect-35e5f17.5

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jobber/components-native",
-    "version": "0.110.0",
+    "version": "0.111.1-fixselect-35e5f17.5+35e5f17e",
     "license": "MIT",
     "description": "React Native implementation of Atlantis",
     "repository": {
@@ -74,7 +74,7 @@
         "@babel/runtime": "^7.29.2",
         "@gorhom/bottom-sheet": "^5.2.8",
         "@jobber/design": "0.109.0",
-        "@jobber/hooks": "2.21.0",
+        "@jobber/hooks": "2.21.1-fixselect-35e5f17.128+35e5f17e",
         "@react-native-community/datetimepicker": "^8.4.5",
         "@react-native/babel-preset": "^0.82.1",
         "@storybook/addon-a11y": "10.3.5",
@@ -124,5 +124,5 @@
         "react-native-screens": ">=4.18.0",
         "react-native-svg": ">=12.0.0"
     },
-    "gitHead": "c81a2b04748119a1bd84cc39f4f5e7a97c410afb"
+    "gitHead": "35e5f17e1a76af9c70f7d38a65caf0be8b47cd6a"
 }

package/dist/src/hooks/useAtlantisI18n/releasedLanguages.js

@@ -0,0 +1,21 @@
+/**
+ * Languages that have been fully released and are safe to surface to users.
+ * Any locale not present in this list will fall back to "en".
+ *
+ * To release a new language, add its BCP 47 language tag here (e.g. "es").
+ */
+export const RELEASED_LANGUAGES = ["en"];
+/**
+ * Returns the locale to use based on what has been released. Matches on the
+ * language part of the locale (before the "-") so that regional variants like
+ * "en-CA" or "es-US" resolve correctly:
+ *
+ * - "en-CA" → "en-CA"  (language "en" is released; full locale preserved for
+ *                        date/time formatting)
+ * - "es-US" → "en"     (language "es" not yet released; falls back to "en")
+ * - "fr"    → "en"     (language "fr" not released; falls back to "en")
+ */
+export function getReleasedLocale(locale) {
+    const language = locale.split("-")[0];
+    return RELEASED_LANGUAGES.includes(language) ? locale : "en";
+}

package/dist/src/hooks/useAtlantisI18n/useAtlantisI18n.js

@@ -1,17 +1,19 @@
 import { useCallback } from "react";
 import en from "./locales/en.json";
 import es from "./locales/es.json";
+import { getReleasedLocale } from "./releasedLanguages";
 import { dateFormatter } from "./utils/dateFormatter";
 import { useAtlantisContext } from "../../AtlantisContext";
 export function useAtlantisI18n() {
-    const { locale, dateFormat, timeFormat, timeZone } = useAtlantisContext();
+    const { locale: contextLocale, dateFormat, timeFormat, timeZone, } = useAtlantisContext();
+    const locale = getReleasedLocale(contextLocale);
     const t = useCallback((messageKey, values) => formatMessage(messageKey, values, locale), [formatMessage, locale]);
     const formatDate = useCallback((date) => dateFormatter(date, dateFormat, { locale, timeZone }), [dateFormatter, locale]);
     const formatTime = useCallback((date) => dateFormatter(date, timeFormat, { locale, timeZone }), [dateFormatter, locale]);
     return { locale, t, formatDate, formatTime };
 }
 function getLocalizedStrings(locale) {
-    switch (locale) {
+    switch (locale.split("-")[0]) {
         case "es":
             return es;
         default:

package/dist/src/hooks/useAtlantisI18n/useAtlantisI18n.test.js

@@ -2,10 +2,15 @@ import { renderHook } from "@testing-library/react-native";
 import { useAtlantisI18n } from ".";
 import en from "./locales/en.json";
 import es from "./locales/es.json";
+import * as releasedLanguages from "./releasedLanguages";
 import * as context from "../../AtlantisContext";
 jest.mock("../../AtlantisContext", () => (Object.assign({ 
     // need to mark this as a module so that we can spy on it
     __esModule: true }, jest.requireActual("../../AtlantisContext"))));
+// Mock releasedLanguages so that jest.spyOn can reliably intercept calls from
+// inside the hook. Without this, Babel may resolve the named import as a local
+// binding at module load time, bypassing any spy set up afterwards.
+jest.mock("./releasedLanguages", () => (Object.assign({ __esModule: true }, jest.requireActual("./releasedLanguages"))));
 const spy = jest.spyOn(context, "useAtlantisContext");
 const testDate = new Date("2020-01-01T00:00:00.000Z");
 const dateAfterSpringForward = new Date("2020-04-10T00:00:00.000Z");
@@ -22,18 +27,123 @@ describe("useAtlantisI18n", () => {
         const { result } = renderHook(useAtlantisI18n);
         expect(result.current.t("FormatFile.preview", { item: "🔱" })).toBe("Preview 🔱");
     });
+    // These tests bypass the release gate via a spy so we can validate Spanish
+    // string correctness as the feature is built, independently of RELEASED_LANGUAGES.
     describe("Español", () => {
+        let getReleasedLocaleSpy;
+        beforeEach(() => {
+            getReleasedLocaleSpy = jest
+                .spyOn(releasedLanguages, "getReleasedLocale")
+                .mockImplementation(locale => locale);
+        });
+        afterEach(() => {
+            getReleasedLocaleSpy.mockRestore();
+        });
         it("should return español", () => {
             spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
             const { result } = renderHook(useAtlantisI18n);
             expect(result.current.t("cancel")).toBe("Cancelar");
         });
-    });
-    describe("Unsupported language", () => {
-        it("should return the english translation", () => {
-            spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "fr" }));
+        it("should return español for regional variant es-US", () => {
+            spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es-US" }));
             const { result } = renderHook(useAtlantisI18n);
-            expect(result.current.t("cancel")).toBe("Cancel");
+            expect(result.current.t("cancel")).toBe("Cancelar");
+        });
+        describe("formatDate", () => {
+            it("should return the date formatted for es", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatDate(testDate)).toBe("1 ene 2020");
+            });
+        });
+        describe("formatTime", () => {
+            it("should return the time formatted for es", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatTime(testDate)).toBe("00:00");
+            });
+        });
+    });
+    describe("RELEASED_LANGUAGES fallback", () => {
+        describe("unsupported language (fr)", () => {
+            it("should return 'en' as the locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "fr" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.locale).toBe("en");
+            });
+            it("should return english translations", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "fr" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.t("cancel")).toBe("Cancel");
+            });
+        });
+        describe("es-US (unreleased locale variant)", () => {
+            it("should return 'en' as the locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es-US" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.locale).toBe("en");
+            });
+            it("should return english translations", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es-US" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.t("cancel")).toBe("Cancel");
+            });
+            it("should format date using english locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es-US" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatDate(testDate)).toBe("Jan 1, 2020");
+            });
+            it("should format time using english locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es-US" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatTime(testDate)).toBe("12:00 AM");
+            });
+        });
+        describe("es (not yet released)", () => {
+            it("should return 'en' as the locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.locale).toBe("en");
+            });
+            it("should return english translations", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.t("cancel")).toBe("Cancel");
+            });
+            it("should format date using english locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatDate(testDate)).toBe("Jan 1, 2020");
+            });
+            it("should format time using english locale", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.formatTime(testDate)).toBe("12:00 AM");
+            });
+        });
+        describe("en-CA (released language, regional variant)", () => {
+            it("should preserve the full locale for date formatting", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "en-CA" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.locale).toBe("en-CA");
+            });
+            it("should return english translations", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "en-CA" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.t("cancel")).toBe("Cancel");
+            });
+        });
+        describe("en-GB (released language, regional variant)", () => {
+            it("should preserve the full locale for date formatting", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "en-GB" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.locale).toBe("en-GB");
+            });
+            it("should return english translations", () => {
+                spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "en-GB" }));
+                const { result } = renderHook(useAtlantisI18n);
+                expect(result.current.t("cancel")).toBe("Cancel");
+            });
         });
     });
     describe("Translation files", () => {
@@ -46,11 +156,6 @@ describe("useAtlantisI18n", () => {
             const { result } = renderHook(useAtlantisI18n);
             expect(result.current.formatDate(testDate)).toBe("Jan 1, 2020");
         });
-        it("should return the date formatted for es", () => {
-            spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
-            const { result } = renderHook(useAtlantisI18n);
-            expect(result.current.formatDate(testDate)).toBe("1 ene 2020");
-        });
         describe("Timezone", () => {
             it.each([
                 ["America/New_York", "Dec 31, 2019"],
@@ -70,11 +175,6 @@ describe("useAtlantisI18n", () => {
             const { result } = renderHook(useAtlantisI18n);
             expect(result.current.formatTime(testDate)).toBe("12:00 AM");
         });
-        it("should return the date formatted for es", () => {
-            spy.mockReturnValueOnce(Object.assign(Object.assign({}, context.atlantisContextDefaultValues), { locale: "es" }));
-            const { result } = renderHook(useAtlantisI18n);
-            expect(result.current.formatTime(testDate)).toBe("00:00");
-        });
         describe("Timezone", () => {
             it.each([
                 ["America/New_York", "7:00 PM"],