@applicaster/zapp-react-native-utils 15.0.0-rc.12 → 15.0.0-rc.121

package/configurationUtils/__tests__/manifestKeyParser.test.ts

@@ -50,7 +50,7 @@ describe("getAllSpecificStyles", () => {
       });
 
       expect(outStyles).toHaveProperty("default");
-      expect(outStyles["default"]).toEqual({});
+      expect(outStyles.default).toEqual({});
     });
 
     it("should handle empty configuration", () => {
@@ -83,7 +83,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000",
         borderWidth: 2,
       });
@@ -104,7 +104,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000",
         textSize: 16,
       });
@@ -126,7 +126,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000",
       });
     });
@@ -148,11 +148,11 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000",
       });
 
-      expect(outStyles["pressed"]).toEqual({
+      expect(outStyles.pressed).toEqual({
         backgroundColor: "#00FF00",
       });
     });
@@ -171,7 +171,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["focused"]).toEqual({
+      expect(outStyles.focused).toEqual({
         borderWidth: 3,
       });
     });
@@ -190,7 +190,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["selected"]).toEqual({
+      expect(outStyles.selected).toEqual({
         opacity: 0.5,
       });
     });
@@ -209,7 +209,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["focused_selected"]).toEqual({
+      expect(outStyles.focused_selected).toEqual({
         scale: 1.2,
       });
     });
@@ -232,21 +232,21 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000",
         borderWidth: 1,
         opacity: 1,
       });
 
       // Pressed should have default styles merged with its specific override
-      expect(outStyles["pressed"]).toEqual({
+      expect(outStyles.pressed).toEqual({
         backgroundColor: "#00FF00", // Override
         borderWidth: 1, // From default
         opacity: 1, // From default
       });
 
       // Focused should have default styles merged with its specific override
-      expect(outStyles["focused"]).toEqual({
+      expect(outStyles.focused).toEqual({
         backgroundColor: "#FF0000", // From default
         borderWidth: 1, // From default
         opacity: 0.8, // Override
@@ -270,7 +270,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["pressed"]).toEqual({
+      expect(outStyles.pressed).toEqual({
         existingKey: "existingValue", // Should be preserved
         backgroundColor: "#FF0000", // From default
         textColor: "#FFFFFF", // New pressed style
@@ -294,7 +294,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FF0000", // Samsung-specific should be included
       });
     });
@@ -317,7 +317,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FFFFFF", // Only non-platform specific
       });
     });
@@ -336,7 +336,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         color: "#FF0000",
       });
     });
@@ -356,7 +356,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["pressed"]).toEqual({
+      expect(outStyles.pressed).toEqual({
         backgroundColor: "#FF0000", // Only samsung style
       });
     });
@@ -377,7 +377,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#00FF00", // Samsung-specific should win
       });
     });
@@ -412,14 +412,14 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         backgroundColor: "#FFFFFF",
         textColor: "#000000",
         borderWidth: 1,
         padding: 10,
       });
 
