@coras-io/embed 0.1.0

package/dist/views/payment-page/payment-page.validation-schema.d.ts

@@ -0,0 +1,28 @@
+import { ValidatorFn } from "./payment-page.validators.js";
+/**
+ * Validation schema for payment page form fields.
+ *
+ * This schema defines validation rules separately from UI configuration,
+ * enabling:
+ * - Easier testing of validation logic
+ * - Clear separation of concerns
+ * - Reusability across different form implementations
+ */
+/**
+ * Validation rules for base form fields
+ */
+export declare const baseFieldValidators: Record<string, ValidatorFn>;
+/**
+ * Default validator for dynamic fields (reservation/ticket requirements)
+ * These fields are generally required unless specified otherwise
+ */
+export declare const defaultDynamicFieldValidator: ValidatorFn;
+/**
+ * Gets validators for a specific field
+ * Falls back to required validator for unknown fields
+ */
+export declare function getFieldValidators(fieldName: string): ValidatorFn;
+/**
+ * Creates a validation schema object for the form controller
+ */
+export declare function createValidationSchema(): Record<string, ValidatorFn>;

package/dist/views/payment-page/payment-page.validation-schema.js

@@ -0,0 +1,42 @@
+import { required, validEmail, validPhone, maxLength, composeValidators, } from "./payment-page.validators.js";
+/**
+ * Validation schema for payment page form fields.
+ *
+ * This schema defines validation rules separately from UI configuration,
+ * enabling:
+ * - Easier testing of validation logic
+ * - Clear separation of concerns
+ * - Reusability across different form implementations
+ */
+/**
+ * Validation rules for base form fields
+ */
+export const baseFieldValidators = {
+    first_name: composeValidators(required, maxLength(50)),
+    second_name: composeValidators(required, maxLength(50)),
+    email: composeValidators(required, validEmail),
+    phone: composeValidators(required, validPhone),
+    addressLine1: composeValidators(required, maxLength(100)),
+    addressLine2: maxLength(100), // Optional field
+    city: composeValidators(required, maxLength(50)),
+    postcode: composeValidators(required, maxLength(20)),
+    country: required,
+};
+/**
+ * Default validator for dynamic fields (reservation/ticket requirements)
+ * These fields are generally required unless specified otherwise
+ */
+export const defaultDynamicFieldValidator = required;
+/**
+ * Gets validators for a specific field
+ * Falls back to required validator for unknown fields
+ */
+export function getFieldValidators(fieldName) {
+    return baseFieldValidators[fieldName] || defaultDynamicFieldValidator;
+}
+/**
+ * Creates a validation schema object for the form controller
+ */
+export function createValidationSchema() {
+    return { ...baseFieldValidators };
+}

package/dist/views/payment-page/payment-page.validators.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Validation context for validators that need additional information
+ */
+export interface ValidatorContext {
+    countryCode?: string;
+}
+/**
+ * Validator function signature
+ */
+export type ValidatorFn = (params: {
+    value: string;
+    context?: ValidatorContext;
+}) => string | undefined;
+/**
+ * Required field validator
+ */
+export declare const required: ValidatorFn;
+/**
+ * RFC 5322 compliant email validation
+ * Validates the general format of email addresses including:
+ * - Local part with allowed special characters
+ * - Domain with valid characters
+ * - Proper structure with @ separator
+ */
+export declare const validEmail: ValidatorFn;
+/**
+ * Phone number validation using libphonenumber-js
+ * Validates phone numbers with optional country context:
+ * - With country code: validates as national number for that country
+ * - Without country code: validates as international format (must include +)
+ * - Strips common formatting characters before validation
+ */
+export declare const validPhone: ValidatorFn;
+/**
+ * Creates a maximum length validator
+ * @param max Maximum allowed characters
+ */
+export declare const maxLength: (max: number) => ValidatorFn;
+/**
+ * Creates a minimum length validator
+ * @param min Minimum required characters
+ */
+export declare const minLength: (min: number) => ValidatorFn;
+/**
+ * Creates a pattern validator with custom error message
+ * @param pattern Regular expression to match
+ * @param errorMessage Error message to show on failure
+ */
+export declare const pattern: (regex: RegExp, errorMessage: string) => ValidatorFn;
+/**
+ * Alphanumeric only validator (letters and numbers)
+ */
+export declare const alphanumeric: ValidatorFn;
+export declare const validDate: ValidatorFn;
+export declare const validPassportExpiry: ValidatorFn;
+export declare const composeValidators: (...validators: ValidatorFn[]) => ValidatorFn;

