ublo-lib 1.31.42 → 1.31.44

package/es/esf/hooks/use-season-products.js

@@ -1,98 +1,102 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as React from "react";
 import getConfig from "next/config";
 const STORAGE_KEY = "forcedSeasonStay";
-const {
-  publicRuntimeConfig
-} = getConfig();
-const {
-  start,
-  end
-} = publicRuntimeConfig.season || {};
+const { publicRuntimeConfig } = getConfig();
+const { start, end } = publicRuntimeConfig.season || {};
 export default function useSeasonProducts(menuPath) {
-  const seasonProductsPage = menuPath?.metadata?.seasonProductsPage;
-  const [startDate, endDate] = [weekToDate(start, end), weekToDate(end, end)];
-  const isEnabled = seasonProductsPage && start !== undefined && end !== undefined;
-  const updateStay = React.useCallback(async () => {
-    const now = new Date();
-    const from = formatDate(now > startDate && now < endDate ? now : startDate);
-    const to = formatDate(endDate);
-    const stay = JSON.stringify({
-      from,
-      to
-    });
-    window.sessionStorage.setItem("stay", stay);
-    window.sessionStorage.setItem(STORAGE_KEY, true);
-  }, [endDate, startDate]);
-  const handleButtonClick = React.useCallback(e => {
-    const button = e.target.closest("[onclick*='openBoutiqueESF']");
-    if (!button) return;
-    e.preventDefault();
-    updateStay();
-    button.click();
-  }, [updateStay]);
-  React.useEffect(() => {
-    if (isEnabled) {
-      if (seasonProductsPage) {
-        document.addEventListener("click", handleButtonClick);
-        return () => {
-          document.removeEventListener("click", handleButtonClick);
-        };
-      } else {
-        const hasForcedStay = window.sessionStorage.getItem(STORAGE_KEY);
-        if (hasForcedStay) {
-          window.sessionStorage.removeItem("stay");
-          window.sessionStorage.removeItem("stayWeek");
-          window.sessionStorage.removeItem(STORAGE_KEY);
+    var _a;
+    const seasonProductsPage = (_a = menuPath === null || menuPath === void 0 ? void 0 : menuPath.metadata) === null || _a === void 0 ? void 0 : _a.seasonProductsPage;
+    const [startDate, endDate] = [weekToDate(start, end), weekToDate(end, end)];
+    const isEnabled = seasonProductsPage && start !== undefined && end !== undefined;
+    const updateStay = React.useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        const now = new Date();
+        const from = formatDate(now > startDate && now < endDate ? now : startDate);
+        const to = formatDate(endDate);
+        const stay = JSON.stringify({ from, to });
+        window.sessionStorage.setItem("stay", stay);
+        window.sessionStorage.setItem(STORAGE_KEY, true);
+    }), [endDate, startDate]);
+    const handleButtonClick = React.useCallback((e) => {
+        const button = e.target.closest("[onclick*='openBoutiqueESF']");
+        if (!button)
+            return;
+        e.preventDefault();
+        updateStay();
+        button.click();
+    }, [updateStay]);
+    React.useEffect(() => {
+        if (isEnabled) {
+            if (seasonProductsPage) {
+                document.addEventListener("click", handleButtonClick);
+                return () => {
+                    document.removeEventListener("click", handleButtonClick);
+                };
+            }
+            else {
+                const hasForcedStay = window.sessionStorage.getItem(STORAGE_KEY);
+                if (hasForcedStay) {
+                    window.sessionStorage.removeItem("stay");
+                    window.sessionStorage.removeItem("stayWeek");
+                    window.sessionStorage.removeItem(STORAGE_KEY);
+                }
+            }
         }
-      }
-    }
-  }, [handleButtonClick, isEnabled, seasonProductsPage]);
+    }, [handleButtonClick, isEnabled, seasonProductsPage]);
 }
 function padStart(value, count, pad) {
-  let str = String(value);
-  while (str.length < count) {
-    str = pad + str;
-  }
-  return str;
+    let str = String(value);
+    while (str.length < count) {
+        str = pad + str;
+    }
+    return str;
 }
 function createDate(...args) {
-  const ref = new Date(...args);
-  const yy = ref.getFullYear();
-  const mm = padStart(ref.getMonth() + 1, 2, 0);
-  const dd = padStart(ref.getDate(), 2, 0);
-  const str = `${yy}-${mm}-${dd}`;
-  return new Date(str);
+    const ref = new Date(...args);
+    const yy = ref.getFullYear();
+    const mm = padStart(ref.getMonth() + 1, 2, 0);
+    const dd = padStart(ref.getDate(), 2, 0);
+    const str = `${yy}-${mm}-${dd}`;
+    return new Date(str);
 }
 function getPrevSaturday(date) {
-  const clone = createDate(date);
-  const day = 1 + clone.getDay();
-  const prevSaturday = clone.getDate() - day % 7;
-  clone.setDate(prevSaturday);
-  return clone;
+    const clone = createDate(date);
+    const day = 1 + clone.getDay();
+    const prevSaturday = clone.getDate() - (day % 7);
+    clone.setDate(prevSaturday);
+    return clone;
 }
 function addDays(date, days) {
-  const clone = createDate(date);
-  clone.setDate(clone.getDate() + days);
-  return clone;
+    const clone = createDate(date);
+    clone.setDate(clone.getDate() + days);
+    return clone;
 }
 function christmasWeek(endWeek) {
-  const now = createDate();
-  const year = now.getFullYear();
-  const month = now.getMonth();
-  const date = now.getDate();
-  const isAfterChristmas = month === 11 && date >= 25;
-  const lastChristmasYear = isAfterChristmas ? year : year - 1;
-  const lastChristmas = createDate(lastChristmasYear, 11, 25);
-  const nextChristmas = createDate(lastChristmasYear + 1, 11, 25);
-  const dateSeasonEnd = addDays(getPrevSaturday(lastChristmas), endWeek * 7);
-  return getPrevSaturday(now <= dateSeasonEnd ? lastChristmas : nextChristmas);
+    const now = createDate();
+    const year = now.getFullYear();
+    const month = now.getMonth();
+    const date = now.getDate();
+    const isAfterChristmas = month === 11 && date >= 25;
+    const lastChristmasYear = isAfterChristmas ? year : year - 1;
+    const lastChristmas = createDate(lastChristmasYear, 11, 25);
+    const nextChristmas = createDate(lastChristmasYear + 1, 11, 25);
+    const dateSeasonEnd = addDays(getPrevSaturday(lastChristmas), endWeek * 7);
+    return getPrevSaturday(now <= dateSeasonEnd ? lastChristmas : nextChristmas);
 }
 function weekToDate(week, endWeek) {
-  return addDays(christmasWeek(endWeek), week * 7);
+    return addDays(christmasWeek(endWeek), week * 7);
 }
 function formatDate(date) {
-  const dd = padStart(date.getDate(), 2, 0);
-  const mm = padStart(date.getMonth() + 1, 2, 0);
-  const yy = date.getFullYear();
-  return `${yy}-${mm}-${dd}`;
-}
+    const dd = padStart(date.getDate(), 2, 0);
+    const mm = padStart(date.getMonth() + 1, 2, 0);
+    const yy = date.getFullYear();
+    return `${yy}-${mm}-${dd}`;
+}

