@coras-io/embed 0.1.0

package/dist/views/landing-page/landing-page.constants.d.ts

@@ -0,0 +1 @@
+export declare const MOBILE_SCREEN_BREAKPOINT = 530;

package/dist/views/landing-page/landing-page.constants.js

@@ -0,0 +1 @@
+export const MOBILE_SCREEN_BREAKPOINT = 530;

package/dist/views/landing-page/landing-page.d.ts

@@ -0,0 +1,8 @@
+import { CorasLandingPage } from "./landing-page.component.js";
+export * from "./landing-page.component.js";
+export default CorasLandingPage;
+declare global {
+    interface HTMLElementTagNameMap {
+        "coras-landing-page": CorasLandingPage;
+    }
+}

package/dist/views/landing-page/landing-page.js

@@ -0,0 +1,6 @@
+import { CorasLandingPage } from "./landing-page.component.js";
+export * from "./landing-page.component.js";
+export default CorasLandingPage;
+if (!customElements.get("coras-landing-page")) {
+    customElements.define("coras-landing-page", CorasLandingPage);
+}

package/dist/views/landing-page/landing-page.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/dist/views/landing-page/landing-page.styles.js

@@ -0,0 +1,109 @@
+import { css } from "lit";
+import component from "../../styles/defaults/component.js";
+export default css `
+  ${component}
+
+  .calendar {
+    padding: 1rem;
+  }
+
+  coras-layout {
+    container-type: inline-size;
+    container-name: coras-layout;
+
+    header.hero-section {
+      display: flex;
+      flex-direction: column;
+      row-gap: 2rem;
+
+      .filters {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        column-gap: 0.5rem;
+        row-gap: 0.75rem;
+        padding-block: 1rem;
+        border-top: 1px solid var(--coras-color-neutral-200);
+        border-bottom: 1px solid var(--coras-color-neutral-200);
+      }
+    }
+
+    .attractions-sections {
+      .popular-title {
+        font-weight: var(--coras-font-weight-normal);
+        font-size: var(--coras-font-size-sm);
+        line-height: 16px;
+        letter-spacing: 0;
+        margin: 2rem 0 1rem 0;
+      }
+
+      section {
+        .section-header {
+          display: flex;
+          align-items: center;
+          gap: 1rem;
+          font-weight: 600;
+          font-size: 22px;
+          line-height: 30px;
+          letter-spacing: 0.2px;
+        }
+
+        .cards {
+          display: grid;
+          grid-template-columns: repeat(4, 1fr);
+          gap: 1rem;
+
+          .show-more-button {
+            visibility: hidden;
+          }
+        }
+      }
+    }
+  }
+
+  @container coras-layout (max-width: 1000px) {
+    coras-layout {
+      header.hero-section {
+        coras-location-image {
+          display: none;
+        }
+
+        .filters {
+          padding-block: 0;
+          border-top: none;
+          border-bottom: none;
+        }
+      }
+
+      .attractions-sections {
+        section {
+          .cards {
+            grid-template-columns: repeat(2, 1fr);
+          }
+        }
+      }
+    }
+  }
+
+  @container coras-layout (max-width: 500px) {
+    coras-layout {
+      .attractions-sections {
+        section {
+          .section-header {
+            .show-more-button {
+              display: none;
+            }
+          }
+
+          .cards {
+            grid-template-columns: repeat(1, 1fr);
+
+            .show-more-button {
+              display: block;
+            }
+          }
+        }
+      }
+    }
+  }
+`;

package/dist/views/landing-page/landing-page.types.d.ts

@@ -0,0 +1,7 @@
+import { components } from "../../core/types/api-schema.js";
+export type CategoriesTree = Record<string, CategoriesTreeElement>;
+export type CategoriesTreeElement = {
+    parent: string | null;
+    children: string[];
+};
+export type MediaAsset = components["schemas"]["MediaAssetSchema"];

package/dist/views/landing-page/landing-page.types.js

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

package/dist/views/payment-page/controllers/crypto-auth.controller.d.ts

