@cwellt_software/cwellt-reactjs-lib 1.1.4 → 1.1.5

package/dist/test/components/custom/new-scheduler/presentation/logic/monthDivisions.test.js

@@ -1,42 +0,0 @@
-import { getMonthsByDays, } from "../../../../../../src/components/custom/scheduler-new/presentation/logic/getDefaultDivisions";
-describe("getMonthdivisions", () => {
-    test("should return empty list if 0 days", () => {
-        expect(getMonthsByDays(0, new Date("2024-10-13"))).toStrictEqual([]);
-    });
-    test("should return empty list if 0 days", () => {
-        expect(getMonthsByDays(1, new Date("2024-10-13"))).toStrictEqual([
-            {
-                start: new Date("2024-10-13"),
-                days: 1
-            }
-        ]);
-    });
-    test("should return 2 divisions 31 days", () => {
-        expect(getMonthsByDays(31, new Date("2024-12-30"))).toStrictEqual([
-            {
-                start: new Date("2024-12-30"),
-                days: 2
-            },
-            {
-                start: new Date("2025-01-01"),
-                days: 29
-            }
-        ]);
-    });
-    test("should return 3 divisions 45 days", () => {
-        expect(getMonthsByDays(45, new Date("2024-12-30"))).toStrictEqual([
-            {
-                start: new Date("2024-12-30"),
-                days: 2
-            },
-            {
-                start: new Date("2025-01-01"),
-                days: 31
-            },
-            {
-                start: new Date("2025-02-01"),
-                days: 12
-            }
-        ]);
-    });
-});

package/dist/test/components/custom/new-scheduler/presentation/logic/weekendCalc.test.js

@@ -1,30 +0,0 @@
-import { getWeekendLinesByDatesVisible, getWeekendsDaysInDateRange } from "../../../../../../src/components/custom/scheduler-new/presentation/logic/WeekendCalc";
-describe("getWeekendsDaysInDateRange", () => {
-    test("from monday to friday should return 0 days", () => {
-        const days = getWeekendsDaysInDateRange(new Date("2004-03-22"), 5);
-        expect(days.length).toBe(0);
-    });
-    test("from monday to sunday should return 2 days", () => {
-        const days = getWeekendsDaysInDateRange(new Date("2004-03-22"), 7);
-        expect(days.length).toBe(2);
-    });
-    test("from monday to sunday should return saturday and sunday of the week", () => {
-        const days = getWeekendsDaysInDateRange(new Date("2004-03-22"), 7);
-        expect(days[0].toString()).toStrictEqual(new Date("2004-03-27").toString());
-        expect(days[1].toString()).toStrictEqual(new Date("2004-03-28").toString());
-    });
-    test("from monday to sunday in two weeks should return 4 days", () => {
-        const days = getWeekendsDaysInDateRange(new Date("2004-03-22"), 14);
-        expect(days.length).toBe(4);
-    });
-    test("from sunday to sunday in two weeks should return 3 days", () => {
-        const days = getWeekendsDaysInDateRange(new Date("2004-03-28"), 8);
-        expect(days.length).toBe(3);
-    });
-});
-describe("getWeekendLinesByDatesVisible", () => {
-    test("from day 28-11-24 to 5 days show return 2 positive widths", () => {
-        const days = getWeekendLinesByDatesVisible(new Date("2024-11-28"), 5);
-        expect(days[1].width).toBeGreaterThan(0);
-    });
-});

package/dist/test/components/custom/scheduler/addMinutesToDateFromPx.test.js