package/es/future/components/msem/index.d.ts

@@ -0,0 +1,3 @@
+import { Script } from "./script";
+import Tunnel from "./tunnel";
+export { Script, Tunnel };

package/es/future/components/msem/index.js

@@ -1,3 +1,3 @@
 import { Script } from "./script";
 import Tunnel from "./tunnel";
-export { Script, Tunnel };
+export { Script, Tunnel };

package/es/future/components/msem/script.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+type ScriptProps = {
+    msemUrl: string;
+};
+export declare function Script({ msemUrl }: ScriptProps): import("react").JSX.Element;
+export {};

package/es/future/components/msem/script.jsx

@@ -0,0 +1,7 @@
+import NextScript from "next/script";
+export function Script({ msemUrl }) {
+    const setLoaded = () => {
+        window.MseMLoaded = true;
+    };
+    return (<NextScript src={`${msemUrl}/static/js/widget-msem.js`} onLoad={setLoaded} defer/>);
+}

package/es/future/components/msem/tunnel.d.ts

@@ -0,0 +1,41 @@
+import * as React from "react";
+import type { GlobalOptions } from "./types";
+type Show = "cart" | "offers" | "stay";
+type Options = GlobalOptions & {
+    esfUrl?: string;
+    skiPassUrl?: string;
+    lodgingUrl?: string;
+    activitiesUrl?: string;
+    wellnessUrl?: string;
+    skiRentalUrl?: string;
+    privateTransferUrl?: string;
+    shuttleUrl?: string;
+    excursionUrl?: string;
+    parkingUrl?: string;
+    textileUrl?: string;
+    daycareUrl?: string;
+    skiSchoolUrl?: string;
+    customOffers?: string;
+    cartExpanded?: boolean;
+    show?: Show[];
+};
+type Presets = {
+    lodging?: {
+        name: string;
+        position: [number, number];
+        address: string;
+    };
+    stay?: {
+        from: string;
+        to: string;
+    };
+    filter?: string;
+};
+type Props = {
+    options?: Options;
+    presets?: Presets;
+    children?: React.ReactNode;
+};
+declare const _default: React.MemoExoticComponent<typeof Tunnel>;
+export default _default;
+declare function Tunnel({ options, presets, children }: Props): React.ReactNode;