package/dist/views/payment-page/payment-page.validators.js

@@ -0,0 +1,147 @@
+import { msg, str } from "@lit/localize";
+import { isValidPhoneNumber } from "libphonenumber-js/min";
+/**
+ * Required field validator
+ */
+export const required = ({ value }) => {
+    return !value || value.trim().length === 0
+        ? msg("This is a required field")
+        : undefined;
+};
+/**
+ * RFC 5322 compliant email validation
+ * Validates the general format of email addresses including:
+ * - Local part with allowed special characters
+ * - Domain with valid characters
+ * - Proper structure with @ separator
+ */
+export const validEmail = ({ value }) => {
+    if (!value) {
+        return undefined; // Let required validator handle empty values
+    }
+    // RFC 5322 compliant regex for email validation
+    // Matches: local-part@domain where:
+    // - Local part allows: alphanumeric, dots, and special chars (!#$%&'*+/=?^_`{|}~-)
+    // - Domain allows: alphanumeric with optional hyphens, and subdomains
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    if (!emailRegex.test(value)) {
+        return msg("Please enter a valid email address");
+    }
+    return undefined;
+};
+/**
+ * Phone number validation using libphonenumber-js
+ * Validates phone numbers with optional country context:
+ * - With country code: validates as national number for that country
+ * - Without country code: validates as international format (must include +)
+ * - Strips common formatting characters before validation
+ */
+export const validPhone = ({ value, context }) => {
+    if (!value) {
+        return undefined;
+    }
+    const cleaned = value.replace(/[\s\-().]/g, "");
+    if (!cleaned) {
+        return undefined;
+    }
+    const countryCode = context?.countryCode;
+    const isValid = countryCode
+        ? isValidPhoneNumber(cleaned, countryCode)
+        : isValidPhoneNumber(cleaned);
+    if (!isValid) {
+        return msg("Please enter a valid phone number");
+    }
+    return undefined;
+};
+/**
+ * Creates a maximum length validator
+ * @param max Maximum allowed characters
+ */
+export const maxLength = (max) => {
+    return ({ value }) => {
+        if (!value) {
+            return undefined;
+        }
+        if (value.length > max) {
+            return msg(str `Maximum ${max} characters allowed`);
+        }
+        return undefined;
+    };
+};
+/**
+ * Creates a minimum length validator
+ * @param min Minimum required characters
+ */
+export const minLength = (min) => {
+    return ({ value }) => {
+        if (!value) {
+            return undefined; // Let required validator handle empty values
+        }
+        if (value.length < min) {
+            return msg(str `Minimum ${min} characters required`);
+        }
+        return undefined;
+    };
+};
+/**
+ * Creates a pattern validator with custom error message
+ * @param pattern Regular expression to match
+ * @param errorMessage Error message to show on failure
+ */
+export const pattern = (regex, errorMessage) => {
+    return ({ value }) => {
+        if (!value) {
+            return undefined;
+        }
+        if (!regex.test(value)) {
+            return errorMessage;
+        }
+        return undefined;
+    };
+};
+/**
+ * Alphanumeric only validator (letters and numbers)
+ */
+export const alphanumeric = ({ value }) => {
+    if (!value) {
+        return undefined;
+    }
+    if (!/^[a-zA-Z0-9]+$/.test(value)) {
+        return msg("Only letters and numbers are allowed");
+    }
+    return undefined;
+};
+export const validDate = ({ value }) => {
+    if (!value)
+        return undefined; // Let required validator handle empty values
+    const datePattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!datePattern.test(value)) {
+        return msg("Please enter a valid date in format YYYY-MM-DD");
+    }
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+        return msg("Please enter a valid date");
+    }
+    return undefined;
+};
+export const validPassportExpiry = ({ value }) => {
+    const dateError = validDate({ value });
+    if (dateError)
+        return dateError;
+    const today = new Date();
+    const expiryDate = new Date(value);
+    if (expiryDate <= today) {
+        return msg("Passport must not be expired");
+    }
+    return undefined;
+};
+export const composeValidators = (...validators) => {
+    return (params) => {
+        for (const validator of validators) {
+            const error = validator(params);
+            if (error)
+                return error;
+        }
+        return undefined;
+    };
+};