@@ -1,43 +0,0 @@
-import { addMinutesToDateFromPx } from "../../../../src/components/custom/scheduler/logic/dates/addMinutesToDateFromPx";
-describe("addMinutesToDateFromPx", () => {
-    it("should correctly add minutes to the original date", () => {
-        const originalDate = new Date("2023-01-01T00:00:00Z");
-        const leftPx = 100;
-        const minutesPerPx = 10;
-        const expectedDate = new Date("2023-01-01T00:10:00Z");
-        const result = addMinutesToDateFromPx(originalDate, leftPx, minutesPerPx);
-        expect(result).toEqual(expectedDate);
-    });
-    it("should handle zero pixels correctly", () => {
-        const originalDate = new Date("2023-01-01T00:00:00Z");
-        const leftPx = 0;
-        const minutesPerPx = 10;
-        const expectedDate = new Date("2023-01-01T00:00:00Z");
-        const result = addMinutesToDateFromPx(originalDate, leftPx, minutesPerPx);
-        expect(result).toEqual(expectedDate);
-    });
-    it("should handle negative pixel values correctly", () => {
-        const originalDate = new Date("2023-01-01T00:00:00Z");
-        const leftPx = -50;
-        const minutesPerPx = 10;
-        const expectedDate = new Date("2022-12-31T23:55:00Z");
-        const result = addMinutesToDateFromPx(originalDate, leftPx, minutesPerPx);
-        expect(result).toEqual(expectedDate);
-    });
-    it("should handle non-integer minutes per pixel correctly", () => {
-        const originalDate = new Date("2023-01-01T00:00:00Z");
-        const leftPx = 46.5;
-        const minutesPerPx = 15.5;
-        const expectedDate = new Date("2023-01-01T00:03:00Z");
-        const result = addMinutesToDateFromPx(originalDate, leftPx, minutesPerPx);
-        expect(result).toEqual(expectedDate);
-    });
-    it("should handle non-integer pixel values correctly", () => {
-        const originalDate = new Date("2023-01-01T00:00:00Z");
-        const leftPx = 75.5;
-        const minutesPerPx = 10;
-        const expectedDate = new Date("2023-01-01T00:07:33Z");
-        const result = addMinutesToDateFromPx(originalDate, leftPx, minutesPerPx);
-        expect(result).toEqual(expectedDate);
-    });
-});

package/dist/test/components/custom/scheduler/checkIfSlotAvailable.test.js

@@ -1,30 +0,0 @@
-import { checkIfSlotAvailable } from "../../../../src/components/custom/scheduler/logic/ui/checkIfSlotAvailable";
-import { cblEvent } from "../../../../src/components/custom/scheduler/state/cblEvent";
-describe("checkIfSlotAvailable", () => {
-    const baseDate = new Date("2023-01-01T00:00:00");
-    test("returns true when event starts after the last event ends", () => {
-        const events = [new cblEvent(new Date(baseDate.getTime()), new Date(baseDate.getTime() + 3600000), 1)];
-        const newEvent = new cblEvent(new Date(baseDate.getTime() + 3600001), new Date(baseDate.getTime() + 7200000), 1);
-        expect(checkIfSlotAvailable(events, newEvent)).toBe(true);
-    });
-    test("returns false when event starts before the last event ends", () => {
-        const events = [new cblEvent(new Date(baseDate.getTime()), new Date(baseDate.getTime() + 3600000), 1)];
-        const newEvent = new cblEvent(new Date(baseDate.getTime() + 3599999), new Date(baseDate.getTime() + 7200000), 1);
-        expect(checkIfSlotAvailable(events, newEvent)).toBe(false);
-    });
-    test("returns true when the last event is full height, regardless of timing", () => {
-        const events = [new cblEvent(new Date(baseDate.getTime()), new Date(baseDate.getTime() + 3600000), 1, null, true)];
-        const newEvent = new cblEvent(new Date(baseDate.getTime() + 1800000), new Date(baseDate.getTime() + 5400000), 1);
-        expect(checkIfSlotAvailable(events, newEvent)).toBe(true);
-    });
-    test("returns true when events array is empty", () => {
-        const events = [];
-        const newEvent = new cblEvent(new Date(baseDate.getTime()), new Date(baseDate.getTime() + 3600000), 1);
-        expect(checkIfSlotAvailable(events, newEvent)).toBe(true);
-    });
-    test("returns true when new event starts exactly when last event ends", () => {
-        const events = [new cblEvent(new Date(baseDate.getTime()), new Date(baseDate.getTime() + 3600000), 1)];
-        const newEvent = new cblEvent(new Date(baseDate.getTime() + 3600000), new Date(baseDate.getTime() + 7200000), 1);
-        expect(checkIfSlotAvailable(events, newEvent)).toBe(true);
-    });
-});

