@cloudparse/up-miniapps-sdk 0.5.7 → 0.6.1

package/dist/index.cjs

@@ -50,6 +50,8 @@ __export(src_exports, {
   SDKProvider: () => SDKProvider,
   SwipeCarousel: () => SwipeCarousel,
   UIEvent: () => UIEvent,
+  createApiService: () => createApiService,
+  createWsService: () => createWsService,
   default: () => src_default,
   handleClearRoute: () => handleClearRoute,
   handleDrawRoute: () => handleDrawRoute,
@@ -124,7 +126,16 @@ var Button = React.forwardRef(
 );
 Button.displayName = "Button";
 
+// src/utils/environment.ts
+function isRunningInsideNativeShell() {
+  if (typeof window === "undefined") return false;
+  const w = window;
+  return w.__UP_REACT_NATIVE_APP__ === true || !!w.ReactNativeWebView;
+}
+
 // src/bridge.ts
+var BridgeTimeoutError = class extends Error {
+};
 var Bridge = class {
   callbacks = /* @__PURE__ */ new Map();
   eventListeners = /* @__PURE__ */ new Map();
@@ -195,18 +206,32 @@ var Bridge = class {
    * @param type The action type (e.g., "GET_LOCATION").
    * @param payload Data associated with the action.
    * @param timeoutMs Time in milliseconds to wait for a response before rejecting.
+   * @param retries Number of additional attempts if a request times out (default 1 — one retry).
+   *   Exists because the response for a request can be lost in transit — e.g. the host's
+   *   injected response script running before this WebView's own `message` listener has
+   *   attached, worse under rapid mount/unmount cycles — with no application-visible symptom
+   *   other than the full 30s timeout. A blind retry self-heals that class of loss without
+   *   needing to diagnose which specific transport race dropped the original message; every
+   *   call site benefits automatically instead of each consumer app hand-rolling its own
+   *   retry-after-catch logic (which previously only covered `initialize()`, and imperfectly).
    * @returns A promise that resolves with the native response.
    */
-  send(type, payload, timeoutMs = 3e4) {
+  send(type, payload, timeoutMs = 3e4, retries = 1) {
     if (!this.isNative()) {
       return this.handleMockMessage(type, payload);
     }
+    return this.sendOnce(type, payload, timeoutMs).catch((err) => {
+      if (retries <= 0 || !(err instanceof BridgeTimeoutError)) throw err;
+      return this.send(type, payload, timeoutMs, retries - 1);
+    });
+  }
+  sendOnce(type, payload, timeoutMs) {
     return new Promise((resolve, reject) => {
       const callbackId = `${type}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
       const timeout = setTimeout(() => {
         if (this.callbacks.has(callbackId)) {
           this.callbacks.delete(callbackId);
-          reject(new Error(`Bridge request timeout: ${type}`));
+          reject(new BridgeTimeoutError(`Bridge request timeout: ${type}`));
         }
       }, timeoutMs);
       this.callbacks.set(callbackId, {
@@ -280,8 +305,7 @@ var Bridge = class {
    * Determine environment. Check flag or cache result.
    */
   isNative() {
-    if (typeof window === "undefined") return false;
-    return window.__UP_REACT_NATIVE_APP__ === true || !!window.ReactNativeWebView;
+    return isRunningInsideNativeShell();
   }
 };
 
@@ -2028,14 +2052,14 @@ var useUserLocation = () => {
   });
   const mapPayload = (0, import_react6.useCallback)((payload) => {
     const coords = payload.location?.coords || payload.coords;
-    const headingData = payload.heading || payload.coords;
+    const headingData = payload.heading;
     const newCoords = coords ? [coords.longitude, coords.latitude] : null;
     let heading = null;
     if (headingData?.trueHeading !== void 0 && headingData.trueHeading >= 0) {
       heading = headingData.trueHeading;
     } else if (headingData?.magneticHeading !== void 0 && headingData.magneticHeading >= 0) {
       heading = headingData.magneticHeading;
-    } else if (headingData?.heading !== null && headingData.heading >= 0) {
+    } else if (headingData?.heading !== null && headingData?.heading >= 0) {
       heading = headingData.heading;
     }
     return {
@@ -2505,7 +2529,14 @@ var import_jsx_runtime11 = require("react/jsx-runtime");
 var MockRadiusLayer = ({
   center,
   radiusMeters,
-  color = "#39ff88"
+  // Neutral gray, not any one app's accent color — this debug aid is shared
+  // across every mini-app (each with its own, different palette), so it
+  // shouldn't default to a color that reads as "part of the app" (was
+  // #39ff88, a neon green/yellow left over from an earlier shared theme,
+  // reported as looking like an unwanted yellow border around the user's
+  // position marker in up-miniapps-explore, which has since moved to a
+  // pastel palette with no neon accents at all).
+  color = "#e2e8f0"
 }) => {
   const data = (0, import_react10.useMemo)(
     () => buildGeoCircle(center, radiusMeters),
@@ -3680,7 +3711,7 @@ var RoutingService = {
 };
 
 // package.json
-var version = "0.5.7";
+var version = "0.6.1";
 
 // src/sdk.ts
 function deepFreeze(obj) {
@@ -3695,6 +3726,7 @@ function deepFreeze(obj) {
   return Object.freeze(obj);
 }
 var globalRoutingConfig = null;
+var lastKnownEnv = null;
 var MiniAppSDK = class {
   /**
    * Map services.
@@ -4017,7 +4049,14 @@ var MiniAppSDK = class {
   });
   constructor() {
     this.bridge = new Bridge();
+    this.bridge.on(
+      "UPDATE_CONTEXT" /* UPDATE_CONTEXT */,
+      (data) => {
+        if (data?.env) lastKnownEnv = data.env;
+      }
+    );
     this.initialize = this.initialize.bind(this);
+    this.getEnv = this.getEnv.bind(this);
     this.on = this.on.bind(this);
     this.off = this.off.bind(this);
   }
@@ -4041,8 +4080,22 @@ var MiniAppSDK = class {
    * The starting point for the Mini-App. Must be called before any other SDK methods.
    * @param options The options to provide to the shell app
    */
-  initialize(options) {
-    return this.bridge.send("INITIALIZE", options);
+  async initialize(options) {
+    const res = await this.bridge.send(
+      "INITIALIZE",
+      options
+    );
+    if (res?.env) lastKnownEnv = res.env;
+    return res;
+  }
+  /**
+   * Returns the last known `env` (shell-provided config like `backendUrl`),
+   * refreshed automatically by `initialize()` and every `UPDATE_CONTEXT`
+   * push — read this instead of caching your own copy of `env` values.
+   * Returns `null` before the first successful `initialize()`/context push.
+   */
+  getEnv() {
+    return lastKnownEnv;
   }
   /**
    * Registers a callback for a specific event from the native shell.
@@ -5249,6 +5302,207 @@ function handleClearRoute(map, miniAppId) {
   if (map.getSource(sourceId)) map.removeSource(sourceId);
 }
 
+// src/services/apiService.ts
+function buildUrl(baseUrl, path) {
+  if (path.startsWith("http://") || path.startsWith("https://")) {
+    return path;
+  }
+  let cleanBase = baseUrl.trim();
+  while (cleanBase.endsWith("/")) {
+    cleanBase = cleanBase.slice(0, -1);
+  }
+  let cleanPath = path.trim();
+  if (!cleanPath.startsWith("/")) {
+    cleanPath = `/${cleanPath}`;
+  }
+  const baseEndsWithV1 = cleanBase.endsWith("/api/v1");
+  const pathStartsWithV1 = cleanPath.startsWith("/api/v1/") || cleanPath === "/api/v1";
+  if (baseEndsWithV1 && pathStartsWithV1) {
+    const strippedPath = cleanPath.slice(7);
+    return `${cleanBase}${strippedPath}`;
+  }
+  return `${cleanBase}${cleanPath}`;
+}
+function getEarlyBackendUrl(kind) {
+  if (typeof window === "undefined") return void 0;
+  const early = window.__UP_BACKEND_URLS__;
+  return early?.[kind] ?? void 0;
+}
+function createApiService(options) {
+  const getBaseUrl = () => getEarlyBackendUrl("http") || sdk.getEnv()?.backendUrl || options.defaultBaseUrl;
+  const getWsUrl = () => getEarlyBackendUrl("ws") || sdk.getEnv()?.wsBackendUrl || options.defaultWsBackendUrl;
+  return {
+    get baseUrl() {
+      return getBaseUrl();
+    },
+    delete: (path) => sdk.network.request({
+      method: "DELETE",
+      url: buildUrl(getBaseUrl(), path)
+    }),
+    get: (path) => sdk.network.request({
+      headers: { "Content-Type": "application/json" },
+      method: "GET",
+      url: buildUrl(getBaseUrl(), path)
+    }),
+    graphqlQuery: (query, variables = {}) => sdk.network.request({
+      body: { query, variables },
+      headers: { "Content-Type": "application/json" },
+      method: "POST",
+      url: buildUrl(getBaseUrl(), "/graphql")
+    }),
+    patch: (path, body) => sdk.network.request({
+      body,
+      headers: { "Content-Type": "application/json" },
+      method: "PATCH",
+      url: buildUrl(getBaseUrl(), path)
+    }),
+    post: (path, body) => sdk.network.request({
+      body,
+      headers: { "Content-Type": "application/json" },
+      method: "POST",
+      url: buildUrl(getBaseUrl(), path)
+    }),
+    get wsUrl() {
+      return getWsUrl();
+    }
+  };
+}
+
+// src/services/wsService.ts
+function createWsService(options) {
+  const channelField = options.channelField;
+  let ws = null;
+  const subscriptions = /* @__PURE__ */ new Map();
+  const globalListeners = /* @__PURE__ */ new Set();
+  let reconnectTimeout = null;
+  let reconnectDelay = 1e3;
+  let isConnecting = false;
+  const getWsUrl = () => options.baseUrl || options.api.wsUrl || "";
+  const sendAction = (action, channelId) => {
+    if (ws?.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ action, [channelField]: channelId }));
+    }
+  };
+  const scheduleReconnect = () => {
+    if (reconnectTimeout) clearTimeout(reconnectTimeout);
+    reconnectTimeout = setTimeout(() => {
+      reconnectDelay = Math.min(reconnectDelay * 2, 3e4);
+      connect();
+    }, reconnectDelay);
+  };
+  const connect = async () => {
+    if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING || isConnecting) {
+      return;
+    }
+    isConnecting = true;
+    try {
+      const wsUrl = getWsUrl();
+      if (!wsUrl) {
+        console.warn(
+          "[WS] No WebSocket backend URL available, connection delayed."
+        );
+        isConnecting = false;
+        return;
+      }
+      let authParams = {};
+      if (isRunningInsideNativeShell() && options.ticketPath !== null) {
+        const ticketResponse = await options.api.post(
+          options.ticketPath ?? "/ws-ticket"
+        );
+        authParams = { ticket: ticketResponse.data.ticket };
+      } else if (options.devToken) {
+        const rawJwt = options.devToken.startsWith("Bearer ") ? options.devToken.slice(7) : options.devToken;
+        authParams = { token: rawJwt };
+      } else if (options.requireAuth === false) {
+      } else {
+        console.warn("[WS] No auth available, connection delayed.");
+        isConnecting = false;
+        return;
+      }
+      const params = new URLSearchParams({ ...options.query, ...authParams });
+      const query = params.toString();
+      ws = new WebSocket(query ? `${wsUrl}?${query}` : wsUrl);
+      ws.onopen = () => {
+        isConnecting = false;
+        reconnectDelay = 1e3;
+        if (channelField) {
+          for (const channelId of subscriptions.keys()) {
+            sendAction("subscribe", channelId);
+          }
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const payload = JSON.parse(event.data);
+          if (channelField) {
+            const channelId = payload[channelField];
+            if (typeof channelId === "string") {
+              const callbacks = subscriptions.get(channelId);
+              if (callbacks) {
+                for (const cb of callbacks) cb(payload);
+              }
+            }
+          }
+          for (const cb of globalListeners) cb(payload);
+        } catch (err) {
+          console.error("[WS] Failed to parse message:", err);
+        }
+      };
+      ws.onclose = () => {
+        isConnecting = false;
+        scheduleReconnect();
+      };
+      ws.onerror = (err) => {
+        console.error("[WS] error:", err);
+        isConnecting = false;
+        ws?.close();
+      };
+    } catch (err) {
+      console.error("[WS] Failed to establish connection:", err);
+      isConnecting = false;
+      scheduleReconnect();
+    }
+  };
+  const disconnect = () => {
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    if (ws) {
+      ws.onclose = null;
+      ws.close();
+      ws = null;
+    }
+  };
+  const subscribe = (channelId, callback) => {
+    const isNewChannel = !subscriptions.has(channelId);
+    if (isNewChannel) subscriptions.set(channelId, /* @__PURE__ */ new Set());
+    subscriptions.get(channelId)?.add(callback);
+    if (isNewChannel) sendAction("subscribe", channelId);
+    connect();
+    return () => {
+      const set = subscriptions.get(channelId);
+      if (!set) return;
+      set.delete(callback);
+      if (set.size === 0) {
+        subscriptions.delete(channelId);
+        sendAction("unsubscribe", channelId);
+      }
+    };
+  };
+  const onMessage = (callback) => {
+    globalListeners.add(callback);
+    connect();
+    return () => {
+      globalListeners.delete(callback);
+    };
+  };
+  if (channelField) {
+    return { connect, disconnect, onMessage, subscribe };
+  }
+  return { connect, disconnect, onMessage };
+}
+
 // src/index.ts
 var src_default = sdk;
 // Annotate the CommonJS export names for ESM import in node:
@@ -5273,6 +5527,8 @@ var src_default = sdk;
   SDKProvider,
   SwipeCarousel,
   UIEvent,
+  createApiService,
+  createWsService,
   handleClearRoute,
   handleDrawRoute,
   handleRouteRequest,