ublo-lib 1.44.14 → 1.44.16

package/es/common/components/date-picker/calendar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/calendar.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;4CAqQC"}
+{"version":3,"file":"calendar.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/calendar.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;4CAwQC"}

package/es/common/components/date-picker/calendar.js

@@ -12,7 +12,7 @@ import * as Data from "./data";
 import * as Utils from "./utils";
 import styles from "./calendar.module.css";
 export default function Calendar({ display, stayDates = [], min, max, onSubmit, availabilities, close, singleDate, submitOnSelectionEnd, disableConfirmModal, defaultSelecting, }) {
-    const date = min ? new Date(min) : new Date();
+    const date = min ? Utils.createGMTDate(min) : Utils.createGMTDate();
     const { lang } = useUbloContext();
     const [selectedDates, setSelectedDates] = React.useState(stayDates);
     const firstRangeDate = selectedDates[0];
@@ -71,7 +71,7 @@ export default function Calendar({ display, stayDates = [], min, max, onSubmit,
             setMonthAlt(month + 1);
         }
     }, [month, year]);
-    const now = new Date();
+    const now = Utils.createGMTDate();
     const currentMonth = now.getMonth() + 1;
     const currentYear = now.getFullYear();
     const isPast = month <= currentMonth && year <= currentYear;
