@coras-io/embed 0.1.0

package/dist/contexts/events.context.d.ts

@@ -0,0 +1,33 @@
+import { BasePageState, BasePageStateInput } from "./types.js";
+import { LandingPageParamsInput, DetailsPageParamsInput, SearchPageParamsInput, HelpPageParamsInput } from "../core/pages.js";
+/**
+ * All possible page-specific fields that can be passed to dispatchPageUpdate.
+ * This is a flat intersection of all page input types (all fields optional).
+ */
+type AllPageSpecificFields = LandingPageParamsInput & DetailsPageParamsInput & SearchPageParamsInput & HelpPageParamsInput;
+/**
+ * Input type for dispatchPageUpdate - all fields optional since
+ * the mixin fills in defaults (page, currency, locale).
+ */
+export type PageDispatchInput = BasePageStateInput & AllPageSpecificFields;
+/**
+ * Output type for the page-dispatch Lit context callback payload that child
+ * components pass to the parent. Base fields (page, currency, locale) are
+ * always present.
+ *
+ * Page-specific fields depend on `page`:
+ * - `page: "landing"` → country, city, startDate, endDate, sort, duration, price, categories
+ * - `page: "details"` → id, date
+ * - `page: "search"` → search
+ * - `page: "help"` → content, href, text
+ * - `page: "payment"` → (no extra fields)
+ *
+ * This is a flat intersection (all fields visible) rather than a discriminated
+ * union for consumer ergonomics — callers can access any field without narrowing
+ * on `page` first. Only the fields matching the current page carry meaningful values.
+ */
+export type PageDispatchPayload = BasePageState & AllPageSpecificFields;
+export declare const pageDispatchContext: {
+    __context__: (params: PageDispatchInput) => void;
+};
+export {};

package/dist/contexts/events.context.js

@@ -0,0 +1,2 @@
+import { createContext } from "@lit/context";
+export const pageDispatchContext = createContext("coras-page-dispatch");

package/dist/contexts/pages.context.d.ts

@@ -0,0 +1,25 @@
+export type LandingPageProps = {
+    startDate: string;
+    endDate: string;
+    country: string;
+    city: string;
+    sortBy: string;
+    categories: string;
+    duration: string;
+    price: string;
+};
+export type DetailsPageProps = {
+    date: string;
+    attractionId: string;
+};
+export type HelpPageProps = {
+    tab: string;
+};
+export type PaymentPageProps = object;
+export type SuggestionWidgetProps = {
+    page: string;
+    id: string;
+    country: string;
+    city: string;
+};
+export type PageProps = LandingPageProps | DetailsPageProps | HelpPageProps | PaymentPageProps | SuggestionWidgetProps;

package/dist/contexts/pages.context.js

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

package/dist/contexts/properties.context.d.ts

@@ -0,0 +1,24 @@
+export declare const localesContext: {
+    __context__: ("en-GB" | "da-DK" | "de-DE" | "en-IE" | "en-US" | "es-ES" | "fr-FR" | "fr-MA" | "is-IS" | "it-IT" | "ms-MY" | "nb-NO" | "pl-PL" | "pt-PT" | "sv-SE" | "th-TH" | "tr-TR" | "zh-CN")[];
+};
+export declare const localeContext: {
+    __context__: "en-GB" | "da-DK" | "de-DE" | "en-IE" | "en-US" | "es-ES" | "fr-FR" | "fr-MA" | "is-IS" | "it-IT" | "ms-MY" | "nb-NO" | "pl-PL" | "pt-PT" | "sv-SE" | "th-TH" | "tr-TR" | "zh-CN";
+};
+export declare const currencyContext: {
+    __context__: "AED" | "ALL" | "AUD" | "CAD" | "CHF" | "CNY" | "DKK" | "EUR" | "GBP" | "HRK" | "HUF" | "IDR" | "ISK" | "JPY" | "MAD" | "MYR" | "NOK" | "PHP" | "PLN" | "SEK" | "SGD" | "THB" | "TRY" | "USD" | "VND";
+};
+export declare const currenciesContext: {
+    __context__: ("AED" | "ALL" | "AUD" | "CAD" | "CHF" | "CNY" | "DKK" | "EUR" | "GBP" | "HRK" | "HUF" | "IDR" | "ISK" | "JPY" | "MAD" | "MYR" | "NOK" | "PHP" | "PLN" | "SEK" | "SGD" | "THB" | "TRY" | "USD" | "VND")[];
+};
+export declare const distributorIdContext: {
+    __context__: string;
+};
+export declare const assetsURLContext: {
+    __context__: string;
+};
+export declare const apiHostContext: {
+    __context__: string;
+};
+export declare const loyaltyPointsContext: {
+    __context__: boolean;
+};