package/es/future/components/msem/tunnel.jsx

@@ -0,0 +1,18 @@
+import * as React from "react";
+import * as Utils from "./utils";
+import * as Plausible from "../plausible";
+export default React.memo(Tunnel);
+function Tunnel({ options, presets, children }) {
+    React.useEffect(() => {
+        const lang = (options === null || options === void 0 ? void 0 : options.lang) === "fr" ? "fr" : "en";
+        const categoryCode = window.sessionStorage.getItem("categoryCode") || undefined;
+        const patchedOptions = Object.assign(Object.assign({}, options), { lang,
+            categoryCode, analytics: (...args) => {
+                var _a;
+                (_a = options === null || options === void 0 ? void 0 : options.analytics) === null || _a === void 0 ? void 0 : _a.apply(null, args);
+                Plausible.callback.apply(null, args);
+            } });
+        Utils.loadWidget("tunnel", patchedOptions, presets);
+    }, [options, presets]);
+    return children;
+}

package/es/future/components/msem/types.d.ts

@@ -0,0 +1,15 @@
+export type GlobalOptions = {
+    resort: number;
+    channel: string;
+    lang: string;
+    preview?: boolean;
+    skipRecap?: true;
+    noTitlebar?: true;
+    noMarketing?: true;
+    draggable?: boolean;
+    verticalMargin?: number;
+    maxWidth: number;
+    groundedTo?: string;
+    fullWidth: boolean;
+    analytics?: () => void;
+};

package/es/future/components/msem/types.js

@@ -1 +1 @@
-export {};
+export {};

package/es/future/components/msem/utils.d.ts

@@ -0,0 +1,3 @@
+type Widget = "tunnel" | "lodging" | "esf" | "skiRental" | "skiPass" | "liftJb" | "transfer" | "shuttle" | "excursion" | "otherProducts" | "genericLine" | "esfCustom" | "vakario" | "elloha" | "widgetPackage" | "customerAccount";
+export declare function loadWidget(widget: Widget, options?: {}, presets?: {}): void;
+export {};

package/es/future/components/msem/utils.js

@@ -1,21 +1,20 @@
 export function loadWidget(widget, options = {}, presets = {}) {
-  const isGroundedTo = ("groundedTo" in options);
-  if (window.MseMLoaded) {
-    window.MseM?.onLoad(() => {
-      if (isGroundedTo) {
-        const container = document.querySelector(options.groundedTo);
-        container.innerHTML = "";
-      }
-      window.MseM[widget](options, presets);
-    });
-  } else {
-    setTimeout(() => {
-      if (isGroundedTo) {
-        const selector = options.groundedTo;
-        const widgetStillHasTarget = document.querySelector(selector);
-        if (!widgetStillHasTarget) return;
-      }
-      loadWidget(widget, options, presets);
-    }, 200);
-  }
-}
+    var _a;
+    const isGroundedTo = "groundedTo" in options;
+    if (window.MseMLoaded) {
+        (_a = window.MseM) === null || _a === void 0 ? void 0 : _a.onLoad(() => {
+            window.MseM[widget](options, presets);
+        });
+    }
+    else {
+        setTimeout(() => {
+            if (isGroundedTo) {
+                const selector = options.groundedTo;
+                const widgetStillHasTarget = document.querySelector(selector);
+                if (!widgetStillHasTarget)
+                    return;
+            }
+            loadWidget(widget, options, presets);
+        }, 200);
+    }
+}

package/es/future/components/plausible/hooks/use-plausible.d.ts