@@ -0,0 +1,71 @@
+import { ReactiveController, ReactiveControllerHost } from "lit";
+import { PhoneCodeSelection } from "../payment-page.types.js";
+/**
+ * Dependencies injected from the host component.
+ * These map to CoinbaseMixin methods and state that the controller
+ * cannot access directly (mixin inheritance is on the component).
+ */
+export interface CryptoAuthDeps {
+    sendCode(email: string): Promise<void>;
+    loginWithCode(email: string, code: string): Promise<{
+        email?: string;
+    } | undefined>;
+    initiateMfaEnrollment(phoneNumber: string): Promise<void>;
+    submitMfaEnrollment(code: string): Promise<boolean>;
+    /** Callback to sync email to form after successful login */
+    onLoginSuccess(): Promise<void>;
+    /** Callback to refresh balance after login */
+    onBalanceRefresh(): void;
+    /** Callback after MFA enrollment completes — syncs phone to form */
+    onMfaEnrollmentComplete(): void;
+}
+/**
+ * CryptoAuthController manages the OTP email authentication and MFA enrollment
+ * flows for crypto payments.
+ *
+ * Extracted from payment-page.component.ts. Manages:
+ * - OTP code state, errors, rate limiting, inactivity timer
+ * - MFA enrollment code, phone number, errors
+ * - Phone enrollment UI state
+ */
+export declare class CryptoAuthController implements ReactiveController {
+    private host;
+    private deps;
+    otpCode: string;
+    otpError: string;
+    showResend: boolean;
+    otpAttempts: number;
+    lastOtpSentTime: number;
+    otpRateLimitError: string;
+    private otpInactivityTimerId;
+    mfaCode: string;
+    mfaError: string;
+    mfaSelectedPhoneCode: PhoneCodeSelection | null;
+    mfaEnrollmentPhoneNumber: string;
+    showMfaPhoneInput: boolean;
+    localPhoneNumber: string;
+    smsRateLimitError: string;
+    smsAttempts: number;
+    lastSmsSentTime: number;
+    phoneNumberError: string;
+    constructor(host: ReactiveControllerHost, deps: CryptoAuthDeps);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    startOtpInactivityTimer(codeSent: boolean, hasSession: boolean): void;
+    clearOtpInactivityTimer(): void;
+    checkOtpRateLimit(): string;
+    checkSmsRateLimit(): string;
+    handleSendCode(email: string, validateEmail: () => boolean, setEmailError: (error: string) => void): Promise<void>;
+    handleResendCode(email: string, codeSent: boolean, hasSession: boolean): Promise<void>;
+    handleLogin(email: string): Promise<void>;
+    /**
+     * Gets the full phone number for MFA enrollment, combining the selected
+     * code with the local number.
+     */
+    getFullPhoneNumber(fallbackPhoneCode: string): string;
+    handleMfaEnrollmentWithFormPhone(formPhone: string | null, useFormPhone: boolean, fallbackPhoneCode: string, setEnrollmentError: (error: string) => void): Promise<void>;
+    handleVerifyMfaEnrollment(): Promise<void>;
+    handlePhoneEnrollmentChange(value: string): void;
+    resetMfaPhoneState(): void;
+    reset(): void;
+}

package/dist/views/payment-page/controllers/crypto-auth.controller.js

