@cwellt_software/cwellt-reactjs-lib 1.2.13 → 1.2.14

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

@@ -0,0 +1,48 @@
+import { getWeeksByDays } from "../../../../../../src/components/custom/scheduler-new/presentation/logic/getDefaultDivisions";
+describe("getWeeksByDays", () => {
+    test("should return empty list if 0 days", () => {
+        expect(getWeeksByDays(0, new Date("2024-10-13"))).toStrictEqual([]);
+    });
+    test("should return empty list if negative days", () => {
+        expect(getWeeksByDays(-20, new Date("2024-10-13"))).toStrictEqual([]);
+    });
+    test("if 1 day should return 1 WeekRange", () => {
+        const weekRanges = getWeeksByDays(1, new Date("2024-10-13"));
+        expect(weekRanges.length).toBe(1);
+    });
+    test("if 2 days should return 2 days in same weekRange ", () => {
+        const weekRanges = getWeeksByDays(2, new Date("2024-10-14"));
+        const first = weekRanges[0];
+        expect(first.days).toBe(2);
+    });
+    test("if 2 days first sunday should return 2 weekRanges", () => {
+        const weekRanges = getWeeksByDays(2, new Date("2024-10-13"));
+        expect(weekRanges.length).toBe(2);
+        const first = weekRanges[0];
+        expect(first.days).toBe(1);
+    });
+    test("when first day is monday and 8 days first should return 7 days", () => {
+        const weekRanges = getWeeksByDays(8, new Date("2024-09-02"));
+        const first = weekRanges[0];
+        expect(first.days).toBe(7);
+    });
+    test("When first day is sunday first should return 1 day", () => {
+        const weekRanges = getWeeksByDays(2, new Date("2024-09-01"));
+        const first = weekRanges[0];
+        expect(first.days).toBe(1);
+    });
+    test("When last day is monday last should return 1 day", () => {
+        const weekRanges = getWeeksByDays(2, new Date("2024-09-08"));
+        const last = weekRanges[weekRanges.length - 1];
+        expect(weekRanges.length).toBe(2);
+        expect(last.days).toBe(1);
+    });
+    test("when 29 days and stars sunday should return 5 weeks ", () => {
+        const weekRanges = getWeeksByDays(29, new Date("2024-09-01"));
+        const last = weekRanges[weekRanges.length - 1];
+        const first = weekRanges[0];
+        expect(weekRanges.length).toBe(5);
+        expect(last.days).toBe(7);
+        expect(first.days).toBe(1);
+    });
+});

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

@@ -0,0 +1,15 @@
+import { hoursBetween } from "../../../../../../src/components/custom/scheduler-new/presentation/logic/getEventSizes";
+describe("hoursbetween", () => {
+    test("from hour to 1 more expect 1", () => {
+        const hours = hoursBetween(new Date("2024-10-14"), new Date("2024-10-14T01:00:00.000Z"));
+        expect(hours).toBe(1);
+    });
+    test("from hour to 30m more expect 0.5", () => {
+        const hours = hoursBetween(new Date("2024-10-14"), new Date("2024-10-14T00:30:00.000Z"));
+        expect(hours).toBe(0.5);
+    });
+    test("from hour to 30m more expect 0.5", () => {
+        const hours = hoursBetween(new Date("2024-10-14"), new Date("2024-10-13T23:30:00.000Z"));
+        expect(hours).toBe(-0.5);
+    });
+});

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,72 @@
+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

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

package/dist/test/vitest.setup.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom/vitest';
+//# sourceMappingURL=vitest.setup.d.ts.map

package/dist/test/vitest.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.setup.d.ts","sourceRoot":"","sources":["../../test/vitest.setup.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC"}