package/dist/contexts/properties.context.js

@@ -0,0 +1,9 @@
+import { createContext } from "@lit/context";
+export const localesContext = createContext(Symbol("locales-context"));
+export const localeContext = createContext(Symbol("locale-context"));
+export const currencyContext = createContext(Symbol("currency-context"));
+export const currenciesContext = createContext(Symbol("currencies-context"));
+export const distributorIdContext = createContext(Symbol("distributor-id-context"));
+export const assetsURLContext = createContext(Symbol("assets-url-context"));
+export const apiHostContext = createContext(Symbol("api-host-context"));
+export const loyaltyPointsContext = createContext(Symbol("loyalty-points-context"));

package/dist/contexts/types.d.ts

@@ -0,0 +1,16 @@
+import { SupportedCurrencies, SupportedLocales } from "../core/types/index.js";
+import { PageName } from "../core/types/shared.js";
+/**
+ * Base parameters always present on the page-dispatch Lit context callback
+ * payload. These are required on the output the parent receives.
+ */
+export type BasePageState = {
+    page: PageName;
+    currency: SupportedCurrencies;
+    locale: SupportedLocales;
+};
+/**
+ * Base parameters for internal dispatch input.
+ * All fields are optional since dispatchPageUpdate fills in defaults.
+ */
+export type BasePageStateInput = Partial<BasePageState>;

package/dist/contexts/types.js

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

package/dist/contexts/utils.d.ts

@@ -0,0 +1 @@
+export type Constructor<T = object> = new (...args: any[]) => T;

package/dist/contexts/utils.js

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

package/dist/controllers/time-expiration.d.ts

@@ -0,0 +1,11 @@
+import { ReactiveController, ReactiveControllerHost } from "lit";
+export declare class TimeExpirationController implements ReactiveController {
+    host: ReactiveControllerHost;
+    value: number;
+    private timerID?;
+    private onExpire?;
+    constructor(host: ReactiveControllerHost, expirationTime?: number, onExpire?: () => void);
+    private destroy;
+    hostConnected(): void;
+    hostDisconnected(): void;
+}

package/dist/controllers/time-expiration.js

@@ -0,0 +1,31 @@
+export class TimeExpirationController {
+    constructor(host, expirationTime = 0, onExpire) {
+        this.value = expirationTime;
+        this.host = host;
+        this.onExpire = onExpire;
+        host.addController(this);
+    }
+    destroy() {
+        clearInterval(this.timerID);
+        this.timerID = undefined;
+    }
+    hostConnected() {
+        if (this.value <= 0) {
+            return;
+        }
+        this.timerID = setInterval(() => {
+            this.value--;
+            if (this.value <= 0) {
+                this.value = 0;
+                this.destroy();
+                if (this.onExpire) {
+                    this.onExpire();
+                }
+            }
+            this.host.requestUpdate();
+        }, 1000);
+    }
+    hostDisconnected() {
+        this.destroy();
+    }
+}

package/dist/core/api/api-error.d.ts

