@syndew/oluso-sdk 0.0.0-stage → 0.1.0

package/dist/react.js

@@ -0,0 +1,1674 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.tsx
+var react_exports = {};
+__export(react_exports, {
+  Journey: () => Journey,
+  JourneyEmbed: () => JourneyEmbed,
+  JourneyForm: () => JourneyForm,
+  OlusoProvider: () => OlusoProvider,
+  useJourney: () => useJourney,
+  useOluso: () => useOluso
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = __toESM(require("react"));
+
+// src/client.ts
+var OlusoClient = class {
+  constructor(config) {
+    this.listeners = /* @__PURE__ */ new Map();
+    if (!config.serverUrl) {
+      throw new Error("serverUrl is required");
+    }
+    this.config = {
+      ...config,
+      serverUrl: config.serverUrl.replace(/\/$/, "")
+      // Remove trailing slash
+    };
+    this.fetchFn = config.fetch || globalThis.fetch.bind(globalThis);
+  }
+  /**
+   * Get journey information including form fields. Journeys are named by slug.
+   */
+  async getJourney(slug) {
+    const response = await this.request(`/api/public/journeys/${encodeURIComponent(slug)}`);
+    return response;
+  }
+  /**
+   * Submit data to a data collection journey (waitlist, contact, survey, etc.)
+   */
+  async submit(slug, data, options) {
+    try {
+      const result = await this.request(`/api/public/journeys/${encodeURIComponent(slug)}/submit`, {
+        method: "POST",
+        body: {
+          data,
+          metadata: {
+            ...options?.metadata,
+            referrer: typeof document !== "undefined" ? document.referrer : void 0,
+            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+          },
+          honeypot: options?.honeypot
+        }
+      });
+      this.emit({
+        type: "submission:success",
+        slug,
+        data: result
+      });
+      return result;
+    } catch (error) {
+      this.emit({
+        type: "submission:error",
+        slug,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  }
+  /**
+   * Start a multi-step journey and run its first step. Without data the session's `step`
+   * is the first step to render; with data, that is the first step's input.
+   */
+  async startJourney(slug, data) {
+    const session = await this.request(
+      `/api/public/journeys/${encodeURIComponent(slug)}/start`,
+      { method: "POST", body: { data } }
+    );
+    this.emit({
+      type: "journey:started",
+      slug: session.slug,
+      sessionId: session.sessionId,
+      data: session
+    });
+    return session;
+  }
+  /**
+   * Start a sign-in (or any authentication) journey for a public client. When the session completes it carries an
+   * authorization code, redeemed at the token endpoint with the PKCE verifier and redirect_uri "postmessage". Use
+   * this when your app keeps its own tokens; OlusoAuth.mountSignIn does the whole round trip for you.
+   */
+  async startAuthJourney(slug, auth, data) {
+    const session = await this.request(
+      `/api/public/journeys/${encodeURIComponent(slug)}/start`,
+      {
+        method: "POST",
+        body: { data, clientId: auth.clientId, codeChallenge: auth.codeChallenge, codeChallengeMethod: "S256", scope: auth.scope }
+      }
+    );
+    this.emit({ type: "journey:started", slug: session.slug, sessionId: session.sessionId, data: session });
+    return session;
+  }
+  /**
+   * Submit input (or an action such as "resend") for the session's current step.
+   * The result is the session afterwards: the next step to render, or the completion.
+   */
+  async submitStep(sessionId, data, action) {
+    const result = await this.request(
+      `/api/public/journeys/sessions/${encodeURIComponent(sessionId)}/step`,
+      { method: "POST", body: { data, action } }
+    );
+    this.emit({
+      type: result.completed ? "journey:completed" : result.success ? "journey:step" : "journey:error",
+      slug: result.slug,
+      sessionId,
+      data: result
+    });
+    return result;
+  }
+  /**
+   * Submit the current step the way a form posts it: every field, files under their field's name, and the
+   * clicked button's name and value. Use this for steps with file fields; `action` is a step action such as "init".
+   */
+  async submitStepForm(sessionId, form, action) {
+    if (action) form.set("__journey_action", action);
+    const result = await this.request(
+      `/api/public/journeys/sessions/${encodeURIComponent(sessionId)}/step`,
+      { method: "POST", body: form }
+    );
+    this.emit({
+      type: result.completed ? "journey:completed" : result.success ? "journey:step" : "journey:error",
+      slug: result.slug,
+      sessionId,
+      data: result
+    });
+    return result;
+  }
+  /** The server this client talks to */
+  get serverUrl() {
+    return this.config.serverUrl;
+  }
+  /**
+   * Get where a multi-step session stands (status, current step), without running it
+   */
+  async getSession(sessionId) {
+    return this.request(`/api/public/journeys/sessions/${encodeURIComponent(sessionId)}`);
+  }
+  /**
+   * URL of the hosted journey page (/journey/start/{slug}) to redirect to
+   */
+  getJourneyUrl(slug, options) {
+    const params = new URLSearchParams();
+    if (this.config.tenant) params.set("tenant", this.config.tenant);
+    if (options?.redirectUri) {
+      params.set("redirect_uri", options.redirectUri);
+    }
+    if (options?.state) {
+      params.set("state", options.state);
+    }
+    return `${this.config.serverUrl}/journey/start/${encodeURIComponent(slug)}?${params}`;
+  }
+  /**
+   * URL of the hosted journey page (/journey/start/{slug}) for an iframe
+   */
+  getEmbedUrl(slug, options) {
+    const params = new URLSearchParams({ embed: "true" });
+    if (this.config.tenant) params.set("tenant", this.config.tenant);
+    if (options?.theme) {
+      params.set("theme", options.theme);
+    }
+    if (options?.hideHeader) {
+      params.set("hideHeader", "true");
+    }
+    return `${this.config.serverUrl}/journey/start/${encodeURIComponent(slug)}?${params}`;
+  }
+  /**
+   * Subscribe to SDK events
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+    return () => {
+      this.listeners.get(event)?.delete(listener);
+    };
+  }
+  /**
+   * Unsubscribe from SDK events
+   */
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event) {
+    this.listeners.get(event.type)?.forEach((listener) => listener(event));
+    this.listeners.get("*")?.forEach((listener) => listener(event));
+  }
+  async request(path, options) {
+    const url = `${this.config.serverUrl}${path}`;
+    const method = options?.method || "GET";
+    const isForm = typeof FormData !== "undefined" && options?.body instanceof FormData;
+    const headers = {};
+    if (this.config.tenant) {
+      headers["X-Tenant-ID"] = this.config.tenant;
+    }
+    if (!isForm) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.config.apiKey) {
+      headers["X-API-Key"] = this.config.apiKey;
+    }
+    if (this.config.headers) {
+      Object.assign(headers, await this.config.headers({ method, url }));
+    }
+    const response = await this.fetchFn(url, {
+      method,
+      headers,
+      body: options?.body === void 0 ? void 0 : isForm ? options.body : JSON.stringify(options.body),
+      credentials: "include"
+      // Include cookies for session management
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      throw new OlusoError(
+        error.message || `Request failed: ${response.status}`,
+        response.status,
+        error.code,
+        error.errors
+      );
+    }
+    return response.json();
+  }
+};
+var OlusoError = class extends Error {
+  constructor(message, status, code, fieldErrors) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.fieldErrors = fieldErrors;
+    this.name = "OlusoError";
+  }
+};
+
+// src/journey/conditions.ts
+var ALIASES = {
+  eq: "eq",
+  equals: "eq",
+  "==": "eq",
+  "=": "eq",
+  ne: "ne",
+  neq: "ne",
+  notequals: "ne",
+  "!=": "ne",
+  gt: "gt",
+  ">": "gt",
+  greaterthan: "gt",
+  gte: "gte",
+  ">=": "gte",
+  greaterthanorequals: "gte",
+  lt: "lt",
+  "<": "lt",
+  lessthan: "lt",
+  lte: "lte",
+  "<=": "lte",
+  lessthanorequals: "lte",
+  contains: "contains",
+  notcontains: "not_contains",
+  "!contains": "not_contains",
+  startswith: "starts_with",
+  endswith: "ends_with",
+  exists: "exists",
+  notnull: "exists",
+  isset: "exists",
+  notexists: "not_exists",
+  null: "not_exists",
+  isnotset: "not_exists",
+  empty: "empty",
+  notempty: "not_empty",
+  in: "in",
+  notin: "not_in",
+  "!in": "not_in",
+  regex: "regex",
+  matches: "regex",
+  true: "true",
+  false: "false"
+};
+function normalizeOperator(op) {
+  if (!op) return void 0;
+  return ALIASES[op.trim().toLowerCase().replace(/_/g, "")];
+}
+var same = (a, b) => a.localeCompare(b, void 0, { sensitivity: "accent" }) === 0;
+function order(actual, expected) {
+  if (expected === void 0) return void 0;
+  const a = Number(actual);
+  const e = Number(expected);
+  if (actual.trim() !== "" && expected.trim() !== "" && !Number.isNaN(a) && !Number.isNaN(e)) return a === e ? 0 : a < e ? -1 : 1;
+  const ad = Date.parse(actual);
+  const ed = Date.parse(expected);
+  if (!Number.isNaN(ad) && !Number.isNaN(ed)) return ad === ed ? 0 : ad < ed ? -1 : 1;
+  return actual.localeCompare(expected, void 0, { sensitivity: "accent" });
+}
+function compare(actual, op, expected) {
+  const lower = actual.toLowerCase();
+  const want = (expected ?? "").toLowerCase();
+  switch (op) {
+    case "eq":
+      return same(actual, expected ?? "");
+    case "ne":
+      return !same(actual, expected ?? "");
+    case "gt": {
+      const o = order(actual, expected);
+      return o !== void 0 && o > 0;
+    }
+    case "gte": {
+      const o = order(actual, expected);
+      return o !== void 0 && o >= 0;
+    }
+    case "lt": {
+      const o = order(actual, expected);
+      return o !== void 0 && o < 0;
+    }
+    case "lte": {
+      const o = order(actual, expected);
+      return o !== void 0 && o <= 0;
+    }
+    case "contains":
+      return lower.includes(want);
+    case "not_contains":
+      return !lower.includes(want);
+    case "starts_with":
+      return lower.startsWith(want);
+    case "ends_with":
+      return lower.endsWith(want);
+    case "regex":
+      if (!expected) return false;
+      try {
+        return new RegExp(expected, "i").test(actual);
+      } catch {
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+function expectedList(expected) {
+  if (!expected || !expected.trim()) return [];
+  const trimmed = expected.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return parsed.map(String);
+    } catch {
+      return [];
+    }
+  }
+  return trimmed.split(",").map((v) => v.trim()).filter(Boolean);
+}
+var truthy = (v) => v.toLowerCase() !== "false" && v !== "0";
+function conditionMet(condition, values) {
+  const op = normalizeOperator(condition.operator);
+  const present = values.filter((v) => v !== "");
+  const members = () => present.flatMap((v) => v.split(",").map((p) => p.trim()).filter(Boolean));
+  switch (op) {
+    case "exists":
+    case "not_empty":
+      return present.length > 0;
+    case "not_exists":
+    case "empty":
+      return present.length === 0;
+    case "ne":
+      return !present.some((v) => compare(v, "eq", condition.value));
+    case "not_contains":
+      return !present.some((v) => compare(v, "contains", condition.value));
+    case "in": {
+      const list = expectedList(condition.value);
+      return members().some((m) => list.some((e) => same(m, e)));
+    }
+    case "not_in": {
+      const list = expectedList(condition.value);
+      return !members().some((m) => list.some((e) => same(m, e)));
+    }
+    case "true":
+      return present.some(truthy);
+    case "false":
+      return !present.some(truthy);
+    case void 0:
+      return false;
+    default:
+      return present.some((v) => compare(v, op, condition.value));
+  }
+}
+
+// src/journey/styles.ts
+var JOURNEY_STYLES = `
+.oluso-journey {
+  --oluso-accent: #4f46e5;
+  --oluso-accent-contrast: #ffffff;
+  --oluso-fg: #111827;
+  --oluso-muted: #6b7280;
+  --oluso-bg: #ffffff;
+  --oluso-field-bg: #ffffff;
+  --oluso-border: #d1d5db;
+  --oluso-danger: #b91c1c;
+  --oluso-danger-bg: #fef2f2;
+  --oluso-notice-bg: #eff6ff;
+  --oluso-notice: #1d4ed8;
+  --oluso-radius: 8px;
+  --oluso-gap: 14px;
+  --oluso-font: inherit;
+  font-family: var(--oluso-font);
+  color: var(--oluso-fg);
+  font-size: 15px;
+  line-height: 1.5;
+}
+.oluso-journey[data-theme="dark"] {
+  --oluso-fg: #f3f4f6;
+  --oluso-muted: #9ca3af;
+  --oluso-bg: #111827;
+  --oluso-field-bg: #1f2937;
+  --oluso-border: #374151;
+  --oluso-danger: #fca5a5;
+  --oluso-danger-bg: rgba(185, 28, 28, 0.15);
+  --oluso-notice-bg: rgba(59, 130, 246, 0.15);
+  --oluso-notice: #93c5fd;
+}
+@media (prefers-color-scheme: dark) {
+  .oluso-journey[data-theme="auto"] {
+    --oluso-fg: #f3f4f6;
+    --oluso-muted: #9ca3af;
+    --oluso-bg: #111827;
+    --oluso-field-bg: #1f2937;
+    --oluso-border: #374151;
+    --oluso-danger: #fca5a5;
+    --oluso-danger-bg: rgba(185, 28, 28, 0.15);
+    --oluso-notice-bg: rgba(59, 130, 246, 0.15);
+    --oluso-notice: #93c5fd;
+  }
+}
+.oluso-journey *, .oluso-journey *::before, .oluso-journey *::after { box-sizing: border-box; }
+.oluso-journey__form { display: flex; flex-direction: column; gap: var(--oluso-gap); margin: 0; }
+.oluso-journey__title { font-size: 1.25em; font-weight: 600; margin: 0; }
+.oluso-journey__description { color: var(--oluso-muted); margin: 0; white-space: pre-line; }
+.oluso-journey__alert { border-radius: var(--oluso-radius); padding: 10px 12px; margin: 0; }
+.oluso-journey__alert--error { background: var(--oluso-danger-bg); color: var(--oluso-danger); }
+.oluso-journey__alert--notice { background: var(--oluso-notice-bg); color: var(--oluso-notice); }
+.oluso-journey__group { display: flex; flex-direction: column; gap: var(--oluso-gap); border: 0; margin: 0; padding: 0; }
+.oluso-journey__field { display: flex; flex-direction: column; gap: 6px; }
+.oluso-journey__field[hidden] { display: none; }
+.oluso-journey__label { font-weight: 500; }
+.oluso-journey__required { color: var(--oluso-danger); margin-left: 2px; }
+.oluso-journey__input, .oluso-journey__select, .oluso-journey__textarea {
+  width: 100%; font: inherit; color: var(--oluso-fg); background: var(--oluso-field-bg);
+  border: 1px solid var(--oluso-border); border-radius: var(--oluso-radius); padding: 9px 11px; min-height: 40px;
+}
+.oluso-journey__input:focus, .oluso-journey__select:focus, .oluso-journey__textarea:focus {
+  outline: 2px solid var(--oluso-accent); outline-offset: 1px; border-color: transparent;
+}
+.oluso-journey__input[aria-invalid="true"], .oluso-journey__select[aria-invalid="true"], .oluso-journey__textarea[aria-invalid="true"] {
+  border-color: var(--oluso-danger);
+}
+.oluso-journey__input--otp { letter-spacing: 0.4em; font-variant-numeric: tabular-nums; text-align: center; font-size: 1.2em; }
+.oluso-journey__phone { display: flex; gap: 8px; }
+.oluso-journey__phone .oluso-journey__select { width: auto; max-width: 45%; }
+.oluso-journey__choices { display: flex; flex-direction: column; gap: 8px; }
+.oluso-journey__choice { display: flex; gap: 10px; align-items: flex-start; cursor: pointer; }
+.oluso-journey__choice input { margin-top: 3px; accent-color: var(--oluso-accent); }
+.oluso-journey__choice-description { display: block; color: var(--oluso-muted); font-size: 0.9em; }
+.oluso-journey__help, .oluso-journey__hint { color: var(--oluso-muted); font-size: 0.875em; margin: 0; }
+.oluso-journey__error { color: var(--oluso-danger); font-size: 0.875em; margin: 0; }
+.oluso-journey__content { margin: 0; white-space: pre-line; }
+.oluso-journey__actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+.oluso-journey__button {
+  font: inherit; font-weight: 500; border-radius: var(--oluso-radius); padding: 9px 16px; min-height: 40px; cursor: pointer;
+  border: 1px solid var(--oluso-border); background: var(--oluso-field-bg); color: var(--oluso-fg);
+}
+.oluso-journey__button--primary { background: var(--oluso-accent); color: var(--oluso-accent-contrast); border-color: var(--oluso-accent); }
+.oluso-journey__button--primary:only-child, .oluso-journey__actions--stacked .oluso-journey__button--primary { flex: 1 1 auto; }
+.oluso-journey__button--link { background: none; border: 0; color: var(--oluso-accent); padding: 4px 0; min-height: 0; }
+.oluso-journey__button--cancel { background: none; }
+.oluso-journey__button:disabled { opacity: 0.6; cursor: progress; }
+.oluso-journey__enter { position: absolute; left: -10000px; width: 1px; height: 1px; overflow: hidden; }
+.oluso-journey__action-line { display: flex; flex-wrap: wrap; gap: 6px; align-items: baseline; margin: 0; }
+.oluso-journey__links { display: flex; flex-wrap: wrap; gap: 12px; font-size: 0.9em; }
+.oluso-journey__links a { color: var(--oluso-accent); }
+.oluso-journey__qr { display: flex; flex-direction: column; align-items: center; gap: 8px; }
+.oluso-journey__qr img { width: 180px; height: 180px; background: #fff; padding: 8px; border-radius: var(--oluso-radius); }
+.oluso-journey__code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; word-break: break-all; }
+.oluso-journey__codes { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 6px; margin: 0; padding: 0; list-style: none; }
+.oluso-journey__codes li { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; padding: 6px 8px; border: 1px solid var(--oluso-border); border-radius: 6px; text-align: center; }
+.oluso-journey__status { color: var(--oluso-muted); text-align: center; padding: 16px 0; }
+.oluso-journey__done { text-align: center; padding: 8px 0; }
+`;
+var injected = false;
+function injectJourneyStyles() {
+  if (injected || typeof document === "undefined") return;
+  const style = document.createElement("style");
+  style.setAttribute("data-oluso-journey", "");
+  style.textContent = JOURNEY_STYLES;
+  document.head.appendChild(style);
+  injected = true;
+}
+
+// src/journey/webauthn.ts
+function base64UrlToBuffer(value) {
+  const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes.buffer;
+}
+function bufferToBase64Url(buffer) {
+  if (!buffer) return null;
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function credentialDescriptors(list) {
+  if (!Array.isArray(list)) return void 0;
+  return list.map((c) => ({
+    type: c.type ?? "public-key",
+    id: base64UrlToBuffer(String(c.id)),
+    transports: c.transports
+  }));
+}
+function requestOptions(publicKey) {
+  return {
+    ...publicKey,
+    challenge: base64UrlToBuffer(String(publicKey.challenge)),
+    allowCredentials: credentialDescriptors(publicKey.allowCredentials)
+  };
+}
+function creationOptions(publicKey) {
+  const user = publicKey.user ?? {};
+  return {
+    ...publicKey,
+    challenge: base64UrlToBuffer(String(publicKey.challenge)),
+    user: { ...user, id: base64UrlToBuffer(String(user.id)) },
+    excludeCredentials: credentialDescriptors(publicKey.excludeCredentials)
+  };
+}
+async function getAssertion(publicKey) {
+  const credential = await navigator.credentials.get({ publicKey: requestOptions(publicKey) });
+  if (!credential) throw new Error("No passkey was chosen");
+  const response = credential.response;
+  return JSON.stringify({
+    id: credential.id,
+    rawId: bufferToBase64Url(credential.rawId),
+    type: credential.type,
+    response: {
+      clientDataJSON: bufferToBase64Url(response.clientDataJSON),
+      authenticatorData: bufferToBase64Url(response.authenticatorData),
+      signature: bufferToBase64Url(response.signature),
+      userHandle: bufferToBase64Url(response.userHandle)
+    },
+    authenticatorAttachment: credential.authenticatorAttachment ?? null
+  });
+}
+async function createCredential(publicKey) {
+  const credential = await navigator.credentials.create({ publicKey: creationOptions(publicKey) });
+  if (!credential) throw new Error("No passkey was created");
+  const response = credential.response;
+  return JSON.stringify({
+    id: credential.id,
+    rawId: bufferToBase64Url(credential.rawId),
+    type: credential.type,
+    response: {
+      clientDataJSON: bufferToBase64Url(response.clientDataJSON),
+      attestationObject: bufferToBase64Url(response.attestationObject),
+      transports: typeof response.getTransports === "function" ? response.getTransports() : void 0
+    },
+    authenticatorAttachment: credential.authenticatorAttachment ?? null
+  });
+}
+
+// src/journey/render.ts
+var DEFAULT_LABELS = {
+  loading: "Loading\u2026",
+  completed: "All done. Thank you.",
+  failed: "Something went wrong. Please try again.",
+  expired: "This session has expired. Please start again.",
+  restart: "Start again",
+  takePhoto: "Take a photo",
+  copy: "Copy",
+  copied: "Copied",
+  passkey: "Use your passkey",
+  retry: "Try again",
+  waiting: "Waiting\u2026",
+  unavailable: "This step can\u2019t be shown here."
+};
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text !== void 0) node.textContent = text;
+  return node;
+}
+var uid = 0;
+function mountJourney(container, options) {
+  const labels = { ...DEFAULT_LABELS, ...options.labels };
+  const client = options.client;
+  const id = `oluso-j${++uid}`;
+  let session;
+  let destroyed = false;
+  let timers = [];
+  if (!options.unstyled) injectJourneyStyles();
+  const root = el("div", "oluso-journey");
+  root.setAttribute("data-theme", options.theme ?? "auto");
+  container.appendChild(root);
+  const clearTimers = () => {
+    timers.forEach((t) => window.clearInterval(t));
+    timers = [];
+  };
+  const status = (text) => {
+    root.replaceChildren(el("p", "oluso-journey__status", text));
+  };
+  const fail = (error) => {
+    const err = error instanceof Error ? error : new Error(String(error));
+    options.onError?.(err, session);
+    return err;
+  };
+  const canRestart = () => Boolean(options.slug || options.start);
+  const begin = async () => {
+    clearTimers();
+    status(labels.loading);
+    try {
+      const started = options.start ? await options.start() : options.slug ? await client.startJourney(options.slug, options.data) : options.session;
+      if (!started) throw new Error("mountJourney needs a slug, a session or a start function");
+      await show(started);
+    } catch (error) {
+      showProblem(fail(error).message);
+    }
+  };
+  const show = async (next) => {
+    if (destroyed) return;
+    clearTimers();
+    session = next;
+    options.onStep?.(next);
+    if (next.completed) {
+      if (next.redirectUrl) {
+        await options.onComplete?.(next);
+        redirect(next.redirectUrl, next);
+        return;
+      }
+      if (options.showCompletion !== false) {
+        const done = el("div", "oluso-journey__done");
+        done.appendChild(el("p", "oluso-journey__content", next.message || labels.completed));
+        root.replaceChildren(done);
+      } else {
+        root.replaceChildren();
+      }
+      await options.onComplete?.(next);
+      return;
+    }
+    if (next.status !== "in_progress") {
+      const message = next.status === "expired" ? labels.expired : next.errorDescription || labels.failed;
+      fail(new Error(message));
+      showProblem(message);
+      return;
+    }
+    if (next.redirectUrl) {
+      redirect(next.redirectUrl, next);
+      return;
+    }
+    if (next.step?.form) {
+      renderForm(next.step.form);
+    } else if (next.step?.html) {
+      renderHtml(next.step.html);
+    } else {
+      showProblem(labels.unavailable);
+    }
+  };
+  const redirect = (url, current) => {
+    if (options.onRedirect) options.onRedirect(url, current);
+    else window.location.assign(url);
+  };
+  const showProblem = (message) => {
+    const box = el("div", "oluso-journey__form");
+    box.appendChild(el("p", "oluso-journey__alert oluso-journey__alert--error", message));
+    if (canRestart()) {
+      const again = el("button", "oluso-journey__button oluso-journey__button--primary", labels.restart);
+      again.type = "button";
+      again.addEventListener("click", () => void begin());
+      const row = el("div", "oluso-journey__actions");
+      row.appendChild(again);
+      box.appendChild(row);
+    }
+    root.replaceChildren(box);
+  };
+  const post = async (form, action) => {
+    if (!session) return;
+    const next = await client.submitStepForm(session.sessionId, form, action);
+    await show(next);
+  };
+  const submitting = (form, busy) => {
+    form.setAttribute("aria-busy", String(busy));
+    form.querySelectorAll("button").forEach((b) => b.disabled = busy);
+  };
+  const send = async (form, action, extra) => {
+    const data = action?.postsFields === false ? new FormData() : new FormData(form);
+    if (action?.name) data.append(action.name, action.value ?? "");
+    if (action?.values) for (const [k, v] of Object.entries(action.values)) data.append(k, v);
+    if (extra) for (const [k, v] of Object.entries(extra)) data.set(k, v);
+    submitting(form, true);
+    try {
+      await post(data);
+    } catch (error) {
+      submitting(form, false);
+      const message = fail(error).message;
+      let alert = form.querySelector("[data-oluso-request-error]");
+      if (!alert) {
+        alert = el("p", "oluso-journey__alert oluso-journey__alert--error");
+        alert.setAttribute("data-oluso-request-error", "");
+        alert.setAttribute("role", "alert");
+        form.prepend(alert);
+      }
+      alert.textContent = message;
+    }
+  };
+  const renderForm = (step) => {
+    const form = el("form", "oluso-journey__form");
+    if (step.title) form.appendChild(el("h2", "oluso-journey__title", step.title));
+    if (step.description) form.appendChild(el("p", "oluso-journey__description", step.description));
+    if (step.error) {
+      const alert = el("p", "oluso-journey__alert oluso-journey__alert--error", step.error);
+      alert.setAttribute("role", "alert");
+      form.appendChild(alert);
+    }
+    if (step.notice) {
+      const notice = el("p", "oluso-journey__alert oluso-journey__alert--notice", step.notice);
+      notice.setAttribute("role", "status");
+      form.appendChild(notice);
+    }
+    const wrappers = [];
+    for (const field of step.fields) {
+      const rendered = renderField(field);
+      if (!rendered) continue;
+      form.appendChild(rendered);
+      if (field.showWhen || field.showWhenAll?.length) wrappers.push({ field, wrapper: rendered });
+    }
+    if (step.widget) {
+      const widget = renderWidget(step.widget, form);
+      if (widget) form.appendChild(widget);
+    }
+    if (step.links.length > 0) {
+      const links = el("div", "oluso-journey__links");
+      for (const link of step.links) {
+        const a = el("a", void 0, link.label);
+        a.href = link.url;
+        a.target = "_blank";
+        a.rel = "noopener noreferrer";
+        links.appendChild(a);
+      }
+      form.appendChild(links);
+    }
+    if (step.actions.length > 0) {
+      const row = el("div", "oluso-journey__actions");
+      const primary = step.actions.findIndex((a) => a.kind === "primary");
+      if (primary >= 0) {
+        const enter = el("button", "oluso-journey__enter");
+        enter.type = "submit";
+        enter.tabIndex = -1;
+        enter.setAttribute("aria-hidden", "true");
+        enter.dataset.olusoAction = String(primary);
+        form.prepend(enter);
+      }
+      const described = [];
+      step.actions.forEach((action, index) => {
+        const button = el("button", `oluso-journey__button oluso-journey__button--${action.kind}`, action.label);
+        button.type = "submit";
+        button.formNoValidate = action.skipValidation || action.postsFields === false;
+        button.dataset.olusoAction = String(index);
+        if (action.description) {
+          const line = el("p", "oluso-journey__action-line");
+          line.appendChild(el("span", "oluso-journey__help", action.description));
+          line.appendChild(button);
+          described.push(line);
+        } else {
+          row.appendChild(button);
+        }
+      });
+      if (row.childElementCount > 0) form.appendChild(row);
+      described.forEach((line) => form.appendChild(line));
+    }
+    const applyConditions = () => {
+      for (const { field, wrapper } of wrappers) {
+        const conditions = [...field.showWhen ? [field.showWhen] : [], ...field.showWhenAll ?? []];
+        const shown = conditions.every((c) => conditionMet(c, currentValues(form.elements.namedItem(c.field))));
+        wrapper.hidden = !shown;
+        wrapper.querySelectorAll("input, select, textarea").forEach((input) => {
+          input.disabled = !shown || input.dataset.olusoReadonly === "true";
+        });
+      }
+    };
+    form.addEventListener("input", (event) => {
+      applyConditions();
+      const target = event.target;
+      const wrapper = target.closest(".oluso-journey__field");
+      wrapper?.querySelectorAll('[aria-invalid="true"]').forEach((n) => n.removeAttribute("aria-invalid"));
+      wrapper?.querySelector(".oluso-journey__error")?.remove();
+    });
+    form.addEventListener("change", applyConditions);
+    applyConditions();
+    form.addEventListener("submit", (event) => {
+      event.preventDefault();
+      const submitter = event.submitter;
+      const index = submitter?.dataset.olusoAction;
+      const action = index !== void 0 ? step.actions[Number(index)] : step.actions.find((a) => a.kind === "primary");
+      if (action?.confirm && submitter && submitter.dataset.olusoConfirming !== "true") {
+        submitter.dataset.olusoConfirming = "true";
+        submitter.textContent = action.confirm;
+        submitter.setAttribute("aria-live", "polite");
+        return;
+      }
+      void send(form, action);
+    });
+    root.replaceChildren(form);
+    const focus = form.querySelector("[autofocus]") ?? form.querySelector("input:not([type=hidden]):not([disabled]), select, textarea");
+    focus?.focus({ preventScroll: true });
+  };
+  const renderField = (field) => {
+    const fieldId = `${id}-${field.name}`;
+    if (field.type === "hidden") {
+      const input = el("input");
+      input.type = "hidden";
+      input.name = field.name;
+      input.value = field.value ?? "";
+      return input;
+    }
+    const wrapper = el("div", "oluso-journey__field");
+    if (field.group) wrapper.dataset.group = field.group;
+    if (field.type === "content") {
+      if (field.label) wrapper.appendChild(el("p", "oluso-journey__label", field.label));
+      wrapper.appendChild(el("p", "oluso-journey__content", field.value ?? ""));
+      return wrapper;
+    }
+    const label = () => {
+      if (!field.label) return;
+      const l = el("label", "oluso-journey__label", field.label);
+      l.htmlFor = fieldId;
+      if (field.required) {
+        const marker = el("span", "oluso-journey__required", "*");
+        marker.setAttribute("aria-hidden", "true");
+        l.appendChild(marker);
+      }
+      wrapper.appendChild(l);
+    };
+    const describedBy = [];
+    const common = (input) => {
+      input.id = fieldId;
+      input.name = field.name;
+      input.required = field.required;
+      if (field.readOnly) {
+        if (input instanceof HTMLSelectElement) input.disabled = true;
+        else input.readOnly = true;
+        input.dataset.olusoReadonly = String(input instanceof HTMLSelectElement);
+      }
+      if (field.autofocus) input.autofocus = true;
+      if (field.autocomplete) input.setAttribute("autocomplete", field.autocomplete);
+      if (field.error) input.setAttribute("aria-invalid", "true");
+    };
+    switch (field.type) {
+      case "textarea": {
+        label();
+        const input = el("textarea", "oluso-journey__textarea");
+        common(input);
+        input.value = field.value ?? "";
+        if (field.placeholder) input.placeholder = field.placeholder;
+        if (field.rows) input.rows = field.rows;
+        if (field.minLength) input.minLength = field.minLength;
+        if (field.maxLength) input.maxLength = field.maxLength;
+        wrapper.appendChild(input);
+        break;
+      }
+      case "select": {
+        label();
+        const input = el("select", "oluso-journey__select");
+        common(input);
+        const blank = el("option", void 0, field.placeholder ?? "");
+        blank.value = "";
+        input.appendChild(blank);
+        for (const option of field.options ?? []) {
+          const o = el("option", void 0, option.label);
+          o.value = option.value;
+          o.disabled = option.disabled;
+          o.selected = option.value === field.value;
+          input.appendChild(o);
+        }
+        wrapper.appendChild(input);
+        break;
+      }
+      case "radio": {
+        const group = el("fieldset", "oluso-journey__group");
+        if (field.label) {
+          const legend = el("legend", "oluso-journey__label", field.label);
+          if (field.required) legend.appendChild(el("span", "oluso-journey__required", "*"));
+          group.appendChild(legend);
+        }
+        const choices = el("div", "oluso-journey__choices");
+        (field.options ?? []).forEach((option, i) => {
+          const choice = el("label", "oluso-journey__choice");
+          const input = el("input");
+          input.type = "radio";
+          input.name = field.name;
+          input.value = option.value;
+          input.id = `${fieldId}-${i}`;
+          input.required = field.required;
+          input.disabled = option.disabled || field.readOnly;
+          input.checked = option.value === field.value;
+          const text = el("span", void 0, option.label);
+          if (option.description) text.appendChild(el("span", "oluso-journey__choice-description", option.description));
+          choice.append(input, text);
+          choices.appendChild(choice);
+        });
+        group.appendChild(choices);
+        wrapper.appendChild(group);
+        break;
+      }
+      case "checkbox": {
+        if (field.placeholder) label();
+        const choice = el("label", "oluso-journey__choice");
+        const input = el("input");
+        input.type = "checkbox";
+        input.value = "true";
+        common(input);
+        input.checked = field.value === "true";
+        if (field.readOnly) {
+          input.setAttribute("aria-readonly", "true");
+          input.addEventListener("click", (e) => e.preventDefault());
+        }
+        const text = el("span", void 0, field.placeholder ?? field.label ?? "");
+        if (!field.placeholder && field.required) text.appendChild(el("span", "oluso-journey__required", "*"));
+        choice.append(input, text);
+        wrapper.appendChild(choice);
+        break;
+      }
+      case "file": {
+        label();
+        const input = el("input", "oluso-journey__input");
+        input.type = "file";
+        common(input);
+        input.readOnly = false;
+        input.disabled = field.readOnly;
+        if (field.accept) input.accept = field.accept;
+        input.multiple = (field.maxFiles ?? 1) > 1;
+        input.required = field.required && !field.capture;
+        wrapper.appendChild(input);
+        if (field.capture && !field.readOnly) {
+          const cameraLabel = el("label", "oluso-journey__hint", labels.takePhoto);
+          cameraLabel.htmlFor = `${fieldId}-camera`;
+          const camera = el("input", "oluso-journey__input");
+          camera.type = "file";
+          camera.id = `${fieldId}-camera`;
+          camera.name = field.name;
+          camera.accept = "image/*";
+          camera.setAttribute("capture", field.capture);
+          wrapper.append(cameraLabel, camera);
+        }
+        break;
+      }
+      case "tel": {
+        label();
+        if (field.countries && field.countries.length > 0) {
+          const row = el("div", "oluso-journey__phone");
+          const country = el("select", "oluso-journey__select");
+          country.name = `${field.name}__country`;
+          country.setAttribute("aria-label", field.label ?? field.name);
+          country.disabled = field.readOnly;
+          for (const c of field.countries) {
+            const o = el("option", void 0, `${c.flag ? c.flag + " " : ""}${c.name} (${c.dialCode})`);
+            o.value = c.code;
+            o.selected = c.code === field.country;
+            country.appendChild(o);
+          }
+          const input = el("input", "oluso-journey__input");
+          input.type = "tel";
+          input.inputMode = "tel";
+          common(input);
+          input.value = field.value ?? "";
+          if (field.placeholder) input.placeholder = field.placeholder;
+          row.append(country, input);
+          wrapper.appendChild(row);
+        } else {
+          const input = textInput(field, "tel");
+          common(input);
+          wrapper.appendChild(input);
+        }
+        break;
+      }
+      case "otp": {
+        label();
+        const input = el("input", "oluso-journey__input oluso-journey__input--otp");
+        input.type = "text";
+        input.inputMode = "numeric";
+        common(input);
+        input.setAttribute("autocomplete", field.autocomplete ?? "one-time-code");
+        if (field.maxLength) {
+          input.maxLength = field.maxLength;
+          input.minLength = field.minLength ?? field.maxLength;
+        }
+        input.pattern = field.pattern ?? "[0-9]*";
+        input.value = field.value ?? "";
+        wrapper.appendChild(input);
+        break;
+      }
+      default: {
+        label();
+        const known = ["text", "email", "password", "number", "date", "url", "tel"];
+        const input = textInput(field, known.includes(field.type) ? field.type : "text");
+        common(input);
+        wrapper.appendChild(input);
+      }
+    }
+    if (field.description) {
+      const help = el("p", "oluso-journey__help", field.description);
+      help.id = `${fieldId}-help`;
+      describedBy.push(help.id);
+      wrapper.appendChild(help);
+    }
+    if (field.hint) {
+      const hint = el("p", "oluso-journey__hint", field.hint);
+      hint.id = `${fieldId}-hint`;
+      describedBy.push(hint.id);
+      wrapper.appendChild(hint);
+    }
+    if (field.error) {
+      const error = el("p", "oluso-journey__error", field.error);
+      error.id = `${fieldId}-error`;
+      describedBy.push(error.id);
+      wrapper.appendChild(error);
+    }
+    if (describedBy.length > 0) {
+      Array.from(wrapper.querySelectorAll("[id]")).find((n) => n.id === fieldId)?.setAttribute("aria-describedby", describedBy.join(" "));
+    }
+    return wrapper;
+  };
+  const textInput = (field, type) => {
+    const input = el("input", "oluso-journey__input");
+    input.type = type;
+    input.value = field.value ?? "";
+    if (field.placeholder) input.placeholder = field.placeholder;
+    if (field.pattern) input.pattern = field.pattern;
+    if (field.patternError) {
+      input.title = field.patternError;
+      input.addEventListener("invalid", () => {
+        if (input.validity.patternMismatch) input.setCustomValidity(field.patternError);
+      });
+      input.addEventListener("input", () => input.setCustomValidity(""));
+    }
+    if (field.minLength) input.minLength = field.minLength;
+    if (field.maxLength) input.maxLength = field.maxLength;
+    if (field.min) input.min = field.min;
+    if (field.max) input.max = field.max;
+    if (type === "number") input.step = "any";
+    return input;
+  };
+  const renderWidget = (widget, form) => {
+    const data = widget.data ?? {};
+    const box = el("div", "oluso-journey__widget");
+    const result = (value) => {
+      if (!widget.resultField) return;
+      let input = Array.from(form.querySelectorAll("input[type=hidden]")).find((n) => n.name === widget.resultField) ?? null;
+      if (!input) {
+        input = el("input");
+        input.type = "hidden";
+        input.name = widget.resultField;
+        form.appendChild(input);
+      }
+      input.value = value;
+    };
+    switch (widget.type) {
+      case "webauthn_get":
+      case "webauthn_create": {
+        const run = el("button", "oluso-journey__button oluso-journey__button--primary", widget.submit?.label ?? labels.passkey);
+        run.type = "button";
+        const go = async () => {
+          run.disabled = true;
+          try {
+            const options2 = await webAuthnOptions(data);
+            const publicKey = options2.publicKey;
+            let extra = options2.extra;
+            const credential = widget.type === "webauthn_get" ? await getAssertion(publicKey) : await createCredential(publicKey);
+            result(credential);
+            const naming = data.credentialName;
+            if (naming?.field) {
+              const attachment = JSON.parse(credential).authenticatorAttachment;
+              const name = attachment === "platform" ? naming.platform : attachment === "cross-platform" ? naming.crossPlatform : naming.other;
+              (extra ?? (extra = {}))[naming.field] = name ?? "";
+            }
+            await send(form, widget.submit, extra);
+          } catch (error) {
+            run.disabled = false;
+            run.textContent = labels.retry;
+            options.onError?.(error instanceof Error ? error : new Error(String(error)), session);
+          }
+        };
+        run.addEventListener("click", () => void go());
+        box.appendChild(run);
+        if (typeof PublicKeyCredential !== "undefined") queueMicrotask(() => void go());
+        return box;
+      }
+      case "verification_connect": {
+        const options2 = data.options ?? {};
+        const reference = typeof data.referenceOption === "string" ? options2[data.referenceOption] : void 0;
+        const field = typeof data.referenceField === "string" ? data.referenceField : "reference_id";
+        const callback = async (withReference) => {
+          const values = new FormData();
+          if (withReference) values.set(field, reference == null ? "" : String(reference));
+          submitting(form, true);
+          try {
+            await post(values, "callback");
+          } catch (error) {
+            submitting(form, false);
+            fail(error);
+          }
+        };
+        const start = async () => {
+          await loadScript(String(data.scriptUrl));
+          const Ctor = window[typeof data.global === "string" ? data.global : "Connect"];
+          if (!Ctor) throw new Error("The verification widget could not be loaded");
+          const connect = new Ctor({
+            ...options2,
+            onSuccess: () => void callback(true),
+            onError: () => void callback(false),
+            onClose: () => void 0
+          });
+          connect.setup?.();
+          connect.open();
+          return connect;
+        };
+        let instance;
+        const open = () => {
+          if (instance) {
+            void instance.then((c) => c.open());
+            return;
+          }
+          instance = start();
+          instance.catch((error) => {
+            instance = void 0;
+            fail(error);
+          });
+        };
+        if (widget.submit) {
+          const button = el("button", `oluso-journey__button oluso-journey__button--${widget.submit.kind}`, widget.submit.label);
+          button.type = "button";
+          button.addEventListener("click", open);
+          box.appendChild(button);
+        }
+        open();
+        return box;
+      }
+      case "captcha": {
+        const target = el("div", "oluso-journey__captcha");
+        box.appendChild(target);
+        void renderCaptcha(target, data, (token) => {
+          result(token);
+          if (widget.submit) void send(form, widget.submit);
+        }).catch((error) => options.onError?.(error instanceof Error ? error : new Error(String(error)), session));
+        return box;
+      }
+      case "qr": {
+        const qr = el("div", "oluso-journey__qr");
+        if (typeof data.image === "string") {
+          const img = el("img");
+          img.src = data.image;
+          img.alt = "";
+          qr.appendChild(img);
+        }
+        if (typeof data.secret === "string") {
+          if (typeof data.secretLabel === "string") qr.appendChild(el("span", "oluso-journey__help", data.secretLabel));
+          qr.appendChild(el("code", "oluso-journey__code", data.secret));
+        } else if (typeof data.value === "string" && typeof data.image !== "string") qr.appendChild(el("code", "oluso-journey__code", data.value));
+        box.appendChild(qr);
+        return box;
+      }
+      case "codes": {
+        const codes = Array.isArray(data.codes) ? data.codes.map(String) : [];
+        const list = el("ul", "oluso-journey__codes");
+        codes.forEach((c) => list.appendChild(el("li", void 0, c)));
+        const copy = el("button", "oluso-journey__button", labels.copy);
+        copy.type = "button";
+        copy.addEventListener("click", () => {
+          void navigator.clipboard?.writeText(codes.join("\n")).then(() => copy.textContent = labels.copied);
+        });
+        box.append(list, copy);
+        return box;
+      }
+      case "poll": {
+        const seconds = Math.max(2, Number(data.intervalSeconds) || 5);
+        const stopAt = Number(data.maxSeconds) > 0 ? Date.now() + Number(data.maxSeconds) * 1e3 : Infinity;
+        const rendered = session?.currentStep;
+        timers.push(window.setInterval(() => {
+          if (Date.now() > stopAt) {
+            clearTimers();
+            return;
+          }
+          if (!session || document.hidden) return;
+          void client.getSession(session.sessionId).then(async (now) => {
+            if (now.status !== "in_progress" || now.currentStep !== rendered) {
+              clearTimers();
+              await post(new FormData(), "init");
+            }
+          }).catch(() => void 0);
+        }, seconds * 1e3));
+        return null;
+      }
+      default:
+        return null;
+    }
+  };
+  const webAuthnOptions = async (data) => {
+    if (data.publicKey) return { publicKey: data.publicKey, extra: void 0 };
+    const url = String(data.optionsUrl);
+    const absolute = /^https?:/i.test(url) ? url : `${client.serverUrl}${url.startsWith("/") ? "" : "/"}${url}`;
+    const method = String(data.optionsMethod ?? "POST").toUpperCase();
+    const response = await fetch(absolute, {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: method === "GET" ? void 0 : JSON.stringify(data.optionsBody ?? {}),
+      credentials: "include"
+    });
+    if (!response.ok) throw new Error(labels.failed);
+    const json = await response.json();
+    const extra = {};
+    if (typeof data.idProperty === "string" && typeof data.idField === "string" && json[data.idProperty] != null) {
+      extra[data.idField] = String(json[data.idProperty]);
+    }
+    return { publicKey: json.options ?? json, extra };
+  };
+  const renderHtml = (html) => {
+    const wrapper = el("div", "oluso-journey__html");
+    wrapper.innerHTML = html;
+    wrapper.querySelectorAll("script").forEach((s) => s.remove());
+    wrapper.addEventListener("submit", (event) => {
+      const form = event.target;
+      event.preventDefault();
+      const submitter = event.submitter;
+      const data = new FormData(form);
+      if (submitter?.name) data.append(submitter.name, submitter.value);
+      data.delete("__RequestVerificationToken");
+      submitting(form, true);
+      post(data).catch((error) => {
+        submitting(form, false);
+        fail(error);
+      });
+    });
+    root.replaceChildren(wrapper);
+  };
+  void (options.session ? show(options.session) : begin());
+  return {
+    get session() {
+      return session;
+    },
+    restart: begin,
+    destroy() {
+      destroyed = true;
+      clearTimers();
+      root.remove();
+    }
+  };
+}
+function currentValues(item) {
+  if (!item) return [];
+  const inputs = item instanceof RadioNodeList ? Array.from(item) : [item];
+  return inputs.flatMap((node) => {
+    const input = node;
+    if (input.disabled) return [];
+    if (input.type === "checkbox" || input.type === "radio") return input.checked ? [input.value] : [];
+    if (input instanceof HTMLSelectElement && input.multiple) return Array.from(input.selectedOptions).map((o) => o.value);
+    return [input.value];
+  });
+}
+var loadedScripts = /* @__PURE__ */ new Map();
+function loadScript(src) {
+  let loading = loadedScripts.get(src);
+  if (!loading) {
+    loading = new Promise((resolve, reject) => {
+      const tag = document.createElement("script");
+      tag.src = src;
+      tag.async = true;
+      tag.onload = () => resolve();
+      tag.onerror = () => {
+        loadedScripts.delete(src);
+        reject(new Error("A script the step needs could not be loaded"));
+      };
+      document.head.appendChild(tag);
+    });
+    loadedScripts.set(src, loading);
+  }
+  return loading;
+}
+var CAPTCHA_SCRIPTS = {
+  recaptcha: { src: "https://www.google.com/recaptcha/api.js?render=explicit&onload=", global: "grecaptcha" },
+  hcaptcha: { src: "https://js.hcaptcha.com/1/api.js?render=explicit&onload=", global: "hcaptcha" },
+  turnstile: { src: "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit&onload=", global: "turnstile" }
+};
+async function renderCaptcha(target, data, done) {
+  const provider = String(data.provider ?? "recaptcha").toLowerCase();
+  const script = CAPTCHA_SCRIPTS[provider];
+  if (!script) throw new Error(`Captcha provider '${provider}' isn't supported`);
+  const w = window;
+  if (!w[script.global]) {
+    const callback = `__olusoCaptcha${Date.now()}`;
+    await new Promise((resolve, reject) => {
+      w[callback] = () => resolve();
+      const tag = document.createElement("script");
+      tag.src = script.src + callback + (data.language ? `&hl=${encodeURIComponent(String(data.language))}` : "");
+      tag.async = true;
+      tag.onerror = () => reject(new Error("The captcha could not be loaded"));
+      document.head.appendChild(tag);
+    });
+  }
+  const api = w[script.global];
+  const siteKey = String(data.siteKey ?? "");
+  if (provider === "recaptcha" && data.version === "v3" && api.execute) {
+    api.ready?.(() => void api.execute(siteKey, { action: String(data.action ?? "submit") }).then(done));
+    return;
+  }
+  api.render(target, {
+    sitekey: siteKey,
+    theme: data.theme,
+    size: data.size,
+    action: data.action,
+    callback: (token) => done(token)
+  });
+}
+
+// src/react.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var OlusoContext = (0, import_react.createContext)(null);
+function OlusoProvider({ config, children }) {
+  const client = (0, import_react.useMemo)(() => new OlusoClient(config), [config]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OlusoContext.Provider, { value: { client }, children });
+}
+function useOluso() {
+  const context = (0, import_react.useContext)(OlusoContext);
+  if (!context) {
+    throw new Error("useOluso must be used within an OlusoProvider");
+  }
+  return context.client;
+}
+function useJourney(options) {
+  const client = useOluso();
+  const [journey, setJourney] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [isSubmitting, setIsSubmitting] = (0, import_react.useState)(false);
+  const [error, setError] = (0, import_react.useState)(null);
+  const [values, setValues] = (0, import_react.useState)(options.defaultValues || {});
+  const [fieldErrors, setFieldErrors] = (0, import_react.useState)({});
+  (0, import_react.useEffect)(() => {
+    let cancelled = false;
+    async function fetchJourney() {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const data = await client.getJourney(options.slug);
+        if (!cancelled) {
+          setJourney(data);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof OlusoError ? err : new OlusoError(String(err), 0));
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    }
+    fetchJourney();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, options.slug]);
+  const setValue = (0, import_react.useCallback)((field, value) => {
+    setValues((prev) => ({ ...prev, [field]: value }));
+    setFieldErrors((prev) => {
+      if (prev[field]) {
+        const { [field]: _, ...rest } = prev;
+        return rest;
+      }
+      return prev;
+    });
+  }, []);
+  const submit = (0, import_react.useCallback)(async () => {
+    if (!journey) return null;
+    try {
+      setIsSubmitting(true);
+      setError(null);
+      setFieldErrors({});
+      const result = await client.submit(options.slug, values);
+      if (result.success) {
+        options.onSuccess?.(result);
+      }
+      return result;
+    } catch (err) {
+      const olusError = err instanceof OlusoError ? err : new OlusoError(String(err), 0);
+      setError(olusError);
+      if (olusError.fieldErrors) {
+        setFieldErrors(olusError.fieldErrors);
+      }
+      options.onError?.(olusError);
+      return null;
+    } finally {
+      setIsSubmitting(false);
+    }
+  }, [client, journey, options, values]);
+  const reset = (0, import_react.useCallback)(() => {
+    setValues(options.defaultValues || {});
+    setFieldErrors({});
+    setError(null);
+  }, [options.defaultValues]);
+  return {
+    journey,
+    isLoading,
+    isSubmitting,
+    error,
+    values,
+    fieldErrors,
+    setValue,
+    submit,
+    reset
+  };
+}
+function JourneyForm({
+  slug,
+  onSuccess,
+  onError,
+  className,
+  submitText = "Submit",
+  loadingText = "Loading...",
+  renderField,
+  renderSubmit,
+  showSuccessMessage = true,
+  renderSuccess
+}) {
+  const {
+    journey,
+    isLoading,
+    isSubmitting,
+    error,
+    values,
+    fieldErrors,
+    setValue,
+    submit
+  } = useJourney({ slug, onSuccess, onError });
+  const [submitted, setSubmitted] = (0, import_react.useState)(null);
+  const handleSubmit = (0, import_react.useCallback)(async (e) => {
+    e.preventDefault();
+    const result = await submit();
+    if (result?.success && showSuccessMessage) {
+      setSubmitted(result);
+    }
+  }, [submit, showSuccessMessage]);
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className, children: loadingText });
+  }
+  if (!journey) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className, children: "Journey not found" });
+  }
+  if (submitted) {
+    if (renderSuccess) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: renderSuccess(submitted) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: submitted.message || "Thank you for your submission!" }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("form", { onSubmit: handleSubmit, className, children: [
+    journey.fields.map((field) => {
+      const fieldProps = {
+        value: values[field.name],
+        onChange: (value) => setValue(field.name, value),
+        error: fieldErrors[field.name]
+      };
+      if (renderField) {
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.default.Fragment, { children: renderField(field, fieldProps) }, field.name);
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultField, { field, ...fieldProps }, field.name);
+    }),
+    error && !error.fieldErrors && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { color: "red", marginBottom: "1rem" }, children: error.message }),
+    renderSubmit ? renderSubmit({ isSubmitting, onClick: () => submit() }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", disabled: isSubmitting, children: isSubmitting ? "Submitting..." : submitText })
+  ] });
+}
+function DefaultField({ field, value, onChange, error }) {
+  const id = `oluso-field-${field.name}`;
+  const inputProps = {
+    id,
+    name: field.name,
+    required: field.required,
+    placeholder: field.placeholder,
+    "aria-describedby": field.description ? `${id}-desc` : void 0,
+    "aria-invalid": !!error
+  };
+  let input;
+  switch (field.type) {
+    case "textarea":
+      input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "textarea",
+        {
+          ...inputProps,
+          value: value || "",
+          onChange: (e) => onChange(e.target.value),
+          rows: 4
+        }
+      );
+      break;
+    case "select":
+      input = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+        "select",
+        {
+          ...inputProps,
+          value: value || "",
+          onChange: (e) => onChange(e.target.value),
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "", children: "Select..." }),
+            field.options?.map((opt) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: opt.value, children: opt.label }, opt.value))
+          ]
+        }
+      );
+      break;
+    case "checkbox":
+      input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "input",
+        {
+          ...inputProps,
+          type: "checkbox",
+          checked: !!value,
+          onChange: (e) => onChange(e.target.checked)
+        }
+      );
+      break;
+    case "radio":
+      input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { role: "radiogroup", children: field.options?.map((opt) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "input",
+          {
+            type: "radio",
+            name: field.name,
+            value: opt.value,
+            checked: value === opt.value,
+            onChange: (e) => onChange(e.target.value)
+          }
+        ),
+        opt.label
+      ] }, opt.value)) });
+      break;
+    default:
+      input = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "input",
+        {
+          ...inputProps,
+          type: field.type,
+          value: value || "",
+          onChange: (e) => onChange(e.target.value),
+          minLength: field.validation?.minLength,
+          maxLength: field.validation?.maxLength,
+          pattern: field.validation?.pattern,
+          min: field.validation?.min,
+          max: field.validation?.max
+        }
+      );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { marginBottom: "1rem" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { htmlFor: id, style: { display: "block", marginBottom: "0.25rem" }, children: [
+      field.label,
+      field.required && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { style: { color: "red" }, children: " *" })
+    ] }),
+    input,
+    field.description && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("small", { id: `${id}-desc`, style: { display: "block", color: "#666" }, children: field.description }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("small", { style: { display: "block", color: "red" }, children: error })
+  ] });
+}
+function Journey({ className, style, ...options }) {
+  const client = useOluso();
+  const host = (0, import_react.useRef)(null);
+  const latest = (0, import_react.useRef)(options);
+  latest.current = options;
+  (0, import_react.useEffect)(() => {
+    if (!host.current) return;
+    const mount = mountJourney(host.current, {
+      client,
+      slug: options.slug,
+      data: options.data,
+      session: options.session,
+      start: options.start,
+      showCompletion: options.showCompletion,
+      theme: options.theme,
+      unstyled: options.unstyled,
+      labels: options.labels,
+      onStep: (s) => latest.current.onStep?.(s),
+      onComplete: (s) => latest.current.onComplete?.(s),
+      onError: (e, s) => latest.current.onError?.(e, s),
+      onRedirect: latest.current.onRedirect ? (url, s) => latest.current.onRedirect?.(url, s) : void 0
+    });
+    return () => mount.destroy();
+  }, [client, options.slug, options.session?.sessionId]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: host, className, style });
+}
+function JourneyEmbed({
+  slug,
+  width = "100%",
+  height = 500,
+  theme,
+  hideHeader,
+  className,
+  style,
+  onComplete
+}) {
+  const client = useOluso();
+  const src = client.getEmbedUrl(slug, { theme, hideHeader });
+  (0, import_react.useEffect)(() => {
+    if (!onComplete) return;
+    const handleMessage = (event) => {
+      if (!client.getJourneyUrl(slug).startsWith(event.origin)) {
+        return;
+      }
+      if (event.data?.type === "oluso:complete") {
+        onComplete(event.data.result);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, [client, slug, onComplete]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "iframe",
+    {
+      src,
+      width,
+      height,
+      className,
+      style: {
+        border: "none",
+        ...style
+      },
+      title: `Oluso Journey: ${slug}`,
+      allow: "clipboard-write; camera; microphone"
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Journey,
+  JourneyEmbed,
+  JourneyForm,
+  OlusoProvider,
+  useJourney,
+  useOluso
+});
+//# sourceMappingURL=react.js.map