@jetezra/bridge 0.0.1 → 0.0.2

package/dist/chooga-bridge.cjs

@@ -38,6 +38,8 @@ var BRIDGE = {
   CALL_RESULT: "chooga.callResult",
   EVENT: "chooga.event",
   HOST_INFO: "chooga.hostInfo",
+  /** Open bag of host-defined fields for getState() / subscribe. */
+  PARAMS: "chooga.params",
   // Mini-app → host
   READY: "chooga.ready",
   CLOSE: "chooga.close",
@@ -53,7 +55,22 @@ var BRIDGE = {
   HOST_INFO_GET: "chooga.hostInfo.get",
   CALL: "chooga.call"
 };
-var BRIDGE_VERSION = "1.2.0";
+var BRIDGE_VERSION = "0.0.2";
+var RESERVED_STATE_KEYS = /* @__PURE__ */ new Set([
+  "hostConnected",
+  "readySent",
+  "session",
+  "user",
+  "theme",
+  "safeArea",
+  "hostInfo",
+  "params",
+  "lastCapability",
+  "lastPayment",
+  "lastActivity",
+  "lastEvent",
+  "lastMessage"
+]);
 var state = {
   hostConnected: false,
   readySent: false,
@@ -62,6 +79,8 @@ var state = {
   theme: null,
   safeArea: null,
   hostInfo: null,
+  /** Host-defined open bag — any keys the host wants the mini-app to see. */
+  params: {},
   lastCapability: null,
   lastPayment: null,
   lastActivity: null,
@@ -73,12 +92,52 @@ var eventHandlers = /* @__PURE__ */ new Map();
 var pending = /* @__PURE__ */ new Map();
 var requestSeq = 0;
 var initialized = false;
+var debugEnabled = false;
+var allowedOrigins = null;
+var mockHostActive = false;
 function nextRequestId() {
   requestSeq += 1;
   return `cb_${Date.now().toString(36)}_${requestSeq}`;
 }
+function logDebug(direction, payload) {
+  if (!debugEnabled) {
+    return;
+  }
+  const label = direction === "out" ? "[ChoogaBridge \u2192 host]" : "[ChoogaBridge \u2190 host]";
+  try {
+    console.log(label, payload);
+  } catch (_) {
+  }
+}
+function logWarn(message, detail) {
+  if (!debugEnabled) {
+    return;
+  }
+  try {
+    console.warn("[ChoogaBridge]", message, detail);
+  } catch (_) {
+  }
+}
+function applyHostParams(msg) {
+  const { type: _t, replace, params: nested, ...rest } = msg || {};
+  const incoming = nested && typeof nested === "object" && !Array.isArray(nested) ? { ...nested } : { ...rest };
+  if (replace) {
+    state.params = incoming;
+    return;
+  }
+  const next = { ...state.params };
+  Object.keys(incoming).forEach((key) => {
+    if (incoming[key] === null) {
+      delete next[key];
+    } else {
+      next[key] = incoming[key];
+    }
+  });
+  state.params = next;
+}
 function getState() {
-  return {
+  const params = { ...state.params };
+  const known = {
     hostConnected: state.hostConnected,
     readySent: state.readySent,
     session: state.session,
@@ -86,12 +145,20 @@ function getState() {
     theme: state.theme,
     safeArea: state.safeArea,
     hostInfo: state.hostInfo,
+    params,
     lastCapability: state.lastCapability,
     lastPayment: state.lastPayment,
     lastActivity: state.lastActivity,
     lastEvent: state.lastEvent,
     lastMessage: state.lastMessage
   };
+  const extras = {};
+  Object.keys(params).forEach((key) => {
+    if (!RESERVED_STATE_KEYS.has(key)) {
+      extras[key] = params[key];
+    }
+  });
+  return { ...extras, ...known };
 }
 function notify() {
   const snapshot = getState();
@@ -124,6 +191,9 @@ function emitLocalEvent(name, detail) {
   }
 }
 function detectHost() {
+  if (mockHostActive) {
+    return true;
+  }
   return !!(typeof window !== "undefined" && window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === "function");
 }
 function ensureChoogaHostShim() {
@@ -149,6 +219,7 @@ function ensureChoogaHostShim() {
   window.ChoogaTheme = window.ChoogaTheme || {};
 }
 function postToHost(msg) {
+  logDebug("out", msg);
   ensureChoogaHostShim();
   if (window.ChoogaHost && typeof window.ChoogaHost.postToHost === "function") {
     window.ChoogaHost.postToHost(msg);
@@ -202,6 +273,7 @@ function trackRequest(options = {}) {
     const timer = timeoutMs > 0 ? setTimeout(() => {
       if (pending.has(requestId)) {
         pending.delete(requestId);
+        logWarn("request timed out", { requestId, timeoutMs });
         reject(Object.assign(new Error("timeout"), { reason: "timeout" }));
       }
     }, timeoutMs) : null;
@@ -219,46 +291,76 @@ function handleHostMessage(raw) {
     try {
       msg = JSON.parse(raw);
     } catch (_) {
+      logWarn("ignored non-JSON host message", raw);
       return;
     }
   }
   if (!msg || typeof msg !== "object" || !msg.type) {
     return;
   }
+  logDebug("in", msg);
   state.hostConnected = true;
   state.lastMessage = msg;
   switch (msg.type) {
-    case BRIDGE.SESSION:
+    case BRIDGE.SESSION: {
+      const { type: _t, ...rest } = msg;
       state.session = {
-        token: msg.token || null,
-        expires_at: msg.expires_at || null
+        ...rest,
+        token: rest.token != null ? rest.token : null,
+        expires_at: rest.expires_at != null ? rest.expires_at : null
       };
       break;
+    }
     case BRIDGE.USER:
-      state.user = msg.user || null;
+      state.user = msg.user != null ? msg.user : null;
+      if (msg.requestId) {
+        settlePending(msg.requestId, { ok: true, user: state.user });
+      }
       break;
-    case BRIDGE.THEME:
+    case BRIDGE.THEME: {
+      const { type: _t, ...rest } = msg;
       state.theme = {
-        mode: msg.mode || "light",
-        primary_color: msg.primary_color || null
+        ...rest,
+        mode: rest.mode || "light",
+        primary_color: rest.primary_color != null ? rest.primary_color : null
       };
       applyTheme(state.theme);
       break;
-    case BRIDGE.SAFE_AREA:
-      state.safeArea = msg.insets || null;
+    }
+    case BRIDGE.SAFE_AREA: {
+      if (msg.insets != null) {
+        state.safeArea = msg.insets;
+      } else {
+        const { type: _t, ...rest } = msg;
+        state.safeArea = Object.keys(rest).length ? rest : null;
+      }
       break;
+    }
     case BRIDGE.HOST_INFO: {
-      const { type: _t, ...rest } = msg;
+      const { type: _t, requestId, ...rest } = msg;
       state.hostInfo = rest;
+      if (requestId) {
+        settlePending(requestId, { ok: true, ...rest });
+      }
       break;
     }
-    case BRIDGE.CAPABILITY_RESULT:
-      state.lastCapability = {
-        key: msg.key,
-        granted: !!msg.granted,
-        reason: msg.reason || null
+    case BRIDGE.PARAMS:
+      applyHostParams(msg);
+      break;
+    case BRIDGE.CAPABILITY_RESULT: {
+      const { type: _t, requestId, ...rest } = msg;
+      const result = {
+        ...rest,
+        key: rest.key,
+        granted: !!rest.granted,
+        reason: rest.reason != null ? rest.reason : null
       };
+      state.lastCapability = result;
+      if (requestId) {
+        settlePending(requestId, { ok: true, ...result });
+      }
       break;
+    }
     case BRIDGE.NAVIGATE_RESULT:
       settlePending(msg.requestId, {
         ok: !!msg.ok,
@@ -286,15 +388,36 @@ function handleHostMessage(raw) {
       emitLocalEvent(msg.name, msg.detail || {});
       break;
     default:
+      logWarn("unknown host message type", msg.type);
       break;
   }
   notify();
 }
 function onWindowMessage(event) {
+  if (allowedOrigins && allowedOrigins.length > 0) {
+    const origin = event && event.origin;
+    const allowAll = allowedOrigins.indexOf("*") !== -1;
+    const isOpaque = origin == null || origin === "" || origin === "null";
+    if (!allowAll && !isOpaque && allowedOrigins.indexOf(origin) === -1) {
+      logWarn("ignored message from disallowed origin", origin);
+      return;
+    }
+  }
   handleHostMessage(event && event.data);
 }
+function setDebug(enabled) {
+  debugEnabled = !!enabled;
+  return ChoogaBridge;
+}
 function init(options = {}) {
+  if (options.debug != null) {
+    debugEnabled = !!options.debug;
+  }
+  if (options.allowedOrigins != null) {
+    allowedOrigins = Array.isArray(options.allowedOrigins) ? options.allowedOrigins.slice() : null;
+  }
   if (initialized) {
+    logDebug("out", { note: "init() already called \u2014 updated debug/allowedOrigins only" });
     return ChoogaBridge;
   }
   initialized = true;
@@ -308,12 +431,164 @@ function init(options = {}) {
       document.addEventListener("message", onWindowMessage);
     }
   }
+  if (debugEnabled) {
+    logDebug("out", {
+      note: "bridge initialized",
+      version: BRIDGE_VERSION,
+      hostConnected: state.hostConnected,
+      allowedOrigins
+    });
+  }
   if (options.autoReady !== false) {
     ready();
   }
   notify();
   return ChoogaBridge;
 }
+function mockHost(options = {}) {
+  if (typeof window === "undefined") {
+    return ChoogaBridge;
+  }
+  ensureChoogaHostShim();
+  mockHostActive = true;
+  state.hostConnected = true;
+  const delayMs = options.delayMs != null ? options.delayMs : 0;
+  const context = options.context || {};
+  function reply(msg) {
+    const run = () => handleHostMessage(msg);
+    if (delayMs > 0) {
+      setTimeout(run, delayMs);
+    } else {
+      run();
+    }
+  }
+  window.ReactNativeWebView = {
+    postMessage(payload) {
+      let msg = payload;
+      if (typeof payload === "string") {
+        try {
+          msg = JSON.parse(payload);
+        } catch (_) {
+          return;
+        }
+      }
+      if (!msg || typeof msg !== "object") {
+        return;
+      }
+      if (typeof options.onMessage === "function") {
+        options.onMessage(msg, reply);
+        return;
+      }
+      switch (msg.type) {
+        case BRIDGE.READY:
+          reply({
+            type: BRIDGE.SESSION,
+            token: "mock-token",
+            expires_at: null,
+            ...context.session || {}
+          });
+          reply({
+            type: BRIDGE.USER,
+            user: context.user || { id: "mock-user", name: "Demo User" }
+          });
+          reply({
+            type: BRIDGE.THEME,
+            mode: "light",
+            primary_color: null,
+            ...context.theme || {}
+          });
+          if (context.params) {
+            reply({
+              type: BRIDGE.PARAMS,
+              replace: true,
+              params: context.params
+            });
+          }
+          reply({
+            type: BRIDGE.HOST_INFO,
+            version: BRIDGE_VERSION,
+            host_version: BRIDGE_VERSION,
+            activities: context.activities || ["wallet.pick", "host.confirm"],
+            capabilities: context.capabilities || ["payments"],
+            granted: context.granted || ["payments"]
+          });
+          break;
+        case BRIDGE.ACTIVITY:
+          reply({
+            type: BRIDGE.ACTIVITY_RESULT,
+            requestId: msg.requestId,
+            ok: true,
+            name: msg.name,
+            mock: true,
+            ...msg.params || {}
+          });
+          break;
+        case BRIDGE.CALL:
+          reply({
+            type: BRIDGE.CALL_RESULT,
+            requestId: msg.requestId,
+            ok: true,
+            method: msg.method,
+            mock: true,
+            ...msg.params || {}
+          });
+          break;
+        case BRIDGE.NAVIGATE:
+          reply({
+            type: BRIDGE.NAVIGATE_RESULT,
+            requestId: msg.requestId,
+            ok: true,
+            reason: null
+          });
+          break;
+        case BRIDGE.USER_GET:
+          reply({
+            type: BRIDGE.USER,
+            requestId: msg.requestId,
+            user: context.user || { id: "mock-user", name: "Demo User" }
+          });
+          break;
+        case BRIDGE.HOST_INFO_GET:
+          reply({
+            type: BRIDGE.HOST_INFO,
+            requestId: msg.requestId,
+            version: BRIDGE_VERSION,
+            host_version: BRIDGE_VERSION,
+            activities: context.activities || ["wallet.pick", "host.confirm"],
+            capabilities: context.capabilities || ["payments"],
+            granted: context.granted || ["payments"]
+          });
+          break;
+        case BRIDGE.REQUEST_CAPABILITY:
+          reply({
+            type: BRIDGE.CAPABILITY_RESULT,
+            requestId: msg.requestId,
+            key: msg.key,
+            granted: true,
+            reason: null
+          });
+          break;
+        case BRIDGE.PAYMENTS_INITIATE:
+          if (msg.deliverResult === false) {
+            break;
+          }
+          reply({
+            type: BRIDGE.PAYMENTS_RESULT,
+            requestId: msg.requestId,
+            ok: true,
+            status: "succeeded",
+            reference: msg.reference || null,
+            mock: true
+          });
+          break;
+        default:
+          break;
+      }
+    }
+  };
+  notify();
+  return ChoogaBridge;
+}
 function ready() {
   postToHost({ type: BRIDGE.READY });
   state.readySent = true;
@@ -325,8 +600,18 @@ function close() {
 function openExternal(url) {
   postToHost({ type: BRIDGE.OPEN_EXTERNAL, url });
 }
-function requestCapability(key) {
-  postToHost({ type: BRIDGE.REQUEST_CAPABILITY, key });
+function requestCapability(key, options = {}) {
+  const requestId = nextRequestId();
+  const promise = trackRequest({
+    requestId,
+    onResult: options.onResult,
+    timeoutMs: options.timeoutMs != null ? options.timeoutMs : 3e4
+  });
+  postToHost({ type: BRIDGE.REQUEST_CAPABILITY, requestId, key });
+  if (!detectHost()) {
+    settlePending(requestId, { ok: false, key, granted: false, reason: "no_host" });
+  }
+  return promise;
 }
 function showProgress(options = {}) {
   const opts = typeof options === "string" ? { message: options } : options || {};
@@ -444,7 +729,11 @@ function off(name, handler) {
 }
 function navigate(options = {}) {
   const requestId = nextRequestId();
-  const promise = trackRequest({ requestId, timeoutMs: options.timeoutMs });
+  const promise = trackRequest({
+    requestId,
+    onResult: options.onResult,
+    timeoutMs: options.timeoutMs
+  });
   postToHost({
     type: BRIDGE.NAVIGATE,
     requestId,
@@ -527,6 +816,8 @@ var ChoogaBridge = {
   BRIDGE,
   BRIDGE_VERSION,
   init,
+  setDebug,
+  mockHost,
   ready,
   close,
   openExternal,