@@ -0,0 +1,20 @@
+export declare class APIError extends Error {
+    readonly endpoint: string;
+    readonly method: string;
+    readonly response: unknown;
+    readonly statusCode?: number;
+    constructor({ endpoint, method, response, statusCode, }: {
+        endpoint: string;
+        method: string;
+        response: unknown;
+        statusCode?: number;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        endpoint: string;
+        method: string;
+        statusCode: number | undefined;
+        response: unknown;
+    };
+}

package/dist/core/api/api-error.js

@@ -0,0 +1,27 @@
+export class APIError extends Error {
+    constructor({ endpoint, method, response, statusCode, }) {
+        const title = response && typeof response === "object" && "title" in response
+            ? String(response.title)
+            : "API Error";
+        super(`${method} ${endpoint}: ${title}`);
+        this.name = "APIError";
+        this.endpoint = endpoint;
+        this.method = method;
+        this.response = response;
+        this.statusCode = statusCode;
+        // Maintains proper stack trace in V8 environments
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, APIError);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            endpoint: this.endpoint,
+            method: this.method,
+            statusCode: this.statusCode,
+            response: this.response,
+        };
+    }
+}

package/dist/core/api/middlewares/booking-session/booking-session.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const BOOKING_SESSION_STORAGE_KEY = "coras-booking-session";
+export declare const BOOKING_SESSION_HEADER = "Booking-Session";
+export declare const BOOKING_SESSION_EXPIRES_HEADER = "booking-session-expires";
+export declare const RETRY_ATTEMPTS = 3;
+export declare const RETRY_DELAY = 1000;

package/dist/core/api/middlewares/booking-session/booking-session.constants.js

@@ -0,0 +1,5 @@
+export const BOOKING_SESSION_STORAGE_KEY = "coras-booking-session";
+export const BOOKING_SESSION_HEADER = "Booking-Session";
+export const BOOKING_SESSION_EXPIRES_HEADER = "booking-session-expires";
+export const RETRY_ATTEMPTS = 3;
+export const RETRY_DELAY = 1000;

package/dist/core/api/middlewares/booking-session/booking-session.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from "openapi-fetch";
+export declare const bookingSessionMiddleware: Middleware;

package/dist/core/api/middlewares/booking-session/booking-session.js

@@ -0,0 +1,56 @@
+import { BOOKING_SESSION_EXPIRES_HEADER, BOOKING_SESSION_HEADER, } from "./booking-session.constants.js";
+import { getBookingSession, removeBookingSession, retryWithExponentialBackoff, updateBookingSessionExpiration, } from "./booking-session.utils.js";
+export const bookingSessionMiddleware = {
+    async onError({ error, request }) {
+        console.log("Request failed with error, attempting retry:", error);
+        try {
+            return await retryWithExponentialBackoff(async () => {
+                const response = await fetch(request.clone());
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                return response;
+            });
+        }
+        catch (retryError) {
+            console.error("All retry attempts failed:", retryError);
+            throw retryError;
+        }
+    },
+    async onResponse({ response, request }) {
+        if (response.status === 401) {
+            console.log("Received 401 response, removing booking session");
+            removeBookingSession();
+            if (request.method === "GET") {
+                console.log("Retrying GET request after removing booking session");
+                const newHeaders = new Headers(request.headers);
+                newHeaders.delete(BOOKING_SESSION_HEADER);
+                const newRequest = new Request(request, {
+                    headers: newHeaders,
+                });
+                try {
+                    return await fetch(newRequest);
+                }
+                catch (error) {
+                    console.error("Error retrying request after 401:", error);
+                    return response;
+                }
+            }
+            return response;
+        }
+        const expiresHeader = response.headers.get(BOOKING_SESSION_EXPIRES_HEADER);
+        if (expiresHeader) {
+            const currentBookingSession = getBookingSession();
+            if (currentBookingSession) {
+                const expirationDate = new Date(expiresHeader);
+                if (!isNaN(expirationDate.getTime())) {
+                    updateBookingSessionExpiration(expirationDate);
+                }
+                else {
+                    console.error("Failed to parse booking session expiration date:", expiresHeader);
+                }
+            }
+        }
+        return response;
+    },
+};