@@ -0,0 +1,252 @@
+import { msg, str } from "@lit/localize";
+import { OTP_INACTIVITY_TIMEOUT_MS, OTP_MIN_RESEND_INTERVAL_MS, OTP_MAX_ATTEMPTS_PER_SESSION, SMS_OTP_MIN_RESEND_INTERVAL_MS, SMS_OTP_MAX_ATTEMPTS_PER_SESSION, } from "../payment-page.constants.js";
+import { sanitizeErrorMessage } from "../payment-page.utils.js";
+/**
+ * CryptoAuthController manages the OTP email authentication and MFA enrollment
+ * flows for crypto payments.
+ *
+ * Extracted from payment-page.component.ts. Manages:
+ * - OTP code state, errors, rate limiting, inactivity timer
+ * - MFA enrollment code, phone number, errors
+ * - Phone enrollment UI state
+ */
+export class CryptoAuthController {
+    constructor(host, deps) {
+        this.otpCode = "";
+        this.otpError = "";
+        this.showResend = false;
+        this.otpAttempts = 0;
+        this.lastOtpSentTime = 0;
+        this.otpRateLimitError = "";
+        this.mfaCode = "";
+        this.mfaError = "";
+        this.mfaSelectedPhoneCode = null;
+        this.mfaEnrollmentPhoneNumber = "";
+        this.showMfaPhoneInput = false;
+        this.localPhoneNumber = "";
+        this.smsRateLimitError = "";
+        this.smsAttempts = 0;
+        this.lastSmsSentTime = 0;
+        this.phoneNumberError = "";
+        this.host = host;
+        this.deps = deps;
+        host.addController(this);
+    }
+    hostConnected() { }
+    hostDisconnected() {
+        this.clearOtpInactivityTimer();
+        this.reset();
+    }
+    // ─── OTP Timer ──────────────────────────────────────────────────────────────
+    startOtpInactivityTimer(codeSent, hasSession) {
+        this.clearOtpInactivityTimer();
+        this.showResend = false;
+        this.otpInactivityTimerId = setTimeout(() => {
+            if (!this.otpCode && codeSent && !hasSession) {
+                this.showResend = true;
+                this.host.requestUpdate();
+            }
+        }, OTP_INACTIVITY_TIMEOUT_MS);
+    }
+    clearOtpInactivityTimer() {
+        if (this.otpInactivityTimerId) {
+            clearTimeout(this.otpInactivityTimerId);
+            this.otpInactivityTimerId = undefined;
+        }
+    }
+    // ─── Rate Limiting ──────────────────────────────────────────────────────────
+    checkOtpRateLimit() {
+        const now = Date.now();
+        const timeSinceLastSend = now - this.lastOtpSentTime;
+        if (this.otpAttempts >= OTP_MAX_ATTEMPTS_PER_SESSION) {
+            return msg("Too many attempts. Please try again later.");
+        }
+        if (this.lastOtpSentTime > 0 &&
+            timeSinceLastSend < OTP_MIN_RESEND_INTERVAL_MS) {
+            const secondsRemaining = Math.ceil((OTP_MIN_RESEND_INTERVAL_MS - timeSinceLastSend) / 1000);
+            return msg(str `Please wait ${secondsRemaining} seconds before resending.`);
+        }
+        return "";
+    }
+    checkSmsRateLimit() {
+        const now = Date.now();
+        const timeSinceLastSend = now - this.lastSmsSentTime;
+        if (this.smsAttempts >= SMS_OTP_MAX_ATTEMPTS_PER_SESSION) {
+            return msg("Too many attempts. Please try again later.");
+        }
+        if (this.lastSmsSentTime > 0 &&
+            timeSinceLastSend < SMS_OTP_MIN_RESEND_INTERVAL_MS) {
+            const secondsRemaining = Math.ceil((SMS_OTP_MIN_RESEND_INTERVAL_MS - timeSinceLastSend) / 1000);
+            return msg(str `Please wait ${secondsRemaining} seconds before resending.`);
+        }
+        return "";
+    }
+    // ─── OTP Actions ────────────────────────────────────────────────────────────
+    async handleSendCode(email, validateEmail, setEmailError) {
+        if (!validateEmail())
+            return;
+        const rateLimitError = this.checkOtpRateLimit();
+        if (rateLimitError) {
+            this.otpRateLimitError = rateLimitError;
+            this.host.requestUpdate();
+            return;
+        }
+        this.otpRateLimitError = "";
+        try {
+            await this.deps.sendCode(email);
+            this.otpAttempts += 1;
+            this.lastOtpSentTime = Date.now();
+            this.host.requestUpdate();
+        }
+        catch (error) {
+            console.error("Error sending verification code:", error);
+            setEmailError(sanitizeErrorMessage(error, msg("Failed to send verification code. Please try again.")));
+        }
+    }
+    async handleResendCode(email, codeSent, hasSession) {
+        const rateLimitError = this.checkOtpRateLimit();
+        if (rateLimitError) {
+            this.otpRateLimitError = rateLimitError;
+            this.host.requestUpdate();
+            return;
+        }
+        this.otpRateLimitError = "";
+        try {
+            await this.deps.sendCode(email);
+            this.otpAttempts += 1;
+            this.lastOtpSentTime = Date.now();
+            this.otpCode = "";
+            this.otpError = "";
+            this.showResend = false;
+            this.startOtpInactivityTimer(codeSent, hasSession);
+            this.host.requestUpdate();
+        }
+        catch (error) {
+            console.error("Error resending verification code:", error);
+        }
+    }
+    async handleLogin(email) {
+        try {
+            if (!this.otpCode) {
+                this.otpError = msg("Please enter the verification code");
+                this.host.requestUpdate();
+                return;
+            }
+            const session = await this.deps.loginWithCode(email, this.otpCode);
+            if (!session) {
+                this.otpError = msg("Login failed. Please try again.");
+                this.host.requestUpdate();
+                return;
+            }
+            this.otpError = "";
+            await this.deps.onLoginSuccess();
+            this.deps.onBalanceRefresh();
+            this.host.requestUpdate();
+        }
+        catch (error) {
+            this.otpError = sanitizeErrorMessage(error, msg("Invalid or expired code. Please try again."));
+            this.host.requestUpdate();
+        }
+    }
+    // ─── MFA Enrollment ─────────────────────────────────────────────────────────
+    /**
+     * Gets the full phone number for MFA enrollment, combining the selected
+     * code with the local number.
+     */
+    getFullPhoneNumber(fallbackPhoneCode) {
+        const mfaPhoneCode = this.mfaSelectedPhoneCode?.phoneCode || fallbackPhoneCode;
+        const phoneNumber = this.localPhoneNumber.replace(/^[+0]+/, "");
+        return `+${mfaPhoneCode}${phoneNumber}`;
+    }
+    async handleMfaEnrollmentWithFormPhone(formPhone, useFormPhone, fallbackPhoneCode, setEnrollmentError) {
+        const smsRateLimit = this.checkSmsRateLimit();
+        if (smsRateLimit) {
+            this.smsRateLimitError = smsRateLimit;
+            this.host.requestUpdate();
+            return;
+        }
+        this.smsRateLimitError = "";
+        try {
+            let phoneNumber;
+            if (useFormPhone && formPhone) {
+                phoneNumber = formPhone;
+            }
+            else {
+                phoneNumber = this.getFullPhoneNumber(fallbackPhoneCode);
+            }
+            // Guard against invalid values: empty, bare "+", or too short to be E.164
+            if (!phoneNumber || !/^\+[1-9]\d{7,14}$/.test(phoneNumber)) {
+                this.phoneNumberError = msg("Please enter a valid phone number");
+                this.host.requestUpdate();
+                return;
+            }
+            await this.deps.initiateMfaEnrollment(phoneNumber);
+            this.smsAttempts += 1;
+            this.lastSmsSentTime = Date.now();
+            this.mfaEnrollmentPhoneNumber = phoneNumber;
+            this.host.requestUpdate();
+        }
+        catch (error) {
+            console.error("MFA enrollment initiation failed:", error);
+            setEnrollmentError(sanitizeErrorMessage(error, msg("Failed to initiate MFA enrollment")));
+        }
+    }
+    async handleVerifyMfaEnrollment() {
+        try {
+            if (!this.mfaCode) {
+                this.mfaError = msg("Please enter the verification code");
+                this.host.requestUpdate();
+                return;
+            }
+            const success = await this.deps.submitMfaEnrollment(this.mfaCode);
+            if (!success) {
+                this.mfaError = msg("Verification failed. Please try again.");
+                this.host.requestUpdate();
+                return;
+            }
+            this.mfaError = "";
+            this.mfaCode = "";
+            this.deps.onMfaEnrollmentComplete();
+            this.host.requestUpdate();
+        }
+        catch (error) {
+            this.mfaError = sanitizeErrorMessage(error, msg("Invalid or expired verification code. Please try again."));
+            this.host.requestUpdate();
+        }
+    }
+    handlePhoneEnrollmentChange(value) {
+        this.localPhoneNumber = value;
+        if (this.phoneNumberError) {
+            this.phoneNumberError = "";
+        }
+        if (this.smsRateLimitError) {
+            this.smsRateLimitError = "";
+        }
+        this.host.requestUpdate();
+    }
+    resetMfaPhoneState() {
+        this.mfaSelectedPhoneCode = null;
+        this.localPhoneNumber = "";
+        this.showMfaPhoneInput = false;
+    }
+    // ─── Reset ──────────────────────────────────────────────────────────────────
+    reset() {
+        this.otpCode = "";
+        this.otpError = "";
+        this.showResend = false;
+        this.otpAttempts = 0;
+        this.lastOtpSentTime = 0;
+        this.otpRateLimitError = "";
+        this.mfaCode = "";
+        this.mfaError = "";
+        this.mfaSelectedPhoneCode = null;
+        this.mfaEnrollmentPhoneNumber = "";
+        this.showMfaPhoneInput = false;
+        this.localPhoneNumber = "";
+        this.smsRateLimitError = "";
+        this.smsAttempts = 0;
+        this.lastSmsSentTime = 0;
+        this.phoneNumberError = "";
+        this.host.requestUpdate();
+    }
+}