package/dist/views/payment-page/services/payment-api.service.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Payment API Service — wraps API calls specific to the payment domain.
+ *
+ * Provides a stable interface for payment-related API operations,
+ * decoupling controllers from the raw API query functions.
+ * Currently delegates to apiGet/apiPut/apiPatch from core/api/queries.
+ */
+import { SupportedLocales } from "../../../core/types/index.js";
+import type { paths, components } from "../../../core/types/api-schema.js";
+import type { Client } from "openapi-fetch";
+export interface PaymentApiConfig {
+    client: Client<paths>;
+    distributorID: string;
+    locale: SupportedLocales;
+}
+export declare class PaymentApiService {
+    private config;
+    constructor(config: PaymentApiConfig);
+    updateConfig(config: Partial<PaymentApiConfig>): void;
+    fetchCountries(languageCode: string): Promise<{
+        data: {
+            code: string;
+            name: string;
+            phone_code: number;
+        }[] | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    fetchGeolocation(): Promise<{
+        data: {
+            code: string | null;
+            name: string | null;
+            location_type: "country" | null;
+            slug: string | null;
+            parent_location_type: null;
+            parent_location: null;
+        } | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    checkReservations(bookingSession: string | null): Promise<{
+        data: {
+            general: components["schemas"]["GeneralRequirements"];
+            reservations: components["schemas"]["ReservationRequirementsAndRestrictions"][];
+        } | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    fetchReservations(bookingSession: string): Promise<{
+        data: {
+            reservations: (components["schemas"]["EventReservationSummary"] | components["schemas"]["TourReservationSummary"])[];
+            total_price: number;
+        } | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    confirmReservation(body: components["schemas"]["ReservationsPutRequest"], bookingSession: string | null, headers?: Record<string, string>): Promise<{
+        data: {
+            transaction_id: string;
+            user_id: string;
+            client_secret: string | null;
+        } | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    patchReservation(reservationId: string, body: {
+        pickup_id: string | null;
+        pickup_entry: string | null;
+    }): Promise<{
+        data: undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    fetchTransactions(userId: string): Promise<{
+        data: {
+            transaction_id: string;
+            status: string;
+            created_at: string;
+            reference_id: string;
+            loyalty: components["schemas"]["LoyaltySchema"];
+        }[] | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    fetchConfig(): Promise<{
+        data: {
+            coinbase_project_id: string | null;
+            fida_token_address: string | null;
+            loyalty_page_url: string | null;
+            stripe_publishable_key: string;
+            rpc_url: string | null;
+            seatsio_public_workspace_key: string | null;
+            seatsio_region: "eu" | "na" | "sa" | "oc";
+            treasury_wallet_address: string | null;
+        } | undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+    submitUserConsent(email: string, headers?: Record<string, string>): Promise<{
+        data: undefined;
+        response: Response | undefined;
+        error: unknown;
+    }>;
+}

package/dist/views/payment-page/services/payment-api.service.js

@@ -0,0 +1,99 @@
+/**
+ * Payment API Service — wraps API calls specific to the payment domain.
+ *
+ * Provides a stable interface for payment-related API operations,
+ * decoupling controllers from the raw API query functions.
+ * Currently delegates to apiGet/apiPut/apiPatch from core/api/queries.
+ */
+import { apiGet, apiPost, apiPut, apiPatch, withErrorHandling, } from "../../../core/api/queries.js";
+export class PaymentApiService {
+    constructor(config) {
+        this.config = config;
+    }
+    updateConfig(config) {
+        Object.assign(this.config, config);
+    }
+    async fetchCountries(languageCode) {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/countries/{language_code}",
+            path: { language_code: languageCode },
+        }));
+    }
+    async fetchGeolocation() {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/geolocation",
+        }));
+    }
+    async checkReservations(bookingSession) {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/reservations/check",
+            bookingSession,
+        }));
+    }
+    async fetchReservations(bookingSession) {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/reservations",
+            bookingSession,
+        }));
+    }
+    async confirmReservation(body, bookingSession, headers) {
+        return withErrorHandling(apiPut({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            bookingSession,
+            endpoint: "/{api_version}/reservations",
+            body,
+            headers,
+        }));
+    }
+    async patchReservation(reservationId, body) {
+        return withErrorHandling(apiPatch({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/reservations/{reservation_id}",
+            path: { reservation_id: reservationId },
+            body,
+        }));
+    }
+    async fetchTransactions(userId) {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/users/{customer_id}/transactions",
+            path: { customer_id: userId },
+        }));
+    }
+    async fetchConfig() {
+        return withErrorHandling(apiGet({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/config",
+        }));
+    }
+    async submitUserConsent(email, headers) {
+        return withErrorHandling(apiPost({
+            client: this.config.client,
+            distributorID: this.config.distributorID,
+            locale: this.config.locale,
+            endpoint: "/{api_version}/fida/user-consent",
+            body: { email },
+            headers,
+        }));
+    }
+}

