@orqex/checkout-js 0.0.1

package/dist/index.js

@@ -0,0 +1,853 @@
+import { successMessage, errorMessage, closeMessage, __publicField, isEmbedMessage } from './chunk-4Q2JETLA.js';
+export { ORQEX_PROTOCOL_VERSION, closeMessage, errorMessage, isEmbedMessage, readyMessage, redirectMessage, resizeMessage, successMessage } from './chunk-4Q2JETLA.js';
+
+// src/key.ts
+var PK_PATTERN = /^pk_(live|test)_[A-Za-z0-9]+$/;
+function parsePublishableKey(key) {
+  if (typeof key !== "string" || !PK_PATTERN.test(key)) {
+    throw new Error(
+      'Orqex: a publishable key ("pk_live_\u2026" or "pk_test_\u2026") is required. Never pass a secret key to the browser.'
+    );
+  }
+  return { key, livemode: key.startsWith("pk_live_") };
+}
+
+// src/config.ts
+var DEFAULT_CHECKOUT_BASE_URL = "https://checkout.orqex.com";
+var DEFAULT_API_BASE_URL = "https://api.orqex.com";
+function resolveConfig(publishableKey, options = {}) {
+  const { key, livemode } = parsePublishableKey(publishableKey);
+  const raw = options.checkoutBaseUrl ?? DEFAULT_CHECKOUT_BASE_URL;
+  const checkoutBaseUrl = raw.replace(/\/+$/, "");
+  let checkoutOrigin;
+  try {
+    checkoutOrigin = new URL(checkoutBaseUrl).origin;
+  } catch {
+    throw new Error(`Orqex: invalid checkoutBaseUrl "${raw}".`);
+  }
+  const apiBaseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "");
+  return { publishableKey: key, livemode, checkoutBaseUrl, checkoutOrigin, apiBaseUrl };
+}
+function buildEmbedUrl(config, publicId, parentOrigin) {
+  const id = encodeURIComponent(publicId);
+  return `${config.checkoutBaseUrl}/${id}?embed=1&origin=${encodeURIComponent(parentOrigin)}`;
+}
+function buildRedirectUrl(config, publicId) {
+  return `${config.checkoutBaseUrl}/${encodeURIComponent(publicId)}`;
+}
+
+// src/embedded.ts
+var SANDBOX = "allow-scripts allow-same-origin allow-forms allow-popups";
+var EmbeddedController = class {
+  constructor(deps) {
+    __publicField(this, "config");
+    __publicField(this, "bus");
+    __publicField(this, "win");
+    __publicField(this, "navigate");
+    __publicField(this, "iframe", null);
+    __publicField(this, "listener", null);
+    this.config = deps.config;
+    this.bus = deps.bus;
+    this.win = deps.win ?? window;
+    this.navigate = deps.navigate ?? ((url) => this.win.location.assign(url));
+  }
+  mount(target, options) {
+    if (!options.publicId) throw new Error("Orqex: mount requires a publicId.");
+    const host = this.resolveHost(target);
+    this.unmount();
+    const iframe = this.win.document.createElement("iframe");
+    iframe.src = buildEmbedUrl(this.config, options.publicId, this.win.location.origin);
+    iframe.setAttribute("sandbox", SANDBOX);
+    iframe.setAttribute("allow", "payment");
+    iframe.setAttribute("title", "Orqex Checkout");
+    iframe.style.width = "100%";
+    iframe.style.border = "none";
+    iframe.style.height = "150px";
+    host.appendChild(iframe);
+    this.iframe = iframe;
+    const listener = (event) => {
+      if (event.origin !== this.config.checkoutOrigin) return;
+      if (event.source !== iframe.contentWindow) return;
+      if (!isEmbedMessage(event.data)) return;
+      this.handle(event.data);
+    };
+    this.win.addEventListener("message", listener);
+    this.listener = listener;
+  }
+  unmount() {
+    if (this.listener) {
+      this.win.removeEventListener("message", this.listener);
+      this.listener = null;
+    }
+    if (this.iframe) {
+      this.iframe.remove();
+      this.iframe = null;
+    }
+  }
+  handle(message) {
+    switch (message.type) {
+      case "resize":
+        if (this.iframe) this.iframe.style.height = `${message.height}px`;
+        break;
+      case "success":
+        this.bus.emit("success", { status: message.status });
+        break;
+      case "error":
+        this.bus.emit("error", { code: message.code, message: message.message });
+        break;
+      case "close":
+        this.bus.emit("close", { status: message.status });
+        break;
+      case "redirect":
+        this.bus.emit("redirect", { url: message.url });
+        this.navigate(message.url);
+        break;
+    }
+  }
+  resolveHost(target) {
+    const host = typeof target === "string" ? this.win.document.querySelector(target) : target;
+    if (!host) throw new Error(`Orqex: mount target "${String(target)}" not found.`);
+    return host;
+  }
+};
+
+// src/event-bus.ts
+var EventBus = class {
+  constructor() {
+    __publicField(this, "handlers", {
+      success: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set(),
+      redirect: /* @__PURE__ */ new Set(),
+      close: /* @__PURE__ */ new Set()
+    });
+  }
+  on(event, handler) {
+    this.handlers[event].add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.handlers[event].delete(handler);
+  }
+  emit(event, payload) {
+    for (const handler of this.handlers[event]) {
+      try {
+        handler(payload);
+      } catch (cause) {
+        console.error(`Orqex: "${event}" event handler threw`, cause);
+      }
+    }
+  }
+};
+
+// ../engine/src/types/errors.ts
+var CheckoutError = class extends Error {
+  constructor(code, message, httpStatus) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "httpStatus");
+    this.name = "CheckoutError";
+    this.code = code;
+    this.httpStatus = httpStatus;
+  }
+};
+function errorCodeFromStatus(status) {
+  switch (status) {
+    case 400:
+      return "not_open";
+    case 404:
+      return "not_found";
+    case 422:
+      return "unprocessable";
+    case 429:
+      return "rate_limited";
+    default:
+      return status >= 500 ? "network" : "unknown";
+  }
+}
+
+// ../engine/src/transport/http-transport.ts
+var HttpTransport = class {
+  constructor(options) {
+    __publicField(this, "baseUrl");
+    __publicField(this, "auth");
+    __publicField(this, "locale");
+    __publicField(this, "fetchImpl");
+    __publicField(this, "timeoutMs");
+    const fetchImpl = options.fetchImpl ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+    if (!fetchImpl) {
+      throw new CheckoutError("unknown", "No fetch implementation available; pass options.fetchImpl.");
+    }
+    if (!options.auth?.publishableKey || !options.auth?.publicId) {
+      throw new CheckoutError("unknown", "HttpTransport requires `auth` with publishableKey and publicId.");
+    }
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.auth = options.auth;
+    this.locale = options.locale;
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = options.timeoutMs ?? 2e4;
+  }
+  show(query) {
+    return this.request("GET", this.path(""), {
+      query: { country: query?.country, currency: query?.currency }
+    });
+  }
+  countries() {
+    return this.request("GET", this.path("/countries"));
+  }
+  pay(body) {
+    return this.request("POST", this.path("/pay"), { body });
+  }
+  authorize(body) {
+    return this.request("POST", this.path("/authorize"), { body });
+  }
+  poll() {
+    return this.request("GET", this.path("/poll"));
+  }
+  /**
+   * Build the resource path: `/checkout/{publicId}{suffix}`.
+   *
+   * One surface shared by the hosted page and the SDK (backend PR #105):
+   * `GET ''` (show), `POST /pay`, `POST /authorize`, `GET /poll`,
+   * `GET /countries`. Scoped to the pk_'s project — a public_id from another
+   * project returns 404 (the engine maps that to a terminal not_found).
+   */
+  path(suffix) {
+    return `/checkout/${encodeURIComponent(this.auth.publicId)}${suffix}`;
+  }
+  async request(method, path, opts) {
+    const url = this.baseUrl + path + this.queryString(opts?.query);
+    const headers = { Accept: "application/json" };
+    if (this.locale) headers["Accept-Language"] = this.locale;
+    headers.Authorization = `Bearer ${this.auth.publishableKey}`;
+    if (opts?.body !== void 0) headers["Content-Type"] = "application/json";
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: opts?.body === void 0 ? void 0 : JSON.stringify(opts.body),
+        signal: controller.signal
+      });
+    } catch (cause) {
+      throw new CheckoutError("network", describeNetworkError(cause));
+    } finally {
+      clearTimeout(timer);
+    }
+    return this.parse(response);
+  }
+  async parse(response) {
+    const text = await response.text().catch(() => "");
+    let json;
+    if (text) {
+      try {
+        json = JSON.parse(text);
+      } catch {
+        json = void 0;
+      }
+    }
+    if (!response.ok) {
+      const message = extractMessage(json) ?? `Request failed with status ${response.status}`;
+      throw new CheckoutError(errorCodeFromStatus(response.status), message, response.status);
+    }
+    if (json === void 0) {
+      throw new CheckoutError("unknown", "Empty or non-JSON response body.", response.status);
+    }
+    return json;
+  }
+  queryString(query) {
+    if (!query) return "";
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0 && value !== "") params.set(key, value);
+    }
+    const qs = params.toString();
+    return qs ? `?${qs}` : "";
+  }
+};
+function extractMessage(json) {
+  if (json && typeof json === "object" && "message" in json) {
+    const message = json.message;
+    if (typeof message === "string") return message;
+  }
+  return void 0;
+}
+function describeNetworkError(cause) {
+  if (cause instanceof Error && cause.name === "AbortError") return "Request timed out.";
+  if (cause instanceof Error) return cause.message;
+  return "Network request failed.";
+}
+
+// ../engine/src/engine/phase.ts
+function derivePhase(checkout) {
+  if (!checkout) return "loading";
+  const session = checkout.session.status;
+  const intent = checkout.payment?.status;
+  const attempt = checkout.attempt?.status;
+  if (intent === "completed") return "succeeded";
+  if (intent === "failed" || intent === "expired") return "failed";
+  if (session !== "open") {
+    return session === "completed" ? "succeeded" : "closed";
+  }
+  if (attempt === "action_required") return "action_required";
+  if (attempt === "processing") return "processing";
+  return "collecting";
+}
+function isTerminalPhase(phase) {
+  return phase === "succeeded" || phase === "failed" || phase === "closed";
+}
+
+// ../engine/src/engine/project.ts
+function actionCompletion(action) {
+  switch (action.type) {
+    case "collect_otp":
+      return "submit";
+    case "complete_with_sdk":
+      return "sdk";
+    case "redirect_to_url":
+      return "redirect";
+    case "embed_iframe":
+    case "approve_on_phone":
+    case "scan_qr_code":
+    case "display_payment_instructions":
+      return "poll";
+    case "none":
+      return "poll";
+    default:
+      return "poll";
+  }
+}
+function isActionable(action) {
+  return action !== null && action.type !== "none";
+}
+function projectView(state) {
+  const { phase, checkout, catalogue } = state;
+  if (phase === "loading") {
+    return { kind: "loading" };
+  }
+  if (!checkout) {
+    const kind = phase === "succeeded" || phase === "failed" ? phase : "closed";
+    return { kind, ctx: result(state, kind) };
+  }
+  const attempt = checkout.attempt;
+  const appearance = state.appearance;
+  switch (phase) {
+    case "collecting": {
+      if (!catalogue) return { kind: "loading" };
+      const ctx = {
+        amount: catalogue.amount,
+        methods: catalogue.methods,
+        country: catalogue.country,
+        currencies: catalogue.currencies,
+        supportsAnyCountry: catalogue.supportsAnyCountry,
+        previousPhones: checkout.previous_used_phones ?? []
+      };
+      if (checkout.restriction) ctx.restriction = checkout.restriction;
+      if (checkout.customer) ctx.customer = checkout.customer;
+      if (checkout.project) ctx.project = checkout.project;
+      if (appearance) ctx.appearance = appearance;
+      if (!state.dismissedError) {
+        if (state.error) ctx.lastError = state.error;
+        if (isFailedAttempt(attempt)) ctx.retryOf = attempt;
+      }
+      return { kind: "form", ctx };
+    }
+    case "action_required": {
+      const action = attempt?.next_action ?? null;
+      if (!attempt || !isActionable(action)) {
+        return attempt ? { kind: "processing", ctx: waiting(state, attempt) } : { kind: "loading" };
+      }
+      return {
+        kind: "action",
+        ctx: {
+          action,
+          attempt,
+          completion: actionCompletion(action),
+          ...catalogue ? { amount: catalogue.amount } : {},
+          ...checkout.project ? { project: checkout.project } : {},
+          ...appearance ? { appearance } : {}
+        }
+      };
+    }
+    case "processing": {
+      return attempt ? { kind: "processing", ctx: waiting(state, attempt) } : { kind: "loading" };
+    }
+    case "succeeded":
+      return { kind: "succeeded", ctx: result(state, "succeeded") };
+    case "failed":
+      return { kind: "failed", ctx: result(state, "failed") };
+    case "closed":
+      return { kind: "closed", ctx: result(state, "closed") };
+    default:
+      return { kind: "loading" };
+  }
+}
+function isFailedAttempt(attempt) {
+  return attempt != null && (attempt.status === "failed" || attempt.status === "cancelled");
+}
+function waiting(state, attempt) {
+  const ctx = { attempt };
+  if (state.catalogue) ctx.amount = state.catalogue.amount;
+  if (state.checkout?.project) ctx.project = state.checkout.project;
+  if (state.appearance) ctx.appearance = state.appearance;
+  return ctx;
+}
+function result(state, kind) {
+  const checkout = state.checkout;
+  const status = kind === "closed" ? checkout?.session.status ?? "expired" : checkout?.payment?.status ?? checkout?.session.status ?? "expired";
+  const failureMessage = kind === "failed" ? checkout?.attempt?.failure.message : void 0;
+  let message = "";
+  if (kind === "failed") message = failureMessage ?? "";
+  else if (kind === "succeeded") message = state.message;
+  const ctx = { status, message };
+  if (checkout?.payment) ctx.payment = checkout.payment;
+  if (state.catalogue) ctx.amount = state.catalogue.amount;
+  if (checkout?.project) ctx.project = checkout.project;
+  if (state.appearance) ctx.appearance = state.appearance;
+  if (state.returnUrl) ctx.returnUrl = state.returnUrl;
+  return ctx;
+}
+
+// ../engine/src/engine/state.ts
+function initialState() {
+  return {
+    catalogue: null,
+    checkout: null,
+    message: "",
+    phase: "loading",
+    error: null,
+    dismissedError: false,
+    appearance: null,
+    returnUrl: null,
+    polling: false
+  };
+}
+function extractCatalogue(checkout) {
+  const { country, currencies, amount, methods } = checkout;
+  if (!country || !currencies || !amount || !methods) return null;
+  return {
+    country,
+    currencies,
+    amount,
+    methods,
+    supportsAnyCountry: checkout.supports_any_country ?? false
+  };
+}
+
+// ../engine/src/engine/engine.ts
+var CheckoutEngine = class {
+  constructor(transport, options = {}) {
+    __publicField(this, "transport", transport);
+    __publicField(this, "state", initialState());
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "autoPoll");
+    __publicField(this, "intervals");
+    __publicField(this, "steady");
+    __publicField(this, "now");
+    __publicField(this, "setTimeoutImpl");
+    __publicField(this, "clearTimeoutImpl");
+    __publicField(this, "pollHandle", null);
+    __publicField(this, "pollTick", 0);
+    __publicField(this, "pollInFlight", false);
+    __publicField(this, "destroyed", false);
+    this.autoPoll = options.autoPoll ?? true;
+    this.intervals = options.pollIntervalsMs ?? [2e3, 2e3, 3e3, 5e3];
+    this.steady = options.steadyIntervalMs ?? 5e3;
+    this.now = options.now ?? Date.now;
+    this.setTimeoutImpl = options.setTimeoutImpl ?? ((cb, ms) => setTimeout(cb, ms));
+    this.clearTimeoutImpl = options.clearTimeoutImpl ?? ((handle) => clearTimeout(handle));
+  }
+  // --- read surface ---
+  getView() {
+    return projectView(this.state);
+  }
+  /** Subscribe to view changes. Fires immediately with the current view. */
+  subscribe(fn) {
+    this.listeners.add(fn);
+    fn(this.getView());
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  // --- actions ---
+  /**
+   * Seed state from a server-fetched `show` payload (SSR) so the first paint is
+   * the form, not the loading screen — no transport call. The host passes the
+   * `GET /checkout/{public_id}` payload the SSR layer fetched after bootstrap.
+   * Treated exactly like a `show`, so the resolved catalogue is cached. The
+   * engine may still `poll()`/`load()` afterwards to refresh.
+   */
+  hydrate(checkout, message = "") {
+    this.applyResponse(checkout, message, true);
+  }
+  /**
+   * Seed session-scoped chrome from the SSR bootstrap payload. `appearance` and
+   * `return_url` no longer ride on show/pay/poll responses, so the host passes
+   * them once here and the engine projects them onto every view. Call before the
+   * first render (alongside `hydrate`) so the theme paints branded from frame 1.
+   */
+  seedBootstrap(input) {
+    const next = {};
+    if (input.appearance) next.appearance = input.appearance;
+    if (input.returnUrl !== void 0) next.returnUrl = input.returnUrl;
+    if (Object.keys(next).length > 0) this.setState(next);
+  }
+  async load() {
+    await this.runShow(void 0);
+  }
+  async selectCountry(country) {
+    await this.runShow({ country });
+  }
+  async selectCurrency(currency) {
+    const country = this.state.catalogue?.country.code;
+    await this.runShow(country ? { country, currency } : { currency });
+  }
+  /** Full selectable country catalogue for the picker (not part of the view). */
+  async listCountries() {
+    try {
+      const res = await this.transport.countries();
+      return res.data;
+    } catch (cause) {
+      this.setError(cause);
+      return [];
+    }
+  }
+  async pay(input) {
+    await this.runMutation(() => this.transport.pay(this.withCatalogueDefaults(input)), false);
+  }
+  /**
+   * Dismiss the current error banner (both `lastError` and a failed-attempt
+   * `retryOf`). Themes call this when the customer selects a method again so a
+   * stale error doesn't linger; the next server response clears the dismissal.
+   */
+  clearError() {
+    if (this.state.error === null && this.state.dismissedError) return;
+    this.setState({ error: null, dismissedError: true });
+  }
+  async authorize(input) {
+    await this.runMutation(() => this.transport.authorize(input), false);
+  }
+  async poll() {
+    await this.runMutation(() => this.transport.poll(), false);
+  }
+  /** Called when the customer returns from an external redirect. Just polls. */
+  async resumeFromRedirect() {
+    await this.poll();
+  }
+  // --- polling control (host wires visibility/focus to these) ---
+  startPolling() {
+    if (this.destroyed || this.state.polling) return;
+    this.setState({ polling: true });
+    this.pollTick = 0;
+    this.scheduleNextPoll();
+  }
+  stopPolling() {
+    if (this.pollHandle !== null) {
+      this.clearTimeoutImpl(this.pollHandle);
+      this.pollHandle = null;
+    }
+    if (this.state.polling) this.setState({ polling: false });
+  }
+  destroy() {
+    this.destroyed = true;
+    this.stopPolling();
+    this.listeners.clear();
+  }
+  // --- internals ---
+  async runShow(query) {
+    try {
+      const res = await this.transport.show(query);
+      this.applyResponse(res.data, res.message ?? "", true);
+    } catch (cause) {
+      this.setError(cause);
+    }
+  }
+  async runMutation(call, isShow) {
+    try {
+      const res = await call();
+      this.applyResponse(res.data, res.message ?? "", isShow);
+    } catch (cause) {
+      this.setError(cause);
+    }
+  }
+  /**
+   * Stamp the pay payload with the currently-resolved country/currency from the
+   * cached catalogue. Themes call `selectCountry`/`selectCurrency` (which refetch
+   * the catalogue) but never thread that selection back into `pay` — without this
+   * the server falls back to its default country and rejects methods that aren't
+   * available there. A value already on the input always wins; currency is only
+   * stamped when DCC is in effect (the only time the server expects it).
+   */
+  withCatalogueDefaults(input) {
+    const catalogue = this.state.catalogue;
+    if (!catalogue) return input;
+    const next = { ...input };
+    if (next.country === void 0) next.country = catalogue.country.code;
+    if (next.currency === void 0 && catalogue.amount.is_dcc) {
+      const currency = catalogue.amount.final.currency;
+      if (currency) next.currency = currency;
+    }
+    return next;
+  }
+  applyResponse(checkout, message, isShow) {
+    const next = {
+      checkout,
+      message,
+      phase: derivePhase(checkout),
+      error: null,
+      // A fresh response (incl. a new failed attempt) is shown, not suppressed.
+      dismissedError: false
+    };
+    if (isShow) {
+      const catalogue = extractCatalogue(checkout);
+      if (catalogue) next.catalogue = catalogue;
+    }
+    this.setState(next);
+    this.reconcilePolling();
+  }
+  setError(cause) {
+    const error = cause instanceof CheckoutError ? cause : new CheckoutError("unknown", toMessage(cause));
+    const isTerminalError = error.code === "not_found" || error.code === "not_open";
+    const keepPhase = !isTerminalError && this.state.checkout;
+    const phase = keepPhase ? this.state.phase : "closed";
+    this.setState({ error, phase, message: error.message, dismissedError: false });
+    this.reconcilePolling();
+  }
+  reconcilePolling() {
+    if (!this.autoPoll || this.destroyed) return;
+    if (isTerminalPhase(this.state.phase)) {
+      this.stopPolling();
+      return;
+    }
+    if (this.shouldPoll()) {
+      this.startPolling();
+    } else {
+      this.stopPolling();
+    }
+  }
+  /**
+   * Poll while an attempt is `processing`, or while it is `action_required`
+   * with a poll-completion action (approve_on_phone, scan_qr_code,
+   * display_payment_instructions, embed_iframe). Do NOT poll while waiting on
+   * the customer to submit (collect_otp), redirect, or run an SDK.
+   */
+  shouldPoll() {
+    if (this.state.phase === "processing") return true;
+    if (this.state.phase === "action_required") {
+      const action = this.state.checkout?.attempt?.next_action;
+      return action != null && actionCompletion(action) === "poll";
+    }
+    return false;
+  }
+  scheduleNextPoll() {
+    if (this.destroyed || !this.state.polling) return;
+    const delay = this.intervals[this.pollTick] ?? this.steady;
+    this.pollTick++;
+    const expiresAt = this.expiresAtMs();
+    if (expiresAt !== null && this.now() >= expiresAt) {
+      this.stopPolling();
+      return;
+    }
+    this.pollHandle = this.setTimeoutImpl(() => {
+      this.tickPoll().catch(() => void 0);
+    }, delay);
+  }
+  async tickPoll() {
+    if (this.destroyed || !this.state.polling || this.pollInFlight) return;
+    this.pollInFlight = true;
+    try {
+      await this.poll();
+    } finally {
+      this.pollInFlight = false;
+    }
+    if (this.state.polling && !isTerminalPhase(this.state.phase)) {
+      this.scheduleNextPoll();
+    }
+  }
+  expiresAtMs() {
+    const raw = this.state.checkout?.session.expires_at;
+    if (!raw) return null;
+    const ms = Date.parse(raw);
+    return Number.isNaN(ms) ? null : ms;
+  }
+  setState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.emit();
+  }
+  emit() {
+    const view = this.getView();
+    for (const listener of this.listeners) listener(view);
+  }
+};
+function toMessage(cause) {
+  if (cause instanceof Error) return cause.message;
+  return "Unexpected error.";
+}
+
+// src/redirect-effect.ts
+function performActionRedirect(action, deps = {}) {
+  const doc = deps.doc ?? document;
+  const navigate = deps.navigate ?? ((url) => window.location.assign(url));
+  if (!isHttps(action.url)) {
+    console.error(`Orqex: refused redirect to non-https URL "${action.url}".`);
+    return;
+  }
+  if (action.method === "POST") {
+    const form = doc.createElement("form");
+    form.method = "POST";
+    form.action = action.url;
+    form.style.display = "none";
+    for (const [name, value] of Object.entries(action.post_data ?? {})) {
+      const input = doc.createElement("input");
+      input.type = "hidden";
+      input.name = name;
+      input.value = typeof value === "string" ? value : JSON.stringify(value);
+      form.appendChild(input);
+    }
+    doc.body.appendChild(form);
+    form.submit();
+    return;
+  }
+  navigate(action.url);
+}
+function isHttps(url) {
+  try {
+    return new URL(url).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+// src/headless.ts
+function redirectActionOf(view) {
+  if (view.kind === "action" && view.ctx.completion === "redirect" && view.ctx.action.type === "redirect_to_url") {
+    return view.ctx.action;
+  }
+  return null;
+}
+var markerKey = (publicId) => `orqex:redirect:${publicId}`;
+function wireAutoResume(engine, publicId, ctx) {
+  const key = markerKey(publicId);
+  if (ctx.storage.getItem(key) !== null) {
+    ctx.storage.removeItem(key);
+    engine.resumeFromRedirect();
+  }
+  let handled = null;
+  const unsubscribe = engine.subscribe((view) => {
+    const action = redirectActionOf(view);
+    if (!action || !action.can_auto_redirect || view.kind !== "action") return;
+    const dedupe = `${view.ctx.attempt.id}:${action.type}`;
+    if (handled === dedupe) return;
+    handled = dedupe;
+    ctx.storage.setItem(key, view.ctx.attempt.id);
+    performActionRedirect(action, { navigate: (url) => ctx.win.location.assign(url), doc: ctx.win.document });
+  });
+  const onPageShow = () => {
+    const kind = engine.getView().kind;
+    if (kind === "action" || kind === "processing") engine.resumeFromRedirect();
+  };
+  ctx.win.addEventListener("pageshow", onPageShow);
+  return () => {
+    unsubscribe();
+    ctx.win.removeEventListener("pageshow", onPageShow);
+  };
+}
+function createHeadlessCheckout(config, options, deps = {}) {
+  const win = deps.win ?? window;
+  const engine = deps.engine ?? new CheckoutEngine(
+    new HttpTransport({
+      baseUrl: config.apiBaseUrl,
+      auth: { publishableKey: config.publishableKey, publicId: options.publicId },
+      locale: options.locale ?? (typeof navigator === "undefined" ? void 0 : navigator.language),
+      fetchImpl: deps.fetchImpl
+    })
+  );
+  let autoResumeTeardown = () => {
+  };
+  const facade = {
+    subscribe: (fn) => engine.subscribe(fn),
+    getView: () => engine.getView(),
+    pay: (input) => engine.pay(input),
+    authorize: (input) => engine.authorize(input),
+    poll: () => engine.poll(),
+    selectCountry: (country) => engine.selectCountry(country),
+    selectCurrency: (currency) => engine.selectCurrency(currency),
+    listCountries: () => engine.listCountries(),
+    resumeFromRedirect: () => engine.resumeFromRedirect(),
+    startPolling: () => engine.startPolling(),
+    stopPolling: () => engine.stopPolling(),
+    performRedirect: () => {
+      const action = redirectActionOf(engine.getView());
+      if (action) performActionRedirect(action, { navigate: (url) => win.location.assign(url), doc: win.document });
+    },
+    destroy: () => {
+      autoResumeTeardown();
+      engine.destroy();
+    }
+  };
+  if (options.autoResume) {
+    autoResumeTeardown = wireAutoResume(engine, options.publicId, { storage: deps.storage ?? win.sessionStorage, win });
+  }
+  engine.load();
+  return facade;
+}
+
+// src/redirect.ts
+var defaultNavigate = (url) => {
+  window.location.assign(url);
+};
+function redirectToCheckout(config, options, navigate = defaultNavigate) {
+  if (!options.publicId) {
+    throw new Error("Orqex: redirectToCheckout requires a publicId.");
+  }
+  navigate(buildRedirectUrl(config, options.publicId));
+}
+
+// src/orqex.ts
+function Orqex(publishableKey, options) {
+  const config = resolveConfig(publishableKey, options);
+  const bus = new EventBus();
+  const embedded = new EmbeddedController({ config, bus });
+  return {
+    mount(target, mountOptions) {
+      embedded.mount(target, mountOptions);
+    },
+    redirectToCheckout(redirectOptions) {
+      redirectToCheckout(config, redirectOptions);
+    },
+    on(event, handler) {
+      return bus.on(event, handler);
+    },
+    unmount() {
+      embedded.unmount();
+    },
+    createEngine(engineOptions) {
+      return createHeadlessCheckout(config, engineOptions);
+    }
+  };
+}
+
+// src/embed-projection.ts
+function projectEmbedMessage(view, lastKey) {
+  let projection = null;
+  if (view.kind === "succeeded") {
+    const status = String(view.ctx.status);
+    projection = { message: successMessage(status), key: `succeeded:${status}` };
+  } else if (view.kind === "failed") {
+    const status = String(view.ctx.status);
+    projection = { message: errorMessage(status, view.ctx.message), key: `failed:${status}` };
+  } else if (view.kind === "closed") {
+    const status = String(view.ctx.status);
+    projection = { message: closeMessage(status), key: `closed:${status}` };
+  }
+  if (!projection || projection.key === lastKey) return null;
+  return projection;
+}
+
+// src/index.ts
+var SDK_VERSION = "0.0.1";
+
+export { Orqex, SDK_VERSION, projectEmbedMessage };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map