@applicaster/zapp-react-native-utils 15.0.0-rc.94 → 15.0.0-rc.96

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);
+    });
+  });
+});

package/enumUtils/__tests__/getEnumKeyByEnumValue.test.ts

@@ -0,0 +1,207 @@
+import { getEnumKeyByEnumValue } from "../index";
+
+describe("getEnumKeyByEnumValue", () => {
+  enum TestEnum {
+    First = "FIRST",
+    Second = "SECOND",
+    Third = "THIRD",
+  }
+
+  enum NumericEnum {
+    Zero = 0,
+    One = 1,
+    Two = 2,
+    Three = 3,
+  }
+
+  enum MixedEnum {
+    StringValue = "string",
+    NumericValue = 42,
+    BooleanValue = "true",
+  }
+
+  describe("string enums", () => {
+    it("should return key for valid enum value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "FIRST")).toBe("First");
+      expect(getEnumKeyByEnumValue(TestEnum, "SECOND")).toBe("Second");
+      expect(getEnumKeyByEnumValue(TestEnum, "THIRD")).toBe("Third");
+    });
+
+    it("should return null for invalid enum value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "INVALID")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "first")).toBeNull();
+    });
+
+    it("should be case-sensitive", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, "first")).toBeNull();
+      expect(getEnumKeyByEnumValue(TestEnum, "FIRST")).toBe("First");
+    });
+  });
+
+  describe("numeric enums", () => {
+    it("should return key for valid numeric enum value", () => {
+      expect(getEnumKeyByEnumValue(NumericEnum, 0)).toBe("Zero");
+      expect(getEnumKeyByEnumValue(NumericEnum, 1)).toBe("One");
+      expect(getEnumKeyByEnumValue(NumericEnum, 2)).toBe("Two");
+      expect(getEnumKeyByEnumValue(NumericEnum, 3)).toBe("Three");
+    });
+
+    it("should return null for invalid numeric value", () => {
+      expect(getEnumKeyByEnumValue(NumericEnum, 4)).toBeNull();
+      expect(getEnumKeyByEnumValue(NumericEnum, -1)).toBeNull();
+      expect(getEnumKeyByEnumValue(NumericEnum, 999)).toBeNull();
+    });
+
+    it("should handle numeric strings", () => {
+      // When passing string "0", it won't match numeric enum value 0
+      expect(getEnumKeyByEnumValue(NumericEnum, "0")).toBeNull();
+    });
+  });
+
+  describe("mixed enums", () => {
+    it("should handle string values in mixed enum", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, "string")).toBe("StringValue");
+    });
+
+    it("should handle numeric values in mixed enum", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, 42)).toBe("NumericValue");
+    });
+
+    it("should handle boolean-like string values", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, "true")).toBe("BooleanValue");
+    });
+
+    it("should not match boolean to string 'true'", () => {
+      expect(getEnumKeyByEnumValue(MixedEnum, true)).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should return null for null value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, null)).toBeNull();
+    });
+
+    it("should return null for undefined value", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, undefined)).toBeNull();
+    });
+
+    it("should handle empty enum", () => {
+      const EmptyEnum = {};
+      expect(getEnumKeyByEnumValue(EmptyEnum, "anything")).toBeNull();
+    });
+
+    it("should handle object values", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, {})).toBeNull();
+    });
+
+    it("should handle array values", () => {
+      expect(getEnumKeyByEnumValue(TestEnum, [])).toBeNull();
+    });
+
+    it("should return first matching key if multiple keys have same value", () => {
+      enum DuplicateEnum {
+        First = "SAME",
+        Second = "SAME",
+      }
+
+      const result = getEnumKeyByEnumValue(DuplicateEnum, "SAME");
+      expect(result).toBeTruthy();
+      expect(["First", "Second"]).toContain(result);
+    });
+  });
+
+  describe("type checking", () => {
+    it("should work with const enum-like objects", () => {
+      const ConstLikeEnum = {
+        KEY_ONE: "value1",
+        KEY_TWO: "value2",
+      } as const;
+
+      expect(getEnumKeyByEnumValue(ConstLikeEnum, "value1")).toBe("KEY_ONE");
+      expect(getEnumKeyByEnumValue(ConstLikeEnum, "value2")).toBe("KEY_TWO");
+    });
+
+    it("should work with plain objects", () => {
+      const plainObject = {
+        key1: "val1",
+        key2: "val2",
+        key3: 123,
+      };
+
+      expect(getEnumKeyByEnumValue(plainObject, "val1")).toBe("key1");
+      expect(getEnumKeyByEnumValue(plainObject, 123)).toBe("key3");
+    });
+
+    it("should return correct TypeScript type", () => {
+      const result = getEnumKeyByEnumValue(TestEnum, "FIRST");
+
+      // Result should be keyof TestEnum | null
+      if (result !== null) {
+        expect(typeof result).toBe("string");
+      }
+    });
+  });
+
+  describe("special values", () => {
+    enum SpecialEnum {
+      EmptyString = "",
+      Zero = 0,
+      False = "false",
+      Null = "null",
+    }
+
+    it("should handle empty string value", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "")).toBe("EmptyString");
+    });
+
+    it("should handle zero value", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, 0)).toBe("Zero");
+    });
+
+    it("should handle false-like string", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "false")).toBe("False");
+    });
+
+    it("should handle null-like string", () => {
+      expect(getEnumKeyByEnumValue(SpecialEnum, "null")).toBe("Null");
+    });
+  });
+
+  describe("performance", () => {
+    it("should handle large enums efficiently", () => {
+      const largeEnum: Record<string, string> = {};
+
+      for (let i = 0; i < 1000; i++) {
+        largeEnum[`Key${i}`] = `Value${i}`;
+      }
+
+      expect(getEnumKeyByEnumValue(largeEnum, "Value500")).toBe("Key500");
+      expect(getEnumKeyByEnumValue(largeEnum, "Value999")).toBe("Key999");
+      expect(getEnumKeyByEnumValue(largeEnum, "NonExistent")).toBeNull();
+    });
+  });
+
+  describe("reverse lookup", () => {
+    enum ReverseEnum {
+      A = "ValueA",
+      B = "ValueB",
+    }
+
+    it("should provide reverse lookup functionality", () => {
+      // Forward: get value from key
+      expect(ReverseEnum.A).toBe("ValueA");
+
+      // Reverse: get key from value
+      expect(getEnumKeyByEnumValue(ReverseEnum, "ValueA")).toBe("A");
+    });
+
+    it("should be consistent with enum access", () => {
+      const key = getEnumKeyByEnumValue(TestEnum, "SECOND");
+
+      if (key) {
+        expect(TestEnum[key]).toBe("SECOND");
+      }
+    });
+  });
+});