package/dist/views/search-page/search-page.component.d.ts

@@ -0,0 +1,61 @@
+import { CSSResultGroup, LitElement, PropertyValues } from "lit";
+import "../../components/attraction-card/long/attraction-long-card.js";
+import "../../components/button/button.js";
+import "../../components/loading-spinner/loading-spinner.js";
+import "../../components/layout/layout.js";
+import "../../components/breadcrumbs/breadcrumbs.js";
+import "../../components/breadcrumbs/breadcrumb-item/breadcrumb-item.js";
+import { Client } from "openapi-fetch";
+import { paths } from "../../core/types/api-schema.js";
+import { SearchPageParamsEvent } from "../../core/pages.js";
+export type AttractionsApiResponse = paths["/{api_version}/attractions"]["get"]["responses"]["200"]["content"]["application/json"];
+declare const CorasSearchPage_base: import("../../contexts/utils.js").Constructor<import("../../mixins/error-modal.mixin.js").ErrorModalMixinInterface> & import("../../contexts/utils.js").Constructor<import("../../mixins/location-search/types.js").LocationSearchMixinInterface> & import("../../contexts/utils.js").Constructor<{
+    apiHost: string;
+    distributorID: string;
+    assetsURL: string;
+    currency: import("../../index.js").SupportedCurrencies;
+    currencies: import("../../index.js").SupportedCurrencies[];
+    locale: import("../../index.js").SupportedLocales;
+    locales: import("../../index.js").SupportedLocales[];
+    loyaltyPoints: boolean;
+    client: Client<paths>;
+    getPageProperties(): SearchPageParamsEvent;
+    dispatchPageUpdate(params: import("../../contexts/events.context.js").PageDispatchInput): void;
+}> & typeof LitElement;
+/**
+ * Search page component for displaying search results.
+ *
+ * @fires coras:navigate - Dispatched when navigating to a result page
+ * @fires coras:state-change - Dispatched when search parameters change
+ */
+export declare class CorasSearchPage extends CorasSearchPage_base {
+    static styles: CSSResultGroup;
+    currentPage: "search";
+    getPageProperties(): SearchPageParamsEvent;
+    client: Client<paths>;
+    startDate: string;
+    search: string;
+    private page;
+    private pageSize;
+    private hasMore;
+    private attractions;
+    private _isFirstUpdate;
+    private observer;
+    private debouncedSearchHandler;
+    private sentinelElement;
+    private attractionsSearchTask;
+    private renderBreadcrumbs;
+    private renderTitle;
+    private loadMoreResults;
+    private setupIntersectionObserver;
+    private cleanupIntersectionObserver;
+    private resetSearch;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: PropertyValues): void;
+    private renderAttractions;
+    private handleAttractionClick;
+    private renderBottomSection;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};