package/dist/test/components/custom/scheduler/daysBetweenTwoDates.test.js

@@ -1,61 +0,0 @@
-import { daysBetweenTwoDates } from "../../../../src/components/custom/scheduler/logic/dates/daysBetweenTwoDates";
-describe("daysBetweenTwoDates", () => {
-    test("should return 0 for the same dates", () => {
-        const date1 = new Date("2024-07-19");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDates(date1, date2);
-        expect(result).toBe(0);
-    });
-    test("should return 1 for dates one day apart", () => {
-        const date1 = new Date("2024-07-18");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDates(date1, date2);
-        expect(result).toBe(1);
-    });
-    test("handles reverse order of dates", () => {
-        const date1 = new Date("2023-01-01");
-        const date2 = new Date("2023-01-05");
-        expect(daysBetweenTwoDates(date2, date1)).toBe(4);
-    });
-    test("handles dates across months", () => {
-        const date1 = new Date("2023-01-31");
-        const date2 = new Date("2023-02-02");
-        expect(daysBetweenTwoDates(date1, date2)).toBe(2);
-    });
-    test("handles dates across years", () => {
-        const date1 = new Date("2022-12-31");
-        const date2 = new Date("2023-01-01");
-        expect(daysBetweenTwoDates(date1, date2)).toBe(1);
-    });
-    test("handles leap year", () => {
-        const date1 = new Date("2024-02-28");
-        const date2 = new Date("2024-03-01");
-        expect(daysBetweenTwoDates(date1, date2)).toBe(2);
-    });
-    test("should return 1 for dates hours apart", () => {
-        const date1 = new Date("2024-07-19T00:00:00");
-        const date2 = new Date("2024-07-19T01:00:00");
-        const result = daysBetweenTwoDates(date1, date2);
-        expect(result).toBe(1);
-    });
-    test("doesn't handles daylight saving time change (spring forward)", () => {
-        // Note: This test assumes a timezone that observes DST
-        const date1 = new Date("2023-03-12T01:59:59-05:00");
-        const date2 = new Date("2023-03-12T03:00:00-04:00");
-        // TODO: should be 0 change after the refactor
-        expect(daysBetweenTwoDates(date1, date2)).toBe(1);
-    });
-    test("handles daylight saving time change (fall back)", () => {
-        // Using America/New_York timezone for this test
-        const date1 = new Date("2023-11-05T01:59:59-04:00");
-        const date2 = new Date("2023-11-05T01:00:00-05:00");
-        // TODO: should be 0 change after the refactor
-        expect(daysBetweenTwoDates(date1, date2)).toBe(1);
-    });
-    test("should return 30 for dates one month apart (June to July)", () => {
-        const date1 = new Date("2024-06-19");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDates(date1, date2);
-        expect(result).toBe(30);
-    });
-});

package/dist/test/components/custom/scheduler/daysBetweenTwoDatesWithoutCeilForEvent.test.js