package/dist/views/payment-page/controllers/crypto-transfer.controller.d.ts

@@ -0,0 +1,99 @@
+import { ReactiveController, ReactiveControllerHost } from "lit";
+import { TransferModalState } from "../../../components/transfer-modal/transfer-modal.component.js";
+import { type PendingTransferPayload } from "../payment-page.utils.js";
+/**
+ * Result returned from the on-chain token transfer.
+ */
+export interface TransferResult {
+    success: boolean;
+    transactionHash?: string;
+}
+/**
+ * Outcome of a transfer operation, used by the host to manage flow state.
+ */
+export type TransferOutcome = "completed" | "failed";
+/**
+ * Dependencies injected from the host component.
+ * Maps to CoinbaseMixin methods and other component APIs.
+ */
+export interface CryptoTransferDeps {
+    transferTokens(amount: string): Promise<TransferResult>;
+    confirmReservation(): Promise<{
+        transaction_id: string;
+        user_id: string;
+    } | null>;
+    checkTransactionStatus(userId: string): Promise<string | null>;
+    showErrorModalOnce(): void;
+    redirectToConfirmation(success: boolean): void;
+    refreshBalance(): void;
+    submitMfaVerification(code: string): Promise<boolean>;
+    initiateMfaVerification(): Promise<void>;
+    resetMfaVerificationState(): void;
+    /** Returns the current pending transfer amount */
+    getPendingTransferAmount(): string;
+    /** Returns the current cart token total for amount matching */
+    getCurrentCartTotal(): string;
+    /** Setter for transactionId on the host */
+    setTransactionId(id: string): void;
+    /** Setter for userId on the host */
+    setUserId(id: string): void;
+}
+/**
+ * CryptoTransferController manages the on-chain token transfer lifecycle,
+ * crash recovery via localStorage, and MFA verification during transfers.
+ *
+ * Extracted from payment-page.component.ts. Manages:
+ * - Transfer modal state (showTransferModal, transferModalState)
+ * - Transfer transaction hash tracking
+ * - MFA verification during transfer (code submission, resend, cancellation)
+ * - Pending transfer persistence and recovery (localStorage + checksum)
+ */
+export declare class CryptoTransferController implements ReactiveController {
+    private host;
+    private deps;
+    showTransferModal: boolean;
+    transferModalState: TransferModalState;
+    transferTransactionHash: string;
+    transferErrorMessage: string;
+    mfaVerificationError: string;
+    mfaVerificationLoading: boolean;
+    constructor(host: ReactiveControllerHost, deps: CryptoTransferDeps);
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Starts a new on-chain crypto transfer.
+     * Called when user clicks Pay Now with crypto and is fully authenticated.
+     */
+    startTransfer(): Promise<TransferOutcome>;
+    /**
+     * Handles successful on-chain transfer — confirms reservation with API.
+     * Persists the transaction hash BEFORE calling the API for crash recovery.
+     */
+    handleTransferSuccess(transactionHash: string): Promise<TransferOutcome>;
+    /**
+     * Opens the transfer modal for MFA verification.
+     * Called from the component when MFA fires during transfer.
+     */
+    openMfaVerification(): void;
+    handleMfaCodeSubmitted(code: string): Promise<void>;
+    handleMfaResendRequested(): Promise<void>;
+    handleTransferCancelled(): void;
+    persistPendingTransfer(transactionHash: string): Promise<void>;
+    clearPendingTransfer(): void;
+    private updatePendingTransferPhase;
+    /**
+     * Checks for a pending transfer that wasn't confirmed with the backend.
+     * Called once on initialization to recover from crashes/failures.
+     */
+    recoverPendingTransfer(): Promise<void>;
+    /**
+     * Gets a valid pending transfer from localStorage, or null.
+     * Validates structure, TTL, checksum, and amount match.
+     */
+    getValidPendingTransfer(): Promise<PendingTransferPayload | null>;
+    /**
+     * Retries reservation confirmation for a pending on-chain transfer.
+     */
+    retryPendingTransfer(payload: PendingTransferPayload): Promise<TransferOutcome>;
+    reset(): void;
+}