@@ -97,7 +97,10 @@ export default function Calendar({ display, stayDates = [], min, max, onSubmit,
                     const { stays } = await fetcher({ ...rest, start, numberDays });
                     if (stays?.length) {
                         const formattedStays = stays.map((stay) => {
-                            return { start: new Date(stay.start), end: new Date(stay.end) };
+                            return {
+                                start: Utils.createGMTDate(stay.start),
+                                end: Utils.createGMTDate(stay.end),
+                            };
                         });
                         setStays(formattedStays);
                     }

package/es/common/components/date-picker/data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/data.js"],"names":[],"mappings":";;;;;;;;;;;AAaA,+BAAkD;AAElD,gCAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HpD,6BAA8B,CAAC,CAAC;AAEzB,kEAyCN"}
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/data.js"],"names":[],"mappings":";;;;;;;;;;;AAaA,+BAA6D;AAE7D,gCAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2H/D,6BAA8B,CAAC,CAAC;AAEzB,kEAyCN"}

package/es/common/components/date-picker/data.js

@@ -8,8 +8,8 @@ export const BREAKPOINTS = {
     TABLET: 745,
     PHONE: 650,
 };
-export const THIS_YEAR = new Date().getFullYear();
-export const THIS_MONTH = new Date().getMonth() + 1;
+export const THIS_YEAR = Utils.createGMTDate().getFullYear();
+export const THIS_MONTH = Utils.createGMTDate().getMonth() + 1;
 export const MONTHS = {
     fr: {
         january: "Janvier",

package/es/common/components/date-picker/date-item.js

@@ -9,11 +9,11 @@ import * as Messages from "./messages";
 import styles from "./date-item.module.css";
 export default function DateItem({ date, index, month, year, min, max, selectedDates, setSelectedDates, setFirstSelectedDate, setLastSelectedDate, selecting, setSelecting, singleDate, submitOnSelectionEnd, onSubmit, stays, matchingStays, allMatchingStaysEnd, }) {
     const { lang } = useUbloContext();
-    const today = new Date();
-    const _date = React.useMemo(() => new Date(date), [date]);
+    const today = Utils.createGMTDate();
+    const _date = React.useMemo(() => Utils.createGMTDate(date), [date]);
     _date.setHours(0, 0, 0, 0);
     const isToday = Utils.isSameDay(_date, today);
-    const monthReference = new Date(`${Utils.zeroPad(year, 2)}-${Utils.zeroPad(month, 2)}-02`);
+    const monthReference = Utils.createGMTDate(`${Utils.zeroPad(year, 2)}-${Utils.zeroPad(month, 2)}-02`);
     const isInMonth = month && year && Utils.isSameMonth(_date, monthReference);
     const isInPastMonth = Utils.isInPastMonth(_date, monthReference);
     const isInNextMonth = Utils.isInNextMonth(_date, monthReference);
@@ -35,8 +35,8 @@ export default function DateItem({ date, index, month, year, min, max, selectedD
     }) || false;
     const shortestMatchingStaysLength = enableAvailability &&
         matchingStays?.reduce((acc, stay) => {
-            const fromDate = new Date(stay.start);
-            const toDate = new Date(stay.end);
+            const fromDate = Utils.createGMTDate(stay.start);
+            const toDate = Utils.createGMTDate(stay.end);
             const days = Utils.getDateInterval(fromDate, toDate);
             const nights = days.length - 1;
             if (nights < acc) {

package/es/common/components/date-picker/utils.d.ts

@@ -1,5 +1,4 @@
-export function addDays(_date: any, days: any): Date;
-export function getMatchingStays(stays: any, selectedDates: any): any;
+export function createGMTDate(fromDate: any): Date;
 export function zeroPad(value: any, length: any): string;
 export function getMonthDays(month?: number, year?: number): 30 | 29 | 28 | 31;
 export function getMonthFirstDay(month?: number, year?: number): number;
@@ -13,6 +12,7 @@ export function isInNextMonth(date: any, basedate?: Date): boolean;
 export function isPast(date: any): boolean;
 export function isBefore(date: any, ref: any): boolean;
 export function isAfter(date: any, ref: any): boolean;
+export function addDays(_date: any, days: any): Date;
 export function getDateInterval(startDate: any, endDate: any): any[];
 export function getDateISO(date?: Date): string;
 export function getQueryDateInterval(firstDate: any, nights: any): any[];
@@ -24,4 +24,5 @@ export function getNextMonth(month: any, year: any): {
     month: any;
     year: any;
 };
+export function getMatchingStays(stays: any, selectedDates: any): any;
 //# sourceMappingURL=utils.d.ts.map

package/es/common/components/date-picker/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/utils.js"],"names":[],"mappings":"AAwJA,qDAIC;AAkDD,sEAQC;AApNM,yDAAmE;AAEnE,+EAcN;AAEM,wEAON;AAEM,kDAON;AAEM,8CAON;AAEM,2CAKN;AAEM,iEAaN;AAEM,+DAmBN;AAEM,mEAgBN;AAEM,mEAgBN;AAEM,2CAMN;AAEM,uDAON;AAEM,sDAON;AAQM,qEAQN;AAEM,gDAON;AAEM,yEAaN;AAEM;;;EAKN;AAEM;;;EAKN"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/common/components/date-picker/utils.js"],"names":[],"mappings":"AAEA,mDAiBC;AAED,yDAEC;AAED,+EAWC;AAED,wEAOC;AAED,kDAOC;AAED,8CAOC;AAED,2CAKC;AAED,iEAaC;AAED,+DAmBC;AAED,mEAgBC;AAED,mEAgBC;AAED,2CAKC;AAED,uDAKC;AAED,sDAKC;AAED,qDAIC;AAED,qEAQC;AAED,gDAOC;AAED,yEAaC;AAED;;;EAKC;AAED;;;EAKC;AAED,sEAQC"}

package/es/common/components/date-picker/utils.js

@@ -1,6 +1,24 @@
 import * as Data from "./data";
-export const zeroPad = (value, length) => `${value}`.padStart(length, "0");
-export const getMonthDays = (month = Data.THIS_MONTH, year = Data.THIS_YEAR) => {
+export function createGMTDate(fromDate) {
+    const date = fromDate ? new Date(fromDate) : new Date();
+    const day = date.getDate();
+    const month = date.getMonth();
+    const year = date.getFullYear();
+    date.setMinutes(date.getMinutes() + date.getTimezoneOffset());
+    date.setHours(0);
+    const newDay = date.getDate();
+    const newMonth = date.getMonth();
+    const newYear = date.getFullYear();
+    if (date.getTimezoneOffset() < 0 &&
+        (newDay < day || newMonth < month || newYear < year)) {
+        date.setDate(date.getDate() + 1);
+    }
+    return date;
+}
+export function zeroPad(value, length) {
+    return `${value}`.padStart(length, "0");
+}
+export function getMonthDays(month = Data.THIS_MONTH, year = Data.THIS_YEAR) {
     const months30 = [4, 6, 9, 11];
     const leapYear = year % 4 === 0;
     return month === 2
@@ -10,34 +28,34 @@ export const getMonthDays = (month = Data.THIS_MONTH, year = Data.THIS_YEAR) =>
         : months30.includes(month)
             ? 30
             : 31;
-};
-export const getMonthFirstDay = (month = Data.THIS_MONTH, year = Data.THIS_YEAR) => {
-    const date = new Date(`${year}-${zeroPad(month, 2)}-01`);
+}
+export function getMonthFirstDay(month = Data.THIS_MONTH, year = Data.THIS_YEAR) {
+    const date = createGMTDate(`${year}-${zeroPad(month, 2)}-01`);
     date.setHours(0, 0, 0, 0);
     return date.getDay();
-};
-export const weekToLongDate = (date) => {
-    const _date = new Date(date);
+}
+export function weekToLongDate(date) {
+    const _date = createGMTDate(date);
     _date.setHours(0, 0, 0, 0);
     const dd = zeroPad(_date.getDate(), 2);
     const mm = zeroPad(_date.getMonth() + 1, 2);
     const yy = _date.getFullYear();
     return `${dd}/${mm}/${yy}`;
-};
-export const formatDate = (date) => {
-    const d = new Date(date);
+}
+export function formatDate(date) {
+    const d = createGMTDate(date);
     d.setHours(0, 0, 0, 0);
     const day = zeroPad(d.getDate(), 2);
     const month = zeroPad(d.getMonth() + 1, 2);
     const year = d.getFullYear();
     return `${year}-${month}-${day}`;
-};
-export const isDate = (date) => {
+}
+export function isDate(date) {
     const isDate = Object.prototype.toString.call(date) === "[object Date]";
     const isValidDate = date && !Number.isNaN(date.valueOf());
     return isDate && isValidDate;
-};
-export const isSameMonth = (date, basedate = new Date()) => {
+}
+export function isSameMonth(date, basedate = createGMTDate()) {
     if (!(isDate(date) && isDate(basedate)))
         return false;
     date.setHours(0, 0, 0, 0);
@@ -47,8 +65,8 @@ export const isSameMonth = (date, basedate = new Date()) => {
     const dateMonth = date.getMonth() + 1;
     const dateYear = date.getFullYear();
     return basedateMonth === dateMonth && basedateYear === dateYear;
-};
-export const isSameDay = (date, basedate = new Date()) => {
+}
+export function isSameDay(date, basedate = createGMTDate()) {
     if (!(isDate(date) && isDate(basedate)))
         return false;
     date.setHours(0, 0, 0, 0);
@@ -62,8 +80,8 @@ export const isSameDay = (date, basedate = new Date()) => {
     return (basedateDate === dateDate &&
         basedateMonth === dateMonth &&
         basedateYear === dateYear);
-};
-export const isInPastMonth = (date, basedate = new Date()) => {
+}
+export function isInPastMonth(date, basedate = createGMTDate()) {
     if (!(isDate(date) && isDate(basedate)))
         return false;
     date.setHours(0, 0, 0, 0);
@@ -77,8 +95,8 @@ export const isInPastMonth = (date, basedate = new Date()) => {
     if (basedateYear > dateYear)
         return true;
     return basedateMonth > dateMonth;
-};
-export const isInNextMonth = (date, basedate = new Date()) => {
+}
+export function isInNextMonth(date, basedate = createGMTDate()) {
     if (!(isDate(date) && isDate(basedate)))
         return false;
     date.setHours(0, 0, 0, 0);
@@ -92,38 +110,33 @@ export const isInNextMonth = (date, basedate = new Date()) => {
     if (basedateYear < dateYear)
         return true;
     return basedateMonth < dateMonth;
-};
-export const isPast = (date) => {
-    const d = Array.isArray(date) ? date.join("-") : date;
-    const _date = new Date(d);
-    const now = new Date();
+}
+export function isPast(date) {
+    const _date = createGMTDate(date);
+    const now = createGMTDate();
     now.setHours(0, 0, 0, 0);
     return _date < now;
-};
-export const isBefore = (date, ref) => {
+}
+export function isBefore(date, ref) {
     if (!date || !ref)
         return false;
-    const d = Array.isArray(date) ? date.join("-") : date;
-    const r = Array.isArray(ref) ? ref.join("-") : ref;
-    const _date = new Date(d);
-    const _ref = new Date(r);
+    const _date = createGMTDate(date);
+    const _ref = createGMTDate(ref);
     return _date < _ref;
-};
-export const isAfter = (date, ref) => {
+}
+export function isAfter(date, ref) {
     if (!date || !ref)
         return false;
-    const d = Array.isArray(date) ? date.join("-") : date;
-    const r = Array.isArray(ref) ? ref.join("-") : ref;
-    const _date = new Date(d);
-    const _ref = new Date(r);
+    const _date = createGMTDate(date);
+    const _ref = createGMTDate(ref);
     return _date > _ref;
-};
+}
 export function addDays(_date, days) {
-    const date = new Date(_date);
+    const date = createGMTDate(_date);
     date.setDate(date.getDate() + days);
     return date;
 }
-export const getDateInterval = (startDate, endDate) => {
+export function getDateInterval(startDate, endDate) {
     const dates = [];
     let currentDate = startDate;
     while (currentDate <= endDate) {
@@ -131,35 +144,35 @@ export const getDateInterval = (startDate, endDate) => {
         currentDate = addDays(currentDate, 1);
     }
     return dates;
-};
-export const getDateISO = (date = new Date()) => {
+}
+export function getDateISO(date = createGMTDate()) {
     if (!isDate(date))
         return null;
     return `${date.getFullYear()}-${zeroPad(date.getMonth() + 1, 2)}-${zeroPad(date.getDate(), 2)}`;
-};
-export const getQueryDateInterval = (firstDate, nights) => {
+}
+export function getQueryDateInterval(firstDate, nights) {
     const splittedDate = [
         firstDate.slice(0, 4),
         firstDate.slice(4, 6),
         firstDate.slice(6, 8),
     ];
-    const from = new Date(splittedDate.join("-"));
+    const from = createGMTDate(splittedDate.join("-"));
     from.setHours(0, 0, 0, 0);
-    const to = new Date(from);
+    const to = createGMTDate(from);
     to.setDate(to.getDate() + parseInt(nights));
     const interval = getDateInterval(from, to);
     return interval;
-};
-export const getPreviousMonth = (month, year) => {
+}
+export function getPreviousMonth(month, year) {
     const prevMonth = month > 1 ? month - 1 : 12;
     const prevMonthYear = month > 1 ? year : year - 1;
     return { month: prevMonth, year: prevMonthYear };
-};
-export const getNextMonth = (month, year) => {
+}
+export function getNextMonth(month, year) {
     const nextMonth = month < 12 ? month + 1 : 1;
     const nextMonthYear = month < 12 ? year : year + 1;
     return { month: nextMonth, year: nextMonthYear };
-};
+}
 export function getMatchingStays(stays, selectedDates) {
     if (!stays?.length || !selectedDates.length)
         return;

package/es/common/hooks/use-injected-cms-markup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-injected-cms-markup.d.ts","sourceRoot":"","sources":["../../../src/common/hooks/use-injected-cms-markup.js"],"names":[],"mappings":";AAaA,wEA+BC"}
+{"version":3,"file":"use-injected-cms-markup.d.ts","sourceRoot":"","sources":["../../../src/common/hooks/use-injected-cms-markup.js"],"names":[],"mappings":";AAaA,wEAqCC"}

package/es/common/hooks/use-injected-cms-markup.js

@@ -12,28 +12,32 @@ const findAllByKey = (obj, keyToFind) => {
 const useInjectedCmsMarkup = (entries, isReady) => {
     const { cmsMode } = useUbloContext();
     const injectCmsMarkup = React.useCallback(async () => {
-        await window.Cms.register();
-        const formats = window.Cms.sectionClasses;
-        entries.forEach((entry) => {
-            const { key, value } = entry;
-            const isArray = Array.isArray(value);
-            const targets = findAllByKey(formats, key);
-            targets.forEach((target) => {
-                if (!target?.markup)
-                    return;
-                if (isArray) {
-                    const formattedRows = value.map((v) => {
-                        return { name: v, markup: `<tr><td>${v}</td></tr>` };
-                    });
-                    const [anchor] = target.markup;
-                    target.markup = anchor ? [anchor, ...formattedRows] : formattedRows;
-                }
-                else {
-                    target.markup = value;
-                }
+        window.requestAnimationFrame(() => window.requestAnimationFrame(async () => {
+            await window.Cms.register();
+            const formats = window.Cms.sectionClasses;
+            entries.forEach((entry) => {
+                const { key, value } = entry;
+                const isArray = Array.isArray(value);
+                const targets = findAllByKey(formats, key);
+                targets.forEach((target) => {
+                    if (!target?.markup)
+                        return;
+                    if (isArray) {
+                        const formattedRows = value.map((v) => {
+                            return { name: v, markup: `<tr><td>${v}</td></tr>` };
+                        });
+                        const [anchor] = target.markup;
+                        target.markup = anchor
+                            ? [anchor, ...formattedRows]
+                            : formattedRows;
+                    }
+                    else {
+                        target.markup = value;
+                    }
+                });
             });
-        });
-        await window.Cms.analyse();
+            await window.Cms.analyse();
+        }));
     }, [entries]);
     React.useEffect(() => {
         if (isReady && cmsMode === "connected") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ublo-lib",
-  "version": "1.44.14",
+  "version": "1.44.16",
   "peerDependencies": {
     "classnames": "^2.5.1",
     "dt-design-system": "^3.12.0",