@@ -0,0 +1,11 @@
+type Revenue = {
+    currency: string;
+    amount: number;
+};
+export default function useGoal(goal: string, props: Record<string, any>, revenue?: Revenue, overridenDomain?: string): void;
+declare global {
+    interface Window {
+        plausible: any;
+    }
+}
+export {};

package/es/future/components/plausible/hooks/use-plausible.js

@@ -2,28 +2,24 @@ import * as React from "react";
 import getConfig from "next/config";
 import load from "../services/load";
 import sendGoal from "../services/send-goal";
-const {
-  publicRuntimeConfig
-} = getConfig();
-const {
-  plausibleDomain
-} = publicRuntimeConfig;
+const { publicRuntimeConfig } = getConfig();
+const { plausibleDomain } = publicRuntimeConfig;
 export default function useGoal(goal, props, revenue, overridenDomain) {
-  const [loaded] = usePlausible(overridenDomain);
-  React.useEffect(() => {
-    if (!loaded || !window.plausible) return;
-    const defaultProps = {
-      path: document.location.pathname
-    };
-    sendGoal(goal, props || defaultProps, revenue);
-  }, [goal, loaded, props]);
+    const [loaded] = usePlausible(overridenDomain);
+    React.useEffect(() => {
+        if (!loaded || !window.plausible)
+            return;
+        const defaultProps = { path: document.location.pathname };
+        sendGoal(goal, props || defaultProps, revenue);
+    }, [goal, loaded, props]);
 }
 function usePlausible(overridenDomain) {
-  const [loaded, setLoaded] = React.useState(false);
-  React.useEffect(() => {
-    if (!overridenDomain && !plausibleDomain) return;
-    load();
-    setLoaded(true);
-  }, [overridenDomain]);
-  return [loaded, setLoaded];
-}
+    const [loaded, setLoaded] = React.useState(false);
+    React.useEffect(() => {
+        if (!overridenDomain && !plausibleDomain)
+            return;
+        load();
+        setLoaded(true);
+    }, [overridenDomain]);
+    return [loaded, setLoaded];
+}

package/es/future/components/plausible/index.d.ts

@@ -0,0 +1,7 @@
+import Script from "./plausible";
+import * as Callback from "./services/callback";
+declare const callback: typeof Callback.MseM;
+export { default as load } from "./services/load";
+export { default as sendGoal } from "./services/send-goal";
+export { default as useGoal } from "./hooks/use-plausible";
+export { callback, Script };

package/es/future/components/plausible/index.js

@@ -4,4 +4,4 @@ const callback = Callback.MseM;
 export { default as load } from "./services/load";
 export { default as sendGoal } from "./services/send-goal";
 export { default as useGoal } from "./hooks/use-plausible";
-export { callback, Script };
+export { callback, Script };

package/es/future/components/plausible/plausible.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+type Props = {
+    lang?: string;
+    source?: string;
+};
+export default function PlausibleScript({ lang, source, }: Props): React.JSX.Element;
+export {};

package/es/future/components/plausible/plausible.jsx

@@ -0,0 +1,17 @@
+import * as React from "react";
+import Script from "next/script";
+import getConfig from "next/config";
+const { publicRuntimeConfig } = getConfig();
+const { plausibleDomain } = publicRuntimeConfig;
+const DEFAULT_SOURCE = "https://plausible.io/js/script.revenue.file-downloads.outbound-links.js";
+export default function PlausibleScript({ lang, source = DEFAULT_SOURCE, }) {
+    const hasI18n = typeof plausibleDomain === "object";
+    if (hasI18n && !lang) {
+        // eslint-disable-next-line no-console
+        console.warn("PlausibleScript: the lang props is mandatory if you want to use a specific domain for each lang");
+    }
+    const domain = hasI18n && lang ? plausibleDomain[lang] : plausibleDomain;
+    if (!domain)
+        return null;
+    return <Script data-domain={domain} src={source}/>;
+}

package/es/future/components/plausible/services/callback.d.ts

@@ -0,0 +1,23 @@
+type Item = {
+    gtmData: {
+        item_name: string;
+        item_brand: string;
+        item_category: string;
+        item_category2: string;
+        item_category3: string;
+        item_variant: string;
+        price: number;
+        quantity: number;
+    };
+};
+type Props = {
+    event: string;
+    payment_type?: string;
+    execcode?: string;
+    items?: Item[];
+    orderId?: string;
+    cartId?: string;
+    currency?: string;
+};
+export declare function MseM({ event, payment_type: paymentType, execcode, items, orderId, cartId, currency, }: Props): void;
+export {};