@mopay/node-sdk 0.1.0

package/dist/checkout.js

@@ -0,0 +1,402 @@
+const DEFAULT_POPUP_WIDTH = 520;
+const DEFAULT_POPUP_HEIGHT = 720;
+const DEFAULT_DIALOG_WIDTH = 571.4;
+const DEFAULT_DIALOG_HEIGHT = 418.4;
+const DEFAULT_DIALOG_MIN_WIDTH = 320;
+const DEFAULT_DIALOG_MIN_HEIGHT = 420;
+const CHECKOUT_STYLE_ID = "mopay-checkout-styles";
+export function checkout(paymentUrl, options = {}) {
+    return MoPayCheckout.open({ ...options, checkoutUrl: paymentUrl });
+}
+export class MoPayCheckout {
+    static open(options) {
+        const checkoutUrl = resolveCheckoutUrl(options);
+        const mode = options.mode || "dialog";
+        assertPaymentUrl(checkoutUrl);
+        if (mode === "redirect") {
+            const target = options.target || window;
+            target.location.href = checkoutUrl;
+            return {
+                mode,
+                close: () => undefined,
+            };
+        }
+        const trustedOrigins = resolveTrustedOrigins(checkoutUrl, options);
+        const controller = new CheckoutMessageController(options, trustedOrigins);
+        if (mode === "dialog") {
+            const handle = openDialog(checkoutUrl, options, controller);
+            options.onOpen?.(handle);
+            return handle;
+        }
+        const handle = openPopup(checkoutUrl, options, controller);
+        options.onOpen?.(handle);
+        return handle;
+    }
+}
+function openPopup(paymentUrl, options, controller) {
+    const width = options.width || DEFAULT_POPUP_WIDTH;
+    const height = options.height || DEFAULT_POPUP_HEIGHT;
+    const left = Math.max(0, window.screenX + (window.outerWidth - width) / 2);
+    const top = Math.max(0, window.screenY + (window.outerHeight - height) / 2);
+    const popup = window.open(paymentUrl, options.popupName || "mopay_checkout", [
+        `width=${width}`,
+        `height=${height}`,
+        `left=${left}`,
+        `top=${top}`,
+        "resizable=yes",
+        "scrollbars=yes",
+        "status=no",
+        "toolbar=no",
+        "menubar=no",
+    ].join(","));
+    if (!popup) {
+        controller.destroy();
+        throw new Error("MoPay checkout popup was blocked by the browser");
+    }
+    controller.setSource(popup);
+    const timer = window.setInterval(() => {
+        if (popup.closed) {
+            window.clearInterval(timer);
+            controller.destroy();
+            options.onClose?.();
+        }
+    }, 500);
+    return {
+        mode: "popup",
+        close: () => {
+            window.clearInterval(timer);
+            controller.destroy();
+            popup.close();
+        },
+    };
+}
+function openDialog(paymentUrl, options, controller) {
+    injectDialogStyles();
+    const dialog = document.createElement("dialog");
+    const shell = document.createElement("div");
+    const frame = document.createElement("iframe");
+    const closeButton = document.createElement("button");
+    const closeLineA = document.createElement("span");
+    const closeLineB = document.createElement("span");
+    const loader = document.createElement("div");
+    dialog.setAttribute("aria-label", "MoPay checkout");
+    dialog.className = `mopay-checkout-dialog${options.resizable ? " is-resizable" : ""}`;
+    dialog.style.setProperty("--mopay-checkout-width", toPixels(options.width || DEFAULT_DIALOG_WIDTH));
+    dialog.style.setProperty("--mopay-checkout-height", toPixels(options.height || DEFAULT_DIALOG_HEIGHT));
+    dialog.style.setProperty("--mopay-checkout-min-width", toPixels(options.minWidth || DEFAULT_DIALOG_MIN_WIDTH));
+    dialog.style.setProperty("--mopay-checkout-min-height", toPixels(options.minHeight || DEFAULT_DIALOG_MIN_HEIGHT));
+    dialog.style.setProperty("--mopay-checkout-max-width", toOptionalPixels(options.maxWidth) || "calc(100vw - 32px)");
+    dialog.style.setProperty("--mopay-checkout-max-height", toOptionalPixels(options.maxHeight) || "calc(100vh - 32px)");
+    shell.className = "mopay-checkout-shell";
+    frame.src = paymentUrl;
+    frame.title = "MoPay checkout";
+    frame.allow = "payment";
+    frame.className = "mopay-checkout-frame";
+    frame.addEventListener("load", () => {
+        frame.classList.add("is-loaded");
+        loader.remove();
+    }, { once: true });
+    closeButton.type = "button";
+    closeButton.className = "mopay-checkout-close";
+    closeButton.setAttribute("aria-label", options.closeButtonLabel || "Close MoPay checkout");
+    closeLineA.setAttribute("aria-hidden", "true");
+    closeLineB.setAttribute("aria-hidden", "true");
+    closeButton.append(closeLineA, closeLineB);
+    closeButton.addEventListener("click", () => dialog.close());
+    loader.className = "mopay-checkout-loader";
+    loader.setAttribute("aria-hidden", "true");
+    shell.append(loader, closeButton, frame);
+    dialog.append(shell);
+    document.body.append(dialog);
+    controller.setSource(frame.contentWindow);
+    dialog.addEventListener("close", () => {
+        controller.destroy();
+        dialog.remove();
+        options.onClose?.();
+    }, { once: true });
+    dialog.showModal();
+    return {
+        mode: "dialog",
+        close: () => dialog.close(),
+    };
+}
+function injectDialogStyles() {
+    if (document.getElementById(CHECKOUT_STYLE_ID)) {
+        return;
+    }
+    const style = document.createElement("style");
+    style.id = CHECKOUT_STYLE_ID;
+    style.textContent = `
+.mopay-checkout-dialog {
+  width: min(var(--mopay-checkout-width), var(--mopay-checkout-max-width));
+  height: min(var(--mopay-checkout-height), var(--mopay-checkout-max-height));
+  min-width: min(var(--mopay-checkout-min-width), calc(100vw - 32px));
+  min-height: min(var(--mopay-checkout-min-height), calc(100vh - 32px));
+  max-width: calc(100vw - 32px);
+  max-height: calc(100vh - 32px);
+  margin: auto;
+  padding: 0;
+  border: 0;
+  border-radius: 10px;
+  background: transparent;
+  color: #111827;
+  overflow: hidden;
+  box-shadow: 0 28px 90px rgb(15 23 42 / 18%), 0 2px 12px rgb(15 23 42 / 8%);
+}
+
+.mopay-checkout-dialog::backdrop {
+  background:  rgb(255 255 255 / 72%);
+}
+
+.mopay-checkout-dialog.is-resizable {
+  resize: both;
+}
+
+.mopay-checkout-shell {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  border: 1px solid rgb(255 255 255 / 82%);
+  border-radius: inherit;
+  background: #ffffff;
+  overflow: hidden;
+}
+
+.mopay-checkout-frame {
+  display: block;
+  width: 100%;
+  height: 100%;
+  border: 0;
+  background: #ffffff;
+  opacity: 0;
+  transition: opacity 160ms ease;
+}
+
+.mopay-checkout-frame.is-loaded {
+  opacity: 1;
+}
+
+.mopay-checkout-close {
+  position: absolute;
+  top: 6px;
+  right: 12px;
+  z-index: 2;
+  display: grid;
+  width: 20px;
+  height: 20px;
+  place-items: center;
+  border: 0;
+  background: none;
+  color: #4b5563;
+  cursor: pointer;
+  font-size: 5px;
+  transition: background 140ms ease, color 140ms ease, transform 140ms ease;
+}
+
+.mopay-checkout-close:hover {
+  color: #111827;
+}
+
+.mopay-checkout-close:active {
+  transform: scale(0.96);
+}
+
+.mopay-checkout-close:focus-visible {
+  outline: 3px solid rgb(59 130 246 / 32%);
+  outline-offset: 2px;
+}
+
+.mopay-checkout-close span {
+  position: absolute;
+  width: 15px;
+  height: 2px;
+  background: currentColor;
+}
+
+.mopay-checkout-close span:first-child {
+  transform: rotate(45deg);
+}
+
+.mopay-checkout-close span:last-child {
+  transform: rotate(-45deg);
+}
+
+.mopay-checkout-loader {
+  position: absolute;
+  inset: 0;
+  z-index: 1;
+  display: grid;
+  place-items: center;
+  background: #ffffff;
+}
+
+.mopay-checkout-loader::after {
+  content: "";
+  width: 38px;
+  height: 38px;
+  border: 3px solid #e5e7eb;
+  border-top-color: #10b981;
+  border-radius: 999px;
+  animation: mopay-checkout-spin 800ms linear infinite;
+}
+
+@keyframes mopay-checkout-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (max-width: 560px) {
+  .mopay-checkout-dialog {
+    width: calc(100vw - 24px);
+    height: calc(100vh - 24px);
+    min-width: 0;
+    min-height: 0;
+    border-radius: 18px;
+  }
+
+  .mopay-checkout-close {
+    top: 12px;
+    right: 12px;
+  }
+}
+`;
+    document.head.append(style);
+}
+class CheckoutMessageController {
+    options;
+    trustedOrigins;
+    source = null;
+    constructor(options, trustedOrigins) {
+        this.options = options;
+        this.trustedOrigins = trustedOrigins;
+        window.addEventListener("message", this.handleMessage);
+    }
+    setSource(source) {
+        this.source = source;
+    }
+    destroy() {
+        window.removeEventListener("message", this.handleMessage);
+    }
+    handleMessage = (event) => {
+        if (!this.trustedOrigins.has(event.origin)) {
+            return;
+        }
+        if (this.source && event.source !== this.source) {
+            return;
+        }
+        const message = normalizeCheckoutMessage(event.data);
+        if (!message) {
+            return;
+        }
+        this.options.onMessage?.(message);
+        switch (message.status) {
+            case "success":
+                this.options.onSuccess?.(message);
+                break;
+            case "failed":
+                this.options.onFailed?.(message);
+                break;
+            case "cancelled":
+                this.options.onCancel?.(message);
+                break;
+            case "pending":
+                this.options.onPending?.(message);
+                break;
+        }
+    };
+}
+function normalizeCheckoutMessage(data) {
+    const parsed = parseMessageData(data);
+    if (!parsed || typeof parsed !== "object") {
+        return null;
+    }
+    const record = parsed;
+    const type = asString(record.type ?? record.event);
+    const status = normalizeStatus(asString(record.status));
+    if (!type?.startsWith("mopay.") && !status) {
+        return null;
+    }
+    return {
+        type,
+        status,
+        sessionId: asString(record.sessionId),
+        transactionId: asString(record.transactionId),
+        reference: asString(record.reference),
+        amount: asString(record.amount),
+        paymentMethod: asString(record.paymentMethod),
+        error: asString(record.error),
+        raw: data,
+    };
+}
+function parseMessageData(data) {
+    if (typeof data !== "string") {
+        return data;
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeStatus(status) {
+    if (!status) {
+        return undefined;
+    }
+    const normalized = status.toLowerCase();
+    if (normalized === "cancelled" || normalized === "canceled") {
+        return "cancelled";
+    }
+    return normalized;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function toPixels(value) {
+    return `${Math.max(0, value)}px`;
+}
+function toOptionalPixels(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return toPixels(value);
+}
+function resolveCheckoutUrl(options) {
+    const checkoutUrl = options.checkoutUrl ?? options.checkout_url;
+    if (checkoutUrl) {
+        return checkoutUrl;
+    }
+    const token = options.checkoutToken ?? options.checkout_token;
+    if (!token) {
+        throw new Error("checkoutUrl or checkoutToken is required to open MoPay checkout");
+    }
+    const baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://mopay.co.ls");
+    return new URL(`/pay/${encodeURIComponent(token)}`, baseUrl).href;
+}
+function resolveTrustedOrigins(checkoutUrl, options) {
+    const origins = [
+        new URL(checkoutUrl).origin,
+        options.allowedOrigin,
+        ...(options.allowedOrigins || []),
+    ];
+    return new Set(origins
+        .filter((origin) => Boolean(origin))
+        .map((origin) => new URL(origin).origin));
+}
+function normalizeBaseUrl(baseUrl) {
+    const normalized = /^https?:\/\//i.test(baseUrl) ? baseUrl : `https://${baseUrl}`;
+    const url = new URL(normalized);
+    return url.href.endsWith("/") ? url.href : `${url.href}/`;
+}
+function assertPaymentUrl(paymentUrl) {
+    if (!paymentUrl) {
+        throw new Error("paymentUrl is required to open MoPay checkout");
+    }
+    try {
+        new URL(paymentUrl);
+    }
+    catch {
+        throw new Error(`paymentUrl must be a valid absolute URL. Received: ${paymentUrl}`);
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class MoPayAPIError extends Error {
+    readonly name = "MoPayAPIError";
+    readonly statusCode: number | undefined;
+    readonly code: string | undefined;
+    readonly response: unknown;
+    constructor(message: string, options?: {
+        statusCode?: number;
+        code?: string;
+        response?: unknown;
+    });
+}
+export declare class MoPayValidationError extends Error {
+    readonly name = "MoPayValidationError";
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,mBAAmB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;gBAGzB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAO;CAO3E;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAA0B;CACxC"}

package/dist/errors.js

@@ -0,0 +1,15 @@
+export class MoPayAPIError extends Error {
+    name = "MoPayAPIError";
+    statusCode;
+    code;
+    response;
+    constructor(message, options = {}) {
+        super(message);
+        this.statusCode = options.statusCode;
+        this.code = options.code;
+        this.response = options.response;
+    }
+}
+export class MoPayValidationError extends Error {
+    name = "MoPayValidationError";
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { Base } from "./base.js";
+import type { CheckoutHandle, CheckoutFlowOptions, CreatePaymentSessionParams, CreatePaymentSessionResponse, RequestOptions, RetrieveSessionResponse, Session, VerifiedRedirect, WaitForSessionOptions } from "./types.js";
+declare class MoPay extends Base {
+    createPaymentSession(params: CreatePaymentSessionParams, options?: RequestOptions): Promise<CreatePaymentSessionResponse>;
+    createPayment(params: CreatePaymentSessionParams, options?: RequestOptions): Promise<CreatePaymentSessionResponse>;
+    retrieveSession(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    parseRedirect(input: string | URL | URLSearchParams | Record<string, string>): VerifiedRedirect;
+    checkout(input: string | CreatePaymentSessionParams, options?: CheckoutFlowOptions): Promise<CheckoutHandle>;
+    getSession(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    getTransaction(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    isSuccessful(session: RetrieveSessionResponse | Session): boolean;
+    isPaymentSuccessful(sessionId: string, options?: RequestOptions): Promise<boolean>;
+    waitForSession(sessionId: string, options?: WaitForSessionOptions): Promise<RetrieveSessionResponse>;
+}
+export default MoPay;
+export { MoPay, MoPay as Mopay };
+export { MoPayAPIError, MoPayValidationError } from "./errors.js";
+export { checkout, MoPayCheckout, } from "./checkout.js";
+export { formatAmount, isValidReference, parseRedirect, validateCreatePaymentSessionParams, } from "./utils.js";
+export type { CreatePaymentSessionParams, CreatePaymentSessionResponse, CheckoutHandle, CheckoutFlowOptions, CheckoutMode, CheckoutMessage, CheckoutOptions, ErrorResponse, FetchLike, MoPayConfig, MoPayCheckoutOpenOptions, PaymentFrequency, PaymentMethod, RequestOptions, RedirectStatus, RetrieveSessionResponse, Session, SessionStatus, TransactionStatus, VerifiedRedirect, WaitForSessionOptions, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAMjC,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EAEnB,0BAA0B,EAC1B,4BAA4B,EAC5B,cAAc,EACd,uBAAuB,EACvB,OAAO,EACP,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,cAAM,KAAM,SAAQ,IAAI;IACtB,oBAAoB,CAClB,MAAM,EAAE,0BAA0B,EAClC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,4BAA4B,CAAC;IAIxC,aAAa,CACX,MAAM,EAAE,0BAA0B,EAClC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,4BAA4B,CAAC;IAIxC,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAI9F,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,gBAAgB;IAIzF,QAAQ,CACZ,KAAK,EAAE,MAAM,GAAG,0BAA0B,EAC1C,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,cAAc,CAAC;IAoB1B,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAIzF,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAI7F,YAAY,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,GAAG,OAAO;IAIjE,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAIlF,cAAc,CACZ,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,uBAAuB,CAAC;CAGpC;AAID,eAAe,KAAK,CAAC;AACrB,OAAO,EAAE,KAAK,EAAE,KAAK,IAAI,KAAK,EAAE,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EACL,QAAQ,EACR,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,kCAAkC,GACnC,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,0BAA0B,EAC1B,4BAA4B,EAC5B,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,eAAe,EACf,aAAa,EACb,SAAS,EACT,WAAW,EACX,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,58 @@
+import { Base } from "./base.js";
+import { Payments } from "./payments/index.js";
+import { Redirects } from "./redirects/index.js";
+import { Sessions } from "./sessions/index.js";
+import { checkout as openCheckoutDialog, MoPayCheckout } from "./checkout.js";
+import { applyMixins } from "./utils.js";
+class MoPay extends Base {
+    createPaymentSession(params, options) {
+        return Payments.prototype.createPaymentSession.call(this, params, options);
+    }
+    createPayment(params, options) {
+        return Payments.prototype.createPayment.call(this, params, options);
+    }
+    retrieveSession(sessionId, options) {
+        return Sessions.prototype.retrieveSession.call(this, sessionId, options);
+    }
+    parseRedirect(input) {
+        return Redirects.prototype.parseRedirect.call(this, input);
+    }
+    async checkout(input, options = {}) {
+        const { onSessionCreated, ...checkoutOptions } = options;
+        const mergedOptions = {
+            ...this.getDefaultCheckoutOptions(),
+            ...checkoutOptions,
+        };
+        if (typeof input === "string") {
+            return openCheckoutDialog(input, mergedOptions);
+        }
+        const session = await this.createPaymentSession(input, options);
+        onSessionCreated?.(session);
+        return MoPayCheckout.open({
+            ...mergedOptions,
+            checkoutUrl: session.paymentUrl ?? session.checkoutUrl ?? session.checkout_url,
+            checkoutToken: session.checkoutToken ?? session.checkout_token,
+        });
+    }
+    getSession(sessionId, options) {
+        return Sessions.prototype.getSession.call(this, sessionId, options);
+    }
+    getTransaction(sessionId, options) {
+        return Sessions.prototype.getTransaction.call(this, sessionId, options);
+    }
+    isSuccessful(session) {
+        return Sessions.prototype.isSuccessful.call(this, session);
+    }
+    isPaymentSuccessful(sessionId, options) {
+        return Sessions.prototype.isPaymentSuccessful.call(this, sessionId, options);
+    }
+    waitForSession(sessionId, options) {
+        return Sessions.prototype.waitForSession.call(this, sessionId, options);
+    }
+}
+applyMixins(MoPay, [Payments, Sessions, Redirects]);
+export default MoPay;
+export { MoPay, MoPay as Mopay };
+export { MoPayAPIError, MoPayValidationError } from "./errors.js";
+export { checkout, MoPayCheckout, } from "./checkout.js";
+export { formatAmount, isValidReference, parseRedirect, validateCreatePaymentSessionParams, } from "./utils.js";

package/dist/payments/index.d.ts

@@ -0,0 +1,7 @@
+import { Base } from "../base.js";
+import type { CreatePaymentSessionParams, CreatePaymentSessionResponse, RequestOptions } from "../types.js";
+export declare class Payments extends Base {
+    createPaymentSession(params: CreatePaymentSessionParams, options?: RequestOptions): Promise<CreatePaymentSessionResponse>;
+    createPayment(params: CreatePaymentSessionParams, options?: RequestOptions): Promise<CreatePaymentSessionResponse>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/payments/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/payments/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,KAAK,EACV,0BAA0B,EAC1B,4BAA4B,EAC5B,cAAc,EACf,MAAM,aAAa,CAAC;AAKrB,qBAAa,QAAS,SAAQ,IAAI;IAChC,oBAAoB,CAClB,MAAM,EAAE,0BAA0B,EAClC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,4BAA4B,CAAC;IAOxC,aAAa,CACX,MAAM,EAAE,0BAA0B,EAClC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,4BAA4B,CAAC;CAGzC"}

package/dist/payments/index.js

@@ -0,0 +1,14 @@
+import { Base } from "../base.js";
+import { serializeCreatePaymentSessionParams } from "../utils.js";
+const resourceName = "/api/external/payment";
+export class Payments extends Base {
+    createPaymentSession(params, options) {
+        return this.request(resourceName, {
+            method: "POST",
+            body: JSON.stringify(serializeCreatePaymentSessionParams(params)),
+        }, options);
+    }
+    createPayment(params, options) {
+        return this.createPaymentSession(params, options);
+    }
+}

package/dist/redirects/index.d.ts

@@ -0,0 +1,7 @@
+import { Base } from "../base.js";
+import type { CheckoutHandle, CheckoutOptions, VerifiedRedirect } from "../types.js";
+export declare class Redirects extends Base {
+    parseRedirect(input: string | URL | URLSearchParams | Record<string, string>): VerifiedRedirect;
+    checkout(paymentUrl: string, options?: CheckoutOptions): CheckoutHandle;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/redirects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/redirects/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGrF,qBAAa,SAAU,SAAQ,IAAI;IACjC,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,gBAAgB;IAI/F,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc;CAGxE"}

package/dist/redirects/index.js

@@ -0,0 +1,11 @@
+import { Base } from "../base.js";
+import { checkout } from "../checkout.js";
+import { parseRedirect } from "../utils.js";
+export class Redirects extends Base {
+    parseRedirect(input) {
+        return parseRedirect(input);
+    }
+    checkout(paymentUrl, options) {
+        return checkout(paymentUrl, options);
+    }
+}

package/dist/sessions/index.d.ts

@@ -0,0 +1,11 @@
+import { Base } from "../base.js";
+import type { RequestOptions, RetrieveSessionResponse, Session, WaitForSessionOptions } from "../types.js";
+export declare class Sessions extends Base {
+    retrieveSession(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    getSession(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    getTransaction(sessionId: string, options?: RequestOptions): Promise<RetrieveSessionResponse>;
+    isSuccessful(session: RetrieveSessionResponse | Session): boolean;
+    isPaymentSuccessful(sessionId: string, options?: RequestOptions): Promise<boolean>;
+    waitForSession(sessionId: string, options?: WaitForSessionOptions): Promise<RetrieveSessionResponse>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sessions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,KAAK,EACV,cAAc,EACd,uBAAuB,EACvB,OAAO,EACP,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAOrB,qBAAa,QAAS,SAAQ,IAAI;IAChC,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAU9F,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAIzF,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAI7F,YAAY,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,GAAG,OAAO;IAK3D,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAKlF,cAAc,CAClB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,uBAAuB,CAAC;CAmBpC"}

package/dist/sessions/index.js

@@ -0,0 +1,58 @@
+import { Base } from "../base.js";
+import { MoPayValidationError } from "../errors.js";
+const resourceName = "/api/external/session/v1";
+const DEFAULT_POLL_INTERVAL_MS = 2000;
+const DEFAULT_POLL_TIMEOUT_MS = 60000;
+const DEFAULT_TERMINAL_STATUSES = ["COMPLETED", "FAILED", "CANCELLED", "EXPIRED"];
+export class Sessions extends Base {
+    retrieveSession(sessionId, options) {
+        if (!sessionId) {
+            throw new MoPayValidationError("sessionId is required");
+        }
+        return this.request(`${resourceName}/${encodeURIComponent(sessionId)}`, {
+            method: "GET",
+        }, options);
+    }
+    getSession(sessionId, options) {
+        return this.retrieveSession(sessionId, options);
+    }
+    getTransaction(sessionId, options) {
+        return this.retrieveSession(sessionId, options);
+    }
+    isSuccessful(session) {
+        const data = isRetrieveSessionResponse(session) ? session.session : session;
+        return data.status === "COMPLETED" || data.transactionStatus === "success";
+    }
+    async isPaymentSuccessful(sessionId, options) {
+        const session = await this.retrieveSession(sessionId, options);
+        return this.isSuccessful(session);
+    }
+    async waitForSession(sessionId, options = {}) {
+        const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const timeoutMs = options.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+        const terminalStatuses = options.terminalStatuses ?? DEFAULT_TERMINAL_STATUSES;
+        const startedAt = Date.now();
+        while (true) {
+            const response = await this.retrieveSession(sessionId, options);
+            if (terminalStatuses.includes(response.session.status)) {
+                return response;
+            }
+            if (Date.now() - startedAt >= timeoutMs) {
+                return response;
+            }
+            await delay(intervalMs, options.signal);
+        }
+    }
+}
+function isRetrieveSessionResponse(session) {
+    return "session" in session && typeof session.session === "object" && session.session !== null;
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}