@cloudparse/up-miniapps-sdk 0.6.6 → 0.6.8

package/dist/index.cjs

@@ -267,11 +267,61 @@ var Bridge = class {
     }
   }
   /**
-   * Internal handler for mock message processing, overrideable in test environments
+   * Internal handler for mock message processing, overrideable in test environments.
+   *
+   * Every mini-app that calls a bridge method also has to run standalone in a plain
+   * browser (dev, and this vault's own Chrome-based verification) with no native shell
+   * attached — `isNative()` is false, so `send()` never round-trips through the real
+   * host at all. Before this switch existed, EVERY unhandled type here resolved with
+   * plain `undefined` (see the `default` branch below), which silently broke any caller
+   * checking a result shape like `{success: boolean}` — `undefined?.success` reads as
+   * `false`, not "no answer", so e.g. `sdk.media.saveImage()` looked like a real
+   * permission-denied rejection in the browser instead of "there's no native shell
+   * here to ask." Add a `case` here — instead of leaving every mini-app to
+   * individually special-case "what happens when I call this with no shell attached" —
+   * whenever a bridge method's mock behavior should be more than a no-op.
    */
   handleMockMessage(type, payload) {
-    console.warn(`[Bridge] Mock mode active: Unhandled message type ${type}`);
-    return Promise.resolve();
+    switch (type) {
+      case "SAVE_IMAGE":
+        return this.mockSaveImage(
+          payload
+        );
+      default:
+        console.warn(
+          `[Bridge] Mock mode active: Unhandled message type ${type}`
+        );
+        return Promise.resolve();
+    }
+  }
+  /**
+   * Standalone-browser stand-in for the native `SAVE_IMAGE` handler: triggers a real
+   * browser download (an `<a download>` click) instead of writing to a device photo
+   * library, which doesn't exist here. Resolves `{success: true}` on a real trigger so
+   * every mini-app's own `result?.success` check gets the same shape/semantics as the
+   * real native response — no per-app "am I in mock mode" branching needed. Consumers
+   * can still keep their own `catch` fallback for the genuinely different case of a
+   * native shell that's missing its WebView bridge (see `sendOnce`'s own rejection
+   * path) — that's a real native edge case, not mocking, and this method never runs
+   * for it (`send()` only reaches `handleMockMessage` when `!isNative()`).
+   */
+  mockSaveImage(payload) {
+    if (typeof document === "undefined") {
+      return Promise.resolve({ success: false });
+    }
+    try {
+      const href = payload.base64.startsWith("data:") ? payload.base64 : `data:image/png;base64,${payload.base64}`;
+      const link = document.createElement("a");
+      link.href = href;
+      link.download = payload.filename ? `${payload.filename}.png` : "image.png";
+      document.body.appendChild(link);
+      link.click();
+      link.remove();
+      return Promise.resolve({ success: true });
+    } catch (err) {
+      console.warn("[Bridge] Mock SAVE_IMAGE download failed:", err);
+      return Promise.resolve({ success: false });
+    }
   }
   sendOnce(type, payload, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -735,7 +785,7 @@ var MapDrawer = (0, import_react2.forwardRef)(
         const dragDelta = touchEndY - dragStartY;
         const drawerHeightFromBottom = dragBaseHeightPxRef.current - dragDelta;
         const distToClosed = Math.abs(drawerHeightFromBottom - closedPx);
-        let targetState;
+        let targetState2;
         if (currentState === "auto") {
           const autoMaxPx2 = resolveHeightToPixels(
             drawerAutoMaxHeight || "100%",
@@ -743,22 +793,22 @@ var MapDrawer = (0, import_react2.forwardRef)(
           );
           const autoPx2 = Math.min(autoMaxPx2, autoContentPx);
           const distToAuto = Math.abs(drawerHeightFromBottom - autoPx2);
-          targetState = distToAuto <= distToClosed ? "auto" : "closed";
+          targetState2 = distToAuto <= distToClosed ? "auto" : "closed";
         } else {
           const distToFull = Math.abs(drawerHeightFromBottom - fullPx2);
           const distToPeek = Math.abs(drawerHeightFromBottom - peekPx2);
           const minDist = Math.min(distToFull, distToPeek, distToClosed);
           if (minDist === distToFull) {
-            targetState = "full";
+            targetState2 = "full";
           } else if (minDist === distToPeek) {
-            targetState = "peek";
+            targetState2 = "peek";
           } else {
-            targetState = "closed";
+            targetState2 = "closed";
           }
         }
         setTouchStartY(null);
         setCurrentTouchY(null);
-        onChangeState(targetState);
+        onChangeState(targetState2);
         requestAnimationFrame(() => {
           if (parentContainer) {
             parentContainer.style.setProperty("--drag-offset", "0px");
@@ -2035,115 +2085,142 @@ var GlobalEvent = /* @__PURE__ */ ((GlobalEvent2) => {
 // src/components/Map/hooks/useUserLocation.ts
 var import_react6 = require("react");
 var LERP_FACTOR = 0.12;
-var useUserLocation = () => {
-  const [locationState, setLocationState] = (0, import_react6.useState)({
-    accuracy: null,
-    coords: null,
-    heading: null
-  });
-  const targetRef = (0, import_react6.useRef)({
-    accuracy: null,
-    coords: null,
-    heading: null
-  });
-  const currentRef = (0, import_react6.useRef)({
-    accuracy: null,
-    coords: null,
-    heading: null
-  });
-  const mapPayload = (0, import_react6.useCallback)((payload) => {
-    const coords = payload.location?.coords || 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) {
-      heading = headingData.heading;
-    }
-    return {
-      accuracy: coords?.accuracy || null,
-      coords: newCoords,
-      heading
-    };
-  }, []);
-  (0, import_react6.useEffect)(() => {
-    let rafId;
-    const animate = () => {
-      let changed = false;
-      if (targetRef.current.coords) {
-        if (!currentRef.current.coords) {
-          currentRef.current.coords = [...targetRef.current.coords];
-          changed = true;
-        } else {
-          const [tLng, tLat] = targetRef.current.coords;
-          const [cLng, cLat] = currentRef.current.coords;
-          const nLng = cLng + (tLng - cLng) * LERP_FACTOR;
-          const nLat = cLat + (tLat - cLat) * LERP_FACTOR;
-          if (Math.abs(nLng - cLng) > 1e-7 || Math.abs(nLat - cLat) > 1e-7) {
-            currentRef.current.coords = [nLng, nLat];
-            changed = true;
-          }
-        }
-      }
-      if (targetRef.current.heading !== null) {
-        if (currentRef.current.heading === null) {
-          currentRef.current.heading = targetRef.current.heading;
-          changed = true;
-        } else {
-          const target = targetRef.current.heading;
-          const current = currentRef.current.heading;
-          let delta = target - current;
-          if (delta > 180) delta -= 360;
-          if (delta < -180) delta += 360;
-          const nHeading = current + delta * LERP_FACTOR;
-          const normalized = (nHeading % 360 + 360) % 360;
-          if (Math.abs(delta) > 0.1) {
-            currentRef.current.heading = normalized;
-            changed = true;
-          }
-        }
-      }
-      if (changed) {
-        setLocationState({
-          accuracy: targetRef.current.accuracy,
-          coords: currentRef.current.coords ? [...currentRef.current.coords] : null,
-          heading: currentRef.current.heading
-        });
-      }
-      rafId = requestAnimationFrame(animate);
-    };
-    rafId = requestAnimationFrame(animate);
-    sdk.location.getCurrentPosition().then((data) => {
-      const payload = mapPayload(data);
-      targetRef.current = payload;
-    }).catch((e) => console.warn("Initial location fetch failed", e));
-    const unsubscribeStream = sdk.on(
-      "LOCATION_STREAM_UPDATE" /* LOCATION_STREAM_UPDATE */,
-      (payload) => {
-        targetRef.current = mapPayload(payload);
+var EMPTY_STATE = {
+  accuracy: null,
+  coords: null,
+  heading: null
+};
+function mapPayload(payload) {
+  const coords = payload.location?.coords || 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) {
+    heading = headingData.heading;
+  }
+  return {
+    accuracy: coords?.accuracy || null,
+    coords: newCoords,
+    heading
+  };
+}
+var refCount = 0;
+var generation = 0;
+var subscribers = /* @__PURE__ */ new Set();
+var targetState = { ...EMPTY_STATE };
+var currentInterpolated = { coords: null, heading: null };
+var rafId = null;
+var unsubscribeStream = null;
+var unsubscribeLegacy = null;
+function getSnapshot() {
+  return {
+    accuracy: targetState.accuracy,
+    coords: currentInterpolated.coords ? [...currentInterpolated.coords] : null,
+    heading: currentInterpolated.heading
+  };
+}
+function notify() {
+  const snapshot = getSnapshot();
+  for (const callback of subscribers) callback(snapshot);
+}
+function animate() {
+  let changed = false;
+  if (targetState.coords) {
+    if (!currentInterpolated.coords) {
+      currentInterpolated.coords = [...targetState.coords];
+      changed = true;
+    } else {
+      const [tLng, tLat] = targetState.coords;
+      const [cLng, cLat] = currentInterpolated.coords;
+      const nLng = cLng + (tLng - cLng) * LERP_FACTOR;
+      const nLat = cLat + (tLat - cLat) * LERP_FACTOR;
+      if (Math.abs(nLng - cLng) > 1e-7 || Math.abs(nLat - cLat) > 1e-7) {
+        currentInterpolated.coords = [nLng, nLat];
+        changed = true;
       }
-    );
-    const unsubscribeLegacy = sdk.on(
-      "LOCATION_UPDATE" /* LOCATION_UPDATE */,
-      (payload) => {
-        targetRef.current = mapPayload(payload);
+    }
+  }
+  if (targetState.heading !== null) {
+    if (currentInterpolated.heading === null) {
+      currentInterpolated.heading = targetState.heading;
+      changed = true;
+    } else {
+      const target = targetState.heading;
+      const current = currentInterpolated.heading;
+      let delta = target - current;
+      if (delta > 180) delta -= 360;
+      if (delta < -180) delta += 360;
+      const nHeading = current + delta * LERP_FACTOR;
+      const normalized = (nHeading % 360 + 360) % 360;
+      if (Math.abs(delta) > 0.1) {
+        currentInterpolated.heading = normalized;
+        changed = true;
       }
-    );
-    sdk.location.startStream({
-      distanceFilter: 1,
-      headingThreshold: 2
-    }).catch((e) => console.warn("Failed to start location stream", e));
+    }
+  }
+  if (changed) notify();
+  rafId = requestAnimationFrame(animate);
+}
+function startSharedStream() {
+  rafId = requestAnimationFrame(animate);
+  generation++;
+  const thisGeneration = generation;
+  sdk.location.getCurrentPosition().then((data) => {
+    if (thisGeneration !== generation) return;
+    targetState = mapPayload(data);
+  }).catch((e) => console.warn("Initial location fetch failed", e));
+  unsubscribeStream = sdk.on(
+    "LOCATION_STREAM_UPDATE" /* LOCATION_STREAM_UPDATE */,
+    (payload) => {
+      targetState = mapPayload(payload);
+    }
+  );
+  unsubscribeLegacy = sdk.on(
+    "LOCATION_UPDATE" /* LOCATION_UPDATE */,
+    (payload) => {
+      targetState = mapPayload(payload);
+    }
+  );
+  sdk.location.startStream({
+    distanceFilter: 1,
+    headingThreshold: 2
+  }).catch((e) => console.warn("Failed to start location stream", e));
+}
+function stopSharedStream() {
+  generation++;
+  if (rafId !== null) cancelAnimationFrame(rafId);
+  rafId = null;
+  unsubscribeStream?.();
+  unsubscribeLegacy?.();
+  unsubscribeStream = null;
+  unsubscribeLegacy = null;
+  sdk.location.stopStream().catch(() => {
+  });
+  targetState = { ...EMPTY_STATE };
+  currentInterpolated = { coords: null, heading: null };
+}
+var useUserLocation = () => {
+  const [locationState, setLocationState] = (0, import_react6.useState)(getSnapshot);
+  (0, import_react6.useEffect)(() => {
+    refCount++;
+    if (refCount === 1) {
+      startSharedStream();
+    } else {
+      setLocationState(getSnapshot());
+    }
+    subscribers.add(setLocationState);
     return () => {
-      cancelAnimationFrame(rafId);
-      unsubscribeStream();
-      unsubscribeLegacy();
-      sdk.location.stopStream().catch(() => {
-      });
+      subscribers.delete(setLocationState);
+      refCount--;
+      if (refCount === 0) {
+        stopSharedStream();
+      }
     };
-  }, [mapPayload]);
+  }, []);
   return locationState;
 };
 
@@ -3715,7 +3792,7 @@ var RoutingService = {
 };
 
 // package.json
-var version = "0.6.6";
+var version = "0.6.8";
 
 // src/sdk.ts
 function deepFreeze(obj) {
@@ -4126,7 +4203,6 @@ var import_react14 = require("react");
 var import_jsx_runtime16 = require("react/jsx-runtime");
 var AVATAR_MOUTH_VARIANTS = [
   "variant03",
-  "variant06",
   "variant07",
   "variant08",
   "variant09",
@@ -4870,7 +4946,10 @@ var RESISTANCE = 0.5;
 var DRAG_DEADZONE = 8;
 var FLING_FRICTION = 0.95;
 var FLING_MIN_VELOCITY = 0.02;
-function DefaultIndicator({ progress, isRefreshing }) {
+function DefaultIndicator({
+  progress,
+  isRefreshing
+}) {
   return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(
     "div",
     {