package/dist/core/api/middlewares/booking-session/booking-session.utils.d.ts

@@ -0,0 +1,5 @@
+export declare const getBookingSession: () => string | undefined;
+export declare const storeBookingSession: (bookingSession: string, expirationDate: Date) => void;
+export declare const updateBookingSessionExpiration: (expirationDate: Date) => void;
+export declare const removeBookingSession: () => void;
+export declare const retryWithExponentialBackoff: <T>(operation: () => Promise<T>, maxRetries?: number, baseDelayMs?: number, maxDelayMs?: number) => Promise<T>;

package/dist/core/api/middlewares/booking-session/booking-session.utils.js

@@ -0,0 +1,70 @@
+import { BOOKING_SESSION_STORAGE_KEY, RETRY_ATTEMPTS, RETRY_DELAY, } from "./booking-session.constants.js";
+export const getBookingSession = () => {
+    try {
+        const raw = localStorage.getItem(BOOKING_SESSION_STORAGE_KEY);
+        if (!raw)
+            return undefined;
+        const { token, expiresAt } = JSON.parse(raw);
+        if (!token || expiresAt <= Date.now()) {
+            removeBookingSession();
+            return undefined;
+        }
+        return token;
+    }
+    catch {
+        // localStorage may be blocked (private browsing) or hold corrupt JSON.
+        return undefined;
+    }
+};
+export const storeBookingSession = (bookingSession, expirationDate) => {
+    try {
+        const value = {
+            token: bookingSession,
+            expiresAt: expirationDate.getTime(),
+        };
+        localStorage.setItem(BOOKING_SESSION_STORAGE_KEY, JSON.stringify(value));
+    }
+    catch {
+        // localStorage may be blocked (private browsing).
+    }
+};
+export const updateBookingSessionExpiration = (expirationDate) => {
+    const currentSession = getBookingSession();
+    if (currentSession) {
+        storeBookingSession(currentSession, expirationDate);
+    }
+};
+export const removeBookingSession = () => {
+    try {
+        localStorage.removeItem(BOOKING_SESSION_STORAGE_KEY);
+    }
+    catch {
+        // localStorage may be blocked (private browsing).
+    }
+};
+const delay = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+export const retryWithExponentialBackoff = async (operation, maxRetries = RETRY_ATTEMPTS, baseDelayMs = RETRY_DELAY, maxDelayMs) => {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries) {
+                let currentDelay = baseDelayMs * Math.pow(2, attempt - 1);
+                if (maxDelayMs !== undefined) {
+                    currentDelay = Math.min(currentDelay, maxDelayMs);
+                }
+                const jitter = Math.random() * (baseDelayMs / 2);
+                const finalDelay = Math.round(currentDelay + jitter);
+                await delay(finalDelay);
+            }
+        }
+    }
+    throw lastError instanceof Error
+        ? lastError
+        : new Error(`Operation failed after ${maxRetries} retries. Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+};

package/dist/core/api/middlewares/error-handler/error-handler.d.ts

@@ -0,0 +1,6 @@
+import { Middleware } from "openapi-fetch";
+import { APIError } from "../../api-error.js";
+type ApiErrorReporter = (error: APIError) => void;
+export declare const setApiErrorReporter: (reporter: ApiErrorReporter) => void;
+export declare const errorHandlerMiddleware: Middleware;
+export {};

package/dist/core/api/middlewares/error-handler/error-handler.js

@@ -0,0 +1,27 @@
+import { APIError } from "../../api-error.js";
+let apiErrorReporter;
+export const setApiErrorReporter = (reporter) => {
+    apiErrorReporter = reporter;
+};
+export const errorHandlerMiddleware = {
+    async onResponse({ response, request }) {
+        if (!response.ok) {
+            let errorBody;
+            try {
+                errorBody = await response.clone().json();
+            }
+            catch {
+                errorBody = await response.clone().text();
+            }
+            const error = new APIError({
+                endpoint: new URL(request.url).pathname,
+                method: request.method,
+                response: errorBody,
+                statusCode: response.status,
+            });
+            apiErrorReporter?.(error);
+            throw error;
+        }
+        return response;
+    },
+};

package/dist/core/api/queries.d.ts

@@ -0,0 +1,74 @@
+import { Client } from "openapi-fetch";
+import type { PathsWithMethod, RequestBodyJSON, ResponseObjectMap, SuccessResponse } from "openapi-typescript-helpers";
+import type { paths } from "../types/api-schema.js";
+import { SupportedLocales } from "../types/index.js";
+export declare const apiGet: <TPath extends PathsWithMethod<paths, "get">>({ client, distributorID, locale, endpoint, query, path: customPath, bookingSession, }: {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+    endpoint: TPath;
+    query?: paths[TPath]["get"]["parameters"]["query"];
+    path?: Record<string, string>;
+    bookingSession?: string | null;
+}) => Promise<{
+    data: SuccessResponse<ResponseObjectMap<paths[TPath]["get"]>>;
+    response: Response;
+}>;
+export declare const apiPost: <TPath extends PathsWithMethod<paths, "post">>({ client, distributorID, locale, endpoint, body, path: customPath, bookingSession, headers: customHeaders, }: {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+    endpoint: TPath;
+    body: RequestBodyJSON<paths[TPath]["post"]>;
+    path?: Record<string, string>;
+    bookingSession?: string | null;
+    headers?: Record<string, string>;
+}) => Promise<{
+    data: SuccessResponse<ResponseObjectMap<paths[TPath]["post"]>>;
+    response: Response;
+}>;
+export declare const apiPut: <TPath extends PathsWithMethod<paths, "put">>({ client, distributorID, locale, endpoint, body, path: customPath, bookingSession, headers: customHeaders, }: {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+    endpoint: TPath;
+    body: RequestBodyJSON<paths[TPath]["put"]>;
+    path?: Record<string, string>;
+    bookingSession?: string | null;
+    headers?: Record<string, string>;
+}) => Promise<{
+    data: SuccessResponse<ResponseObjectMap<paths[TPath]["put"]>>;
+    response: Response;
+}>;
+export declare const apiPatch: <TPath extends PathsWithMethod<paths, "patch">>({ client, distributorID, locale, endpoint, path: customPath, query: customQuery, body, bookingSession, }: {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+    endpoint: TPath;
+    path?: Record<string, string>;
+    query?: Record<string, string | null | undefined>;
+    body?: RequestBodyJSON<paths[TPath]["patch"]>;
+    bookingSession?: string | null;
+}) => Promise<{
+    data: SuccessResponse<ResponseObjectMap<paths[TPath]["patch"]>>;
+    response: Response;
+}>;
+export declare const apiDelete: <TPath extends PathsWithMethod<paths, "delete">>({ client, distributorID, locale, endpoint, path: customPath, bookingSession, }: {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+    endpoint: TPath;
+    path?: Record<string, string>;
+    bookingSession?: string | null;
+}) => Promise<{
+    data: SuccessResponse<ResponseObjectMap<paths[TPath]["delete"]>>;
+    response: Response;
+}>;
+export declare function withErrorHandling<T>(promise: Promise<{
+    data: T;
+    response: Response;
+}>): Promise<{
+    data: T | undefined;
+    response: Response | undefined;
+    error: unknown;
+}>;

package/dist/core/api/queries.js

@@ -0,0 +1,120 @@
+import { API_VERSION } from "../constants/api-version.js";
+import { getBookingSession } from "./middlewares/booking-session/booking-session.utils.js";
+const createBaseRequestConfig = (distributorID, locale, customBookingSession) => {
+    const bookingSession = customBookingSession !== undefined
+        ? customBookingSession
+        : getBookingSession();
+    const headers = {
+        "Content-Type": "application/json",
+        "Coras-Distributor": distributorID,
+        ...(bookingSession && { "Booking-Session": bookingSession }),
+    };
+    const path = { api_version: API_VERSION };
+    const language_code = locale.split("-")[0];
+    return { headers, path, language_code };
+};
+export const apiGet = async ({ client, distributorID, locale, endpoint, query, path: customPath, bookingSession, }) => {
+    const { headers, path, language_code } = createBaseRequestConfig(distributorID, locale, bookingSession);
+    const { data, response } = await client.GET(endpoint, {
+        params: {
+            header: headers,
+            path: {
+                ...path,
+                ...(customPath || {}),
+            },
+            query: {
+                ...(query || {}),
+                language_code,
+            },
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { data, response };
+};
+export const apiPost = async ({ client, distributorID, locale, endpoint, body, path: customPath, bookingSession, headers: customHeaders, }) => {
+    const { headers, path, language_code } = createBaseRequestConfig(distributorID, locale, bookingSession);
+    const { data, response } = await client.POST(endpoint, {
+        params: {
+            header: {
+                ...headers,
+                ...(customHeaders || {}),
+            },
+            path: {
+                ...path,
+                ...(customPath || {}),
+            },
+            query: {
+                language_code,
+            },
+        },
+        body,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { data, response };
+};
+export const apiPut = async ({ client, distributorID, locale, endpoint, body, path: customPath, bookingSession, headers: customHeaders, }) => {
+    const { headers, path, language_code } = createBaseRequestConfig(distributorID, locale, bookingSession);
+    const { data, response } = await client.PUT(endpoint, {
+        params: {
+            header: {
+                ...headers,
+                ...(customHeaders || {}),
+            },
+            path: {
+                ...path,
+                ...(customPath || {}),
+            },
+            query: {
+                language_code,
+            },
+        },
+        body,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { data, response };
+};
+export const apiPatch = async ({ client, distributorID, locale, endpoint, path: customPath, query: customQuery, body, bookingSession, }) => {
+    const { headers, path, language_code } = createBaseRequestConfig(distributorID, locale, bookingSession);
+    const { data, response } = await client.PATCH(endpoint, {
+        params: {
+            header: headers,
+            path: {
+                ...path,
+                ...(customPath || {}),
+            },
+            query: {
+                language_code,
+                ...(customQuery || {}),
+            },
+        },
+        body,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { data, response };
+};
+export const apiDelete = async ({ client, distributorID, locale, endpoint, path: customPath, bookingSession, }) => {
+    const { headers, path, language_code } = createBaseRequestConfig(distributorID, locale, bookingSession);
+    const { data, response } = await client.DELETE(endpoint, {
+        params: {
+            header: headers,
+            path: {
+                ...path,
+                ...(customPath || {}),
+            },
+            query: {
+                language_code,
+            },
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+    return { data, response };
+};
+export async function withErrorHandling(promise) {
+    try {
+        const { data, response } = await promise;
+        return { data, response, error: null };
+    }
+    catch (error) {
+        return { data: undefined, response: undefined, error };
+    }
+}

package/dist/core/constants/api-version.d.ts

@@ -0,0 +1 @@
+export declare const API_VERSION = "v2";

package/dist/core/constants/api-version.js

@@ -0,0 +1 @@
+export const API_VERSION = "v2";

package/dist/core/currency/constants.d.ts

@@ -0,0 +1,5 @@
+import { allLocales } from "../i18n/locale-codes.js";
+export declare const supportedCurrencies: readonly ["AED", "ALL", "AUD", "CAD", "CHF", "CNY", "DKK", "EUR", "GBP", "HRK", "HUF", "IDR", "ISK", "JPY", "MAD", "MYR", "NOK", "PHP", "PLN", "SEK", "SGD", "THB", "TRY", "USD", "VND"];
+export declare const currencySymbol: Record<(typeof supportedCurrencies)[number], string>;
+export declare const currencyName: Record<(typeof supportedCurrencies)[number], string>;
+export declare const localeToCurrencyMapping: Partial<Record<(typeof allLocales)[number], keyof typeof currencySymbol>>;