@@ -1,27 +0,0 @@
-import { daysBetweenTwoDatesIncludingBoth } from "../../../../src/components/custom/scheduler/logic/dates/daysBetweenTwoDatesWithoutCeil";
-describe("daysBetweenTwoDatesWithoutCeilForEvent", () => {
-    test("should return 0 for the same dates", () => {
-        const date1 = new Date("2024-07-19");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDatesIncludingBoth(date1, date2);
-        expect(result).toBe(0);
-    });
-    test("should return 1 for dates one day apart", () => {
-        const date1 = new Date("2024-07-18");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDatesIncludingBoth(date1, date2);
-        expect(result).toBe(1);
-    });
-    test("should return 0.5 for dates 12 hours apart", () => {
-        const date1 = new Date("2024-07-19T00:00:00");
-        const date2 = new Date("2024-07-19T12:00:00");
-        const result = daysBetweenTwoDatesIncludingBoth(date1, date2);
-        expect(result).toBe(0.5);
-    });
-    test("should return 30 for dates one month apart (June to July)", () => {
-        const date1 = new Date("2024-06-19");
-        const date2 = new Date("2024-07-19");
-        const result = daysBetweenTwoDatesIncludingBoth(date1, date2);
-        expect(result).toBe(30);
-    });
-});

package/dist/test/components/custom/scheduler/getGUID.test.js

@@ -1,30 +0,0 @@
-import { getGUID } from "../../../../src/components/custom/scheduler/logic/strings/getGUID";
-describe("getGUID", () => {
-    it("should return a string", () => {
-        const result = getGUID();
-        expect(typeof result).toBe("string");
-    });
-    it("should return a string of length 36", () => {
-        const result = getGUID();
-        expect(result.length).toBe(36);
-    });
-    it("should return a string with four hyphens", () => {
-        const result = getGUID();
-        const hyphens = result.match(/-/g);
-        expect(hyphens).toHaveLength(4);
-    });
-    it("should return a string with hyphens at positions 8 and 13", () => {
-        const result = getGUID();
-        expect(result.charAt(8)).toBe("-");
-        expect(result.charAt(13)).toBe("-");
-    });
-    it("should return a string with only hexadecimal characters and hyphens", () => {
-        const result = getGUID();
-        expect(result).toMatch(/^[0-9a-f-]+$/i);
-    });
-    it("should return different GUIDs on subsequent calls", () => {
-        const guid1 = getGUID();
-        const guid2 = getGUID();
-        expect(guid1).not.toBe(guid2);
-    });
-});

package/dist/test/components/custom/scheduler/getPixelsForEvent.test.js

@@ -1,38 +0,0 @@
-import { getLeftPixels, } from "../../../../src/components/custom/scheduler/logic/pixels/getPixelsForEvent";
-describe("getLeftPixels", () => {
-    it("should calculate pixels correctly when stateStart is after eventStart", () => {
-        const stateStart = new Date("2024-01-10");
-        const eventStart = new Date("2024-01-01");
-        const dayPx = 10;
-        const result = getLeftPixels(stateStart, eventStart, dayPx);
-        expect(result).toBe(90);
-    });
-    it("should return 0 if eventStart is before newStart", () => {
-        const eventStart = new Date("2024-01-01");
-        const newStart = new Date("2024-01-10");
-        const dayPx = 10;
-        const result = getLeftPixels(eventStart, newStart, dayPx);
-        expect(result).toBe(0);
-    });
-    it("should return good if eventStart is 16.10.2024 12:00 and start is 14-10-2024", () => {
-        const eventStart = new Date("2024-10-16T12:00:00Z");
-        const newStart = new Date("2024-10-14");
-        const dayPx = 10;
-        const result = getLeftPixels(eventStart, newStart, dayPx);
-        expect(result).toBe(25);
-    });
-    it("should return", () => {
-        const eventStart = new Date("2024-11-04T04:10:00Z");
-        const newStart = new Date("2024-11-04");
-        const dayPx = 1;
-        const result = getLeftPixels(eventStart, newStart, dayPx);
-        expect(result).toBeCloseTo(0.173);
-    });
-    it("should return", () => {
-        const eventStart = new Date("2024-11-04T15:05:00Z");
-        const newStart = new Date("2024-11-04");
-        const dayPx = 1;
-        const result = getLeftPixels(eventStart, newStart, dayPx);
-        expect(result).toBeCloseTo(0.628);
-    });
-});

