@applicaster/zapp-react-native-utils 14.0.23-alpha.3038517325 → 14.0.24-alpha.2716433026

package/cellUtils/__tests__/cellUtils.test.ts

@@ -3,6 +3,7 @@ import {
   ifEmptyUseFallback,
   textTransform,
   getKeyForLabel,
+  getDataTransformForLabel,
   getLabel,
   getAspectRatio,
   getCellWidth,
@@ -56,6 +57,44 @@ describe("getKeyForLabel", () => {
   });
 });
 
+describe("getDataTransformForLabel", () => {
+  it("returns dataKey when dataKey is not other", () => {
+    expect(getDataTransformForLabel(VAL.dataKey, VAL.customKey)).toEqual(
+      VAL.dataKey
+    );
+  });
+
+  it("returns customKey when dataKey is other", () => {
+    expect(getDataTransformForLabel(VAL.other, VAL.customKey)).toEqual(
+      VAL.customKey
+    );
+  });
+
+  it("preserves full date formats containing dots", () => {
+    expect(getDataTransformForLabel(VAL.other, "DD.MM.YYYY")).toEqual(
+      "DD.MM.YYYY"
+    );
+  });
+
+  it("returns default date format when selected key is null or undefined", () => {
+    expect(getDataTransformForLabel(EMPTY.nulls, VAL.customKey)).toEqual(
+      "DD/MM/YYYY"
+    );
+
+    expect(getDataTransformForLabel(EMPTY.undef, VAL.customKey)).toEqual(
+      "DD/MM/YYYY"
+    );
+
+    expect(getDataTransformForLabel(VAL.other, EMPTY.nulls)).toEqual(
+      "DD/MM/YYYY"
+    );
+
+    expect(getDataTransformForLabel(VAL.other, EMPTY.undef)).toEqual(
+      "DD/MM/YYYY"
+    );
+  });
+});
+
 describe("getLabel", () => {
   it("returns a string from dataKey's path", () => {
     expect(getLabel(VAL.dataKey, VAL.customKey)(entry)).toEqual(entry.id);

package/cellUtils/index.ts

@@ -1,5 +1,5 @@
 import * as R from "ramda";
-import dayjs from "dayjs";
+import { dayjs } from "../dateUtils";
 import validateColor from "validate-color";
 
 import { transformColorCode as fixColorHexCode } from "@applicaster/zapp-react-native-utils/transform";
@@ -31,6 +31,16 @@ export const getKeyForLabel = (dataKey, customKey) => {
   return keyToUse.split(".");
 };
 
+/**
+ * Provides `format` for date formatting. Returns customKey if dataKey is "other", otherwise it returns dataKey.
+ * Should consist of valid dayjs tokens - https://day.js.org/docs/en/parse/string-format#list-of-all-available-parsing-tokens
+ */
+export const getDataTransformForLabel = (dataKey, customKey) => {
+  const keyToUse = dataKey === CUSTOM_KEY ? customKey : dataKey;
+
+  return keyToUse ?? "DD/MM/YYYY";
+};
+
 /**
  * This method will return true if the argument passed to it is either empty or nil
  * The method prevents zero from being evaluated as falsey in an || condition

package/dateUtils/__tests__/dayjs.test.ts

@@ -0,0 +1,327 @@
+import { dayjs } from "../index";
+
+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);
+    });
+  });
+});

package/dateUtils/index.ts

@@ -4,12 +4,14 @@ import timezone from "dayjs/plugin/timezone";
 import isoWeek from "dayjs/plugin/isoWeek";
 import duration from "dayjs/plugin/duration";
 import relativeTime from "dayjs/plugin/relativeTime";
+import customParseFormat from "dayjs/plugin/customParseFormat";
 
 // Extend dayjs with plugins
 dayjs.extend(utc);
 dayjs.extend(timezone);
 dayjs.extend(isoWeek);
 dayjs.extend(duration);
+dayjs.extend(customParseFormat);
 
 dayjs.extend(relativeTime, {
   thresholds: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "14.0.23-alpha.3038517325",
+  "version": "14.0.24-alpha.2716433026",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "14.0.23-alpha.3038517325",
+    "@applicaster/applicaster-types": "14.0.24-alpha.2716433026",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/zappFrameworkUtils/HookCallback/callbackNavigationAction.ts

@@ -46,7 +46,7 @@ const legacyMappingKeys = {
     actionType: "login_completion_action",
     targetScreen: "navigate_to_login_screen",
   },
-  "quick-brick-user-account-ui-component": {
+  "quick-brick-user-account-ui-component.login": {
     actionType: "callbackAction",
   },
   "quick-brick-login-multi-login-providers.login": {
@@ -82,10 +82,10 @@ export const getNavigationKeys = (
   item?: ZappUIComponent | ZappRiver,
   resultType: ResultType | null = null
 ): NavKeys => {
-  const general = ((item as any)?.general ?? {}) as General;
+  const general = (item?.general ?? {}) as General;
 
   const pluginIdentifier =
-    (item as any).identifier ?? (item as any)?.type ?? "";
+    (item as any)?.identifier ?? item?.type ?? item?.component_type ?? "";
 
   const legacy =
     legacyMappingKeys[`${pluginIdentifier}.${resultType}`] ??
@@ -176,12 +176,25 @@ export const useCallbackNavigationAction = (
         return;
       }
 
-      const data = getNavigationKeys(item, args.options?.resultType ?? null);
+      let data = getNavigationKeys(item, args.options?.resultType ?? null);
 
       if (!data) {
-        hookCallback?.(args);
+        const isScreen = !hookCallback;
 
-        return;
+        if (isScreen && args.options?.resultType === ResultType.login) {
+          log_debug(
+            `${LogPrefix} no navigation data found, applying GO BACK for login screen`
+          );
+
+          data = {
+            action: NavigationCallbackOptions.GO_BACK,
+            targetScreenId: null,
+          };
+        } else {
+          hookCallback?.(args);
+
+          return;
+        }
       }
 
       hookCallback?.({ ...args, success: false, cancelled: true });

package/zappFrameworkUtils/HookCallback/hookCallbackManifestExtensions.config.js

@@ -20,7 +20,7 @@ const callbackKeyPrefix = (key, prefix, keySeparator = "_") =>
 
 const extendManifestWithHookCallback = (prefix = null) => ({
   group: true,
-  label: "CallBack Navigation",
+  label: prefix ? `Callback Navigation: ${prefix}` : "Callback Navigation",
   folded: true,
   fields: [
     {

package/zappFrameworkUtils/loginPluginUtils.ts

@@ -20,7 +20,7 @@ const isAuthenticationRequired = ({ payload, logs }) => {
 
   if (!payload) {
     log_info(
-      "isAuthenticationRequired: No payload exist, authentefication required"
+      "isAuthenticationRequired: No payload exists, authentication required"
     );
 
     return true;