package/errorUtils/__tests__/GeneralError.test.ts

@@ -0,0 +1,97 @@
+import { GeneralError } from "../GeneralError";
+
+describe("GeneralError", () => {
+  it("should create error with message only", () => {
+    const message = "Something went wrong";
+    const error = new GeneralError(message);
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(GeneralError);
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBeNull();
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should create error with message and status code", () => {
+    const message = "Not found";
+    const statusCode = 404;
+    const error = new GeneralError(message, statusCode);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should create error with all parameters", () => {
+    const message = "Forbidden";
+    const statusCode = 403;
+    const localizationKey = "error.forbidden";
+    const error = new GeneralError(message, statusCode, localizationKey);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBe(localizationKey);
+  });
+
+  it("should create error with null status code explicitly", () => {
+    const message = "Error without status";
+    const error = new GeneralError(message, null, "error.general");
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBeNull();
+    expect(error.localizationKey).toBe("error.general");
+  });
+
+  it("should create error with null localization key explicitly", () => {
+    const message = "Server error";
+    const statusCode = 500;
+    const error = new GeneralError(message, statusCode, null);
+
+    expect(error.message).toBe(message);
+    expect(error.statusCode).toBe(statusCode);
+    expect(error.localizationKey).toBeNull();
+  });
+
+  it("should have error name", () => {
+    const error = new GeneralError("Test error");
+
+    expect(error.name).toBe("Error");
+  });
+
+  it("should be throwable and catchable", () => {
+    const message = "Test throw";
+    const statusCode = 400;
+
+    expect(() => {
+      throw new GeneralError(message, statusCode);
+    }).toThrow(GeneralError);
+
+    try {
+      throw new GeneralError(message, statusCode);
+    } catch (error) {
+      expect(error).toBeInstanceOf(GeneralError);
+      expect((error as GeneralError).message).toBe(message);
+      expect((error as GeneralError).statusCode).toBe(statusCode);
+    }
+  });
+
+  it("should maintain error stack trace", () => {
+    const error = new GeneralError("Stack trace test");
+
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain("Stack trace test");
+  });
+
+  it("should allow status code to be 0", () => {
+    const error = new GeneralError("Zero status", 0);
+
+    expect(error.statusCode).toBe(0);
+  });
+
+  it("should allow empty string message", () => {
+    const error = new GeneralError("");
+
+    expect(error.message).toBe("");
+    expect(error.statusCode).toBeNull();
+  });
+});