package/dist/test/components/custom/scheduler/getTimeHeaders.test.js

@@ -1,35 +0,0 @@
-import { getTimeHeaders } from "../../../../src/components/custom/scheduler/logic/ui/getTimeHeaders";
-describe("getTimeHeaders", () => {
-    it("should return correct array of dates for summer offset", () => {
-        const startDate = new Date("2024-07-01T00:00:00Z");
-        const endDate = new Date("2024-07-01T02:00:00Z");
-        const result = getTimeHeaders(startDate, endDate);
-        expect(result).toEqual([new Date("2024-07-01T00:00:00Z"), new Date("2024-07-01T01:00:00Z")]);
-    });
-    it("should handle empty range", () => {
-        const startDate = new Date("2024-07-01T00:00:00Z");
-        const endDate = new Date("2024-07-01T00:00:00Z");
-        const result = getTimeHeaders(startDate, endDate);
-        expect(result).toEqual([]);
-    });
-    it("should handle different time zones correctly", () => {
-        const startDate = new Date("2024-07-01T00:00:00+02:00");
-        const endDate = new Date("2024-07-01T03:00:00+02:00");
-        const result = getTimeHeaders(startDate, endDate);
-        expect(result).toEqual([
-            new Date("2024-07-01T00:00:00+02:00"),
-            new Date("2024-07-01T01:00:00+02:00"),
-            new Date("2024-07-01T02:00:00+02:00")
-        ]);
-    });
-    it("should handle date ranges spanning multiple days", () => {
-        const startDate = new Date("2024-07-01T23:00:00Z");
-        const endDate = new Date("2024-07-02T02:00:00Z");
-        const result = getTimeHeaders(startDate, endDate);
-        expect(result).toEqual([
-            new Date("2024-07-01T23:00:00Z"),
-            new Date("2024-07-02T00:00:00Z"),
-            new Date("2024-07-02T01:00:00Z")
-        ]);
-    });
-});

package/dist/test/components/custom/scheduler/hasSameProperties.test.js

@@ -1,51 +0,0 @@
-import { hasSameProperties } from "../../../../src/components/custom/scheduler/logic/filtering/hasSameProperties";
-import { cblEvent } from "../../../../src/components/custom/scheduler/state/cblEvent";
-describe("hasSameProperties", () => {
-    it("should return true for events with the same properties", () => {
-        const event1 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        const event2 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        expect(hasSameProperties(event1, event2)).toBe(false);
-        // TODO: this test is testing old behavior of scheduler
-        // must be changed to .toBe(true)
-    });
-    it("should return false for events with different resourceId", () => {
-        const event1 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        const event2 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 2, {
-            key: "value"
-        });
-        expect(hasSameProperties(event1, event2)).toBe(false);
-    });
-    it("should return false for events with different start times", () => {
-        const event1 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        const event2 = new cblEvent(new Date("2023-07-01T11:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        expect(hasSameProperties(event1, event2)).toBe(false);
-    });
-    it("should return false for events with different end times", () => {
-        const event1 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        const event2 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T13:00:00Z"), 1, {
-            key: "value"
-        });
-        expect(hasSameProperties(event1, event2)).toBe(false);
-    });
-    it("should return false for events with different data", () => {
-        const event1 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "value"
-        });
-        const event2 = new cblEvent(new Date("2023-07-01T10:00:00Z"), new Date("2023-07-01T12:00:00Z"), 1, {
-            key: "differentValue"
-        });
-        expect(hasSameProperties(event1, event2)).toBe(false);
-    });
-});

package/dist/test/components/custom/scheduler/isAllowedToMove.test.js