-      expect(outStyles["pressed"]).toEqual({
+      expect(outStyles.pressed).toEqual({
         backgroundColor: "#EEEEEE",
         textColor: "#000000",
         borderWidth: 1,
@@ -427,7 +427,7 @@ describe("getAllSpecificStyles", () => {
         opacity: 0.8,
       });
 
-      expect(outStyles["focused"]).toEqual({
+      expect(outStyles.focused).toEqual({
         backgroundColor: "#FFFFFF",
         textColor: "#000000",
         borderWidth: 1,
@@ -453,7 +453,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         validKey: "included",
       });
     });
@@ -474,11 +474,11 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["focused_selected"]).toEqual({
+      expect(outStyles.focused_selected).toEqual({
         test: "focused_selected_value",
       });
 
-      expect(outStyles["focused"]).toEqual({
+      expect(outStyles.focused).toEqual({
         another: "focused_value",
       });
     });
@@ -517,7 +517,7 @@ describe("getAllSpecificStyles", () => {
         outStyles,
       });
 
-      expect(outStyles["pressed"]["backgroundColor"]).toBe("#222222");
+      expect(outStyles.pressed.backgroundColor).toBe("#222222");
     });
 
     it("should handle frozen outStyles properties", () => {
@@ -537,7 +537,7 @@ describe("getAllSpecificStyles", () => {
       });
 
       // Should create new object instead of mutating frozen one
-      expect(outStyles["default"]).toEqual({
+      expect(outStyles.default).toEqual({
         existingProp: "value",
         backgroundColor: "#FF0000",
       });

package/configurationUtils/index.ts

@@ -155,9 +155,9 @@ export function getMediaItems(entry: ZappEntry): Option<ZappMediaItem[]> {
 
 /**
  * Retrieves the "src" value from a media item in the entry's media group,
- * based on a provided key, with fallback logic.
+ * based on a provided key, with optional fallback logic.
  *
- * Fallback order:
+ * Fallback order (when enabled):
  *   1. Attempts to find a media item with the specified key (or "image_base" if none provided).
  *   2. If not found, attempts to find a media item with the key "image_base".
  *   3. If still not found, falls back to the first available media item.
@@ -166,15 +166,19 @@ export function getMediaItems(entry: ZappEntry): Option<ZappMediaItem[]> {
  * since empty URIs are invalid in some platforms (e.g., React Native).
  *
  * @param {ZappEntry} entry - The entry object containing a media group.
- * @param {string[] | unknown} arg - A single-element array containing the key to look up, or any unknown value.
+ * @param {string[] | unknown} arg - Can be an array or any other value (treated as empty array).
+ *   When an array:
+ *   - First element: The key to look up. If omitted or undefined, defaults to "image_base".
+ *   - Second element: Boolean to enable/disable fallback logic. If omitted or undefined, defaults to true.
  * @returns {?string} The "src" URI from the matched media item, or undefined if not found or empty.
  */
 export function imageSrcFromMediaItem(
   entry: ZappEntry,
   arg: string[] | unknown
 ): Option<string> {
-  const args: unknown = R.unless(Array.isArray, Array)(arg || []);
+  const args: any = R.unless(Array.isArray, Array)(arg || []);
   const imageKey: string = args?.[0] || "image_base"; // always a single key in this function
+  const fallback: boolean = args?.[1] !== false;
 
   const mediaItems = getMediaItems(entry);
 
@@ -185,14 +189,16 @@ export function imageSrcFromMediaItem(
   // Try to find the item with the given key
   let foundItem = mediaItems.find((item) => item.key === imageKey);
 
-  // If not found and key was not "image_base", try to find "image_base"
-  if (!foundItem && imageKey !== "image_base") {
-    foundItem = mediaItems.find((item) => item.key === "image_base");
-  }
+  if (fallback) {
+    // If not found and key was not "image_base", try to find "image_base"
+    if (!foundItem && imageKey !== "image_base") {
+      foundItem = mediaItems.find((item) => item.key === "image_base");
+    }
 
-  // If still not found, default to first item
-  if (!foundItem) {
-    foundItem = mediaItems[0];
+    // If still not found, default to first item
+    if (!foundItem) {
+      foundItem = mediaItems[0];
+    }
   }
 
   const src = foundItem?.src;

package/dateUtils/__tests__/dayjs.test.ts

@@ -0,0 +1,330 @@
+import { dayjs } from "../index";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+
+dayjs.extend(customParseFormat);
+
+describe("dayjs", () => {
+  describe("basic functionality", () => {
+    it("should be defined and be a function", () => {
+      expect(dayjs).toBeDefined();
+      expect(typeof dayjs).toBe("function");
+    });
+
+    it("should create dayjs object from date string", () => {
+      const date = dayjs("2023-01-01");
+
+      expect(date.isValid()).toBe(true);
+      expect(date.year()).toBe(2023);
+      expect(date.month()).toBe(0); // January is 0
+      expect(date.date()).toBe(1);
+    });
+
+    it("should create dayjs object from timestamp", () => {
+      const timestamp = 1672531200000; // 2023-01-01 00:00:00 UTC
+      const date = dayjs(timestamp);
+
+      expect(date.isValid()).toBe(true);
+      expect(date.valueOf()).toBe(timestamp);
+    });
+
+    it("should get current date when called without arguments", () => {
+      const now = dayjs();
+
+      expect(now.isValid()).toBe(true);
+      expect(now.year()).toBeGreaterThan(2020);
+    });
+  });
+
+  describe("utc plugin", () => {
+    it("should support UTC conversion", () => {
+      const date = dayjs("2023-01-01T12:00:00");
+      const utcDate = date.utc();
+
+      expect(utcDate).toBeDefined();
+      expect(utcDate.isValid()).toBe(true);
+    });
+
+    it("should create UTC date", () => {
+      const utcDate = dayjs.utc("2023-01-01");
+
+      expect(utcDate.isValid()).toBe(true);
+      expect(utcDate.utcOffset()).toBe(0);
+    });
+
+    it("should handle UTC offset correctly", () => {
+      const date = dayjs.utc();
+
+      expect(date.utcOffset()).toBe(0);
+    });
+  });
+
+  describe("timezone plugin", () => {
+    it("should support timezone conversion", () => {
+      const date = dayjs("2023-01-01T12:00:00");
+      const tzDate = date.tz("America/New_York");
+
+      expect(tzDate).toBeDefined();
+      expect(tzDate.isValid()).toBe(true);
+    });
+
+    it("should create date in specific timezone", () => {
+      const date = dayjs.tz("2023-01-01", "America/New_York");
+
+      expect(date.isValid()).toBe(true);
+    });
+
+    it("should handle timezone method", () => {
+      const date = dayjs();
+
+      // Just verify the method exists and doesn't throw
+      expect(() => date.tz("UTC")).not.toThrow();
+    });
+  });
+
+  describe("isoWeek plugin", () => {
+    it("should get ISO week of year", () => {
+      const date = dayjs("2023-01-01");
+      const isoWeek = date.isoWeek();
+
+      expect(typeof isoWeek).toBe("number");
+      expect(isoWeek).toBeGreaterThan(0);
+      expect(isoWeek).toBeLessThanOrEqual(53);
+    });
+
+    it("should get ISO weekday", () => {
+      const date = dayjs("2023-01-02"); // Monday
+      const isoWeekday = date.isoWeekday();
+
+      expect(isoWeekday).toBe(1); // Monday is 1 in ISO weekday
+    });
+
+    it("should set ISO week", () => {
+      const date = dayjs("2023-01-01");
+      const newDate = date.isoWeek(10);
+
+      expect(newDate.isoWeek()).toBe(10);
+    });
+  });
+
+  describe("duration plugin", () => {
+    it("should create duration from milliseconds", () => {
+      const duration = dayjs.duration(1000);
+
+      expect(duration.asSeconds()).toBe(1);
+    });
+
+    it("should create duration with object", () => {
+      const duration = dayjs.duration({
+        hours: 1,
+        minutes: 30,
+      });
+
+      expect(duration.asMinutes()).toBe(90);
+    });
+
+    it("should format duration", () => {
+      const duration = dayjs.duration(3661, "seconds");
+
+      expect(duration.hours()).toBe(1);
+      expect(duration.minutes()).toBe(1);
+      expect(duration.seconds()).toBe(1);
+    });
+
+    it("should add duration to date", () => {
+      const date = dayjs("2023-01-01");
+      const duration = dayjs.duration(1, "day");
+      const newDate = date.add(duration);
+
+      expect(newDate.date()).toBe(2);
+    });
+
+    it("should subtract duration from date", () => {
+      const date = dayjs("2023-01-02");
+      const duration = dayjs.duration(1, "day");
+      const newDate = date.subtract(duration);
+
+      expect(newDate.date()).toBe(1);
+    });
+  });
+
+  describe("relativeTime plugin", () => {
+    it("should get time from now", () => {
+      const pastDate = dayjs().subtract(1, "hour");
+      const relative = pastDate.fromNow();
+
+      expect(typeof relative).toBe("string");
+      expect(relative).toContain("hour");
+    });
+
+    it("should get time to now", () => {
+      const futureDate = dayjs().add(1, "hour");
+      const relative = futureDate.toNow();
+
+      expect(typeof relative).toBe("string");
+      expect(relative).toContain("hour");
+    });
+
+    it("should get time from specific date", () => {
+      const date1 = dayjs("2023-01-01");
+      const date2 = dayjs("2023-01-02");
+      const relative = date1.from(date2);
+
+      expect(typeof relative).toBe("string");
+      expect(relative).toContain("day");
+    });
+
+    it("should get time to specific date", () => {
+      const date1 = dayjs("2023-01-01");
+      const date2 = dayjs("2023-01-02");
+      const relative = date2.to(date1);
+
+      expect(typeof relative).toBe("string");
+      expect(relative).toContain("day");
+    });
+
+    it("should handle relative time for minutes", () => {
+      const pastDate = dayjs().subtract(30, "minutes");
+      const relative = pastDate.fromNow();
+
+      expect(relative).toContain("minute");
+    });
+
+    it("should handle relative time for days", () => {
+      const pastDate = dayjs().subtract(5, "days");
+      const relative = pastDate.fromNow();
+
+      expect(relative).toContain("day");
+    });
+
+    it("should handle relative time for months", () => {
+      const pastDate = dayjs().subtract(2, "months");
+      const relative = pastDate.fromNow();
+
+      expect(relative).toContain("month");
+    });
+
+    it("should handle relative time for years", () => {
+      const pastDate = dayjs().subtract(2, "years");
+      const relative = pastDate.fromNow();
+
+      expect(relative).toContain("year");
+    });
+  });
+
+  describe("custom relativeTime thresholds", () => {
+    it("should respect custom threshold configuration", () => {
+      // Our custom config has 59 minutes threshold for 'mm'
+      const date = dayjs().subtract(45, "minutes");
+      const relative = date.fromNow();
+
+      // Should show minutes, not hours
+      expect(relative).toContain("minute");
+    });
+
+    it("should handle edge case at day threshold", () => {
+      const date = dayjs().subtract(29, "days");
+      const relative = date.fromNow();
+
+      // With custom threshold of 29 days, should still show days
+      expect(relative).toContain("day");
+    });
+  });
+
+  describe("date manipulation", () => {
+    it("should add time units", () => {
+      const date = dayjs("2023-01-01");
+
+      expect(date.add(1, "day").date()).toBe(2);
+      expect(date.add(1, "month").month()).toBe(1);
+      expect(date.add(1, "year").year()).toBe(2024);
+    });
+
+    it("should subtract time units", () => {
+      const date = dayjs("2023-01-02");
+
+      expect(date.subtract(1, "day").date()).toBe(1);
+      expect(date.subtract(1, "month").month()).toBe(11); // December of previous year
+      expect(date.subtract(1, "year").year()).toBe(2022);
+    });
+
+    it("should start of time unit", () => {
+      const date = dayjs("2023-06-15T14:30:45");
+
+      expect(date.startOf("day").hour()).toBe(0);
+      expect(date.startOf("month").date()).toBe(1);
+      expect(date.startOf("year").month()).toBe(0);
+    });
+
+    it("should end of time unit", () => {
+      const date = dayjs("2023-06-15T14:30:45");
+
+      expect(date.endOf("day").hour()).toBe(23);
+      expect(date.endOf("month").date()).toBe(30); // June has 30 days
+      expect(date.endOf("year").month()).toBe(11); // December
+    });
+  });
+
+  describe("formatting", () => {
+    it("should format date", () => {
+      const date = dayjs("2023-01-01T12:30:45");
+
+      expect(date.format("YYYY-MM-DD")).toBe("2023-01-01");
+      expect(date.format("YYYY/MM/DD HH:mm:ss")).toContain("2023/01/01");
+    });
+
+    it("should convert to ISO string", () => {
+      const date = dayjs("2023-01-01");
+      const iso = date.toISOString();
+
+      expect(iso).toContain("2023-01-01");
+      expect(iso).toContain("T");
+      expect(iso).toContain("Z");
+    });
+
+    it("should convert to Date object", () => {
+      const dayjsDate = dayjs("2023-01-01");
+      const jsDate = dayjsDate.toDate();
+
+      expect(jsDate).toBeInstanceOf(Date);
+      expect(jsDate.getFullYear()).toBe(2023);
+    });
+  });
+
+  describe("comparison", () => {
+    it("should check if date is before another", () => {
+      const date1 = dayjs("2023-01-01");
+      const date2 = dayjs("2023-01-02");
+
+      expect(date1.isBefore(date2)).toBe(true);
+      expect(date2.isBefore(date1)).toBe(false);
+    });
+
+    it("should check if date is after another", () => {
+      const date1 = dayjs("2023-01-01");
+      const date2 = dayjs("2023-01-02");
+
+      expect(date2.isAfter(date1)).toBe(true);
+      expect(date1.isAfter(date2)).toBe(false);
+    });
+
+    it("should check if date is same as another", () => {
+      const date1 = dayjs("2023-01-01");
+      const date2 = dayjs("2023-01-01");
+
+      expect(date1.isSame(date2)).toBe(true);
+    });
+  });
+
+  describe("validation", () => {
+    it("should validate valid dates", () => {
+      expect(dayjs("2023-01-01").isValid()).toBe(true);
+      expect(dayjs(new Date()).isValid()).toBe(true);
+      expect(dayjs(Date.now()).isValid()).toBe(true);
+    });
+
+    it("should detect invalid dates", () => {
+      expect(dayjs("invalid").isValid()).toBe(false);
+      expect(dayjs("2023-13-01", "YYYY-MM-DD", true).isValid()).toBe(false);
+    });
+  });
+});