@jobber/components-native 0.109.1 → 0.111.0

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"],

package/dist/src/index.js

@@ -37,6 +37,7 @@ export * from "./InputSearch";
 export * from "./InputText";
 export * from "./InputTime";
 export * from "./ProgressBar";
+export * from "./ProgressIndicator";
 export * from "./Select";
 export * from "./StatusLabel";
 export * from "./Switch";

package/dist/src/utils/meta/meta.json

@@ -59,6 +59,7 @@
         "InputTime",
         "Option",
         "ProgressBar",
+        "ProgressIndicator",
         "Select",
         "Select.Content",
         "Select.Group",