@@ -1,28 +0,0 @@
-import { isAllowedToMove } from "../../../../src/components/custom/scheduler/logic/ui/isAllowedToMove";
-import { CblDragAndDrop } from "../../../../src/components/custom/scheduler/state/CblDragAndDrop";
-describe("isAllowedToMove", () => {
-    it("should return true if data.eventType is not 1", () => {
-        const data = { eventType: 0 };
-        const resData = {};
-        const cblDragNDrop = new CblDragAndDrop("", "", null);
-        expect(isAllowedToMove(data, resData, cblDragNDrop)).toBe(true);
-    });
-    it("should return true if the allowed move in crewControll ", () => {
-        const data = { eventType: 1 };
-        const resData = {};
-        const cblDragNDrop = new CblDragAndDrop("acftsScheduler", "flightsPairingsScheduler", null);
-        expect(isAllowedToMove(data, resData, cblDragNDrop)).toBe(true);
-    });
-    it("should return true if the move is not allowed but Crew ids do not match", () => {
-        const data = { eventType: 1, Crew: 1 };
-        const resData = { Crewmember_Id: 2 };
-        const cblDragNDrop = new CblDragAndDrop("", "", null);
-        expect(isAllowedToMove(data, resData, cblDragNDrop)).toBe(true);
-    });
-    it("should return false if the move is not allowed and Crew ids match", () => {
-        const data = { eventType: 1, Crew: 1 };
-        const resData = { Crewmember_Id: 1 };
-        const cblDragNDrop = new CblDragAndDrop("", "", null);
-        expect(isAllowedToMove(data, resData, cblDragNDrop)).toBe(false);
-    });
-});

package/dist/test/components/custom/scheduler/listOfDatesToWeeks.test.js

@@ -1,72 +0,0 @@
-import moment from "moment";
-import { listOfDatesToWeekRangeList } from "../../../../src/components/custom/scheduler/logic/dates/listOfDatesToWeeks";
-describe("listOfDatesToWeeks", () => {
-    test("empty list return empty", () => {
-        expect(listOfDatesToWeekRangeList([])).toStrictEqual([]);
-    });
-    test("1st day of week should return a weekRange of day to day", () => {
-        const start = moment("20240721", "YYYYMMDD").toDate();
-        const expected = [
-            {
-                start: start,
-                end: start,
-                days: 1,
-                isShortWeek: true
-            }
-        ];
-        expect(listOfDatesToWeekRangeList([start])).toStrictEqual(expected);
-    });
-    test("7 day starting on monday should return a weekRange of monday to sunday", () => {
-        const days = [];
-        for (let i = 0; i <= 6; i++) {
-            days.push(moment("20240722").add(i, "days").toDate());
-        }
-        const expected = [
-            {
-                start: days[0],
-                end: days[6],
-                days: 7,
-                isShortWeek: false
-            }
-        ];
-        const actual = listOfDatesToWeekRangeList(days);
-        expect(actual).toStrictEqual(expected);
-    });
-    test("1st day of week + 7 day should return 2 weekRanges", () => {
-        const days = [];
-        for (let i = 0; i <= 6; i++) {
-            days.push(moment("20240721").add(i, "days"));
-        }
-        const expected = [
-            {
-                start: days[0].toDate(),
-                end: days[0].toDate(),
-                isShortWeek: true,
-                days: 1
-            },
-            {
-                start: days[1].toDate(),
-                end: days[6].add(1, "days").toDate(),
-                isShortWeek: false,
-                days: 7
-            }
-        ];
-        const actual = listOfDatesToWeekRangeList(days.map(element => element.toDate()));
-        expect(actual.length).toBe(2);
-        expect(actual).toStrictEqual(expected);
-    });
-    test("start on wednesday should return 1 weekRange of 5 days", () => {
-        const start = moment("20240724");
-        const startDate = start.toDate();
-        const expected = [
-            {
-                start: startDate,
-                end: start.add(4, "days").toDate(),
-                days: 5,
-                isShortWeek: true
-            }
-        ];
-        const actual = listOfDatesToWeekRangeList([startDate]);
-        expect(actual).toStrictEqual(expected);
-    });
-});

package/dist/test/jest.setup.js

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';