@goliapkg/sentori-react-native 0.7.1 → 0.7.3

package/src/mask.ts

@@ -0,0 +1,41 @@
+// v0.7.3 — mask discovery via consumer-supplied query callback.
+//
+// The SDK does not own a registry of masked regions. The host app
+// keeps its own (e.g. a `Set<string>` updated as `<Maskable>`
+// components mount/unmount) and hands the SDK a thunk that returns
+// the current list of native-IDs to redact. The SDK calls the thunk
+// once per screenshot capture — cheap, called rarely, only on error.
+//
+// Why this shape: a logging SDK should never live on the render
+// path. Earlier iterations exported `<MaskRegion>` (React component)
+// and `setMaskedNode` (imperative ref helper), which forced every
+// PII-bearing UI file to import from the SDK and put SDK bugs in
+// the user's render tree. This module is JS-only — no React, no JSX,
+// no native module touch — so swapping or removing the SDK doesn't
+// affect rendering.
+
+type MaskQuery = () => string[];
+
+let _query: MaskQuery | null = null;
+
+/**
+ * Register a callback the SDK calls right before each screenshot
+ * capture. Return the native-IDs (the `nativeID` prop on the RN
+ * `<View>`) that should be blacked-out in the captured image.
+ *
+ * Idempotent: a second call replaces the first. Pass `null` (or
+ * call `clearMaskQuery`) to detach.
+ */
+export function registerMaskQuery(query: MaskQuery): void {
+  _query = query;
+}
+
+/** Unregister. Mostly for tests / teardown. */
+export function clearMaskQuery(): void {
+  _query = null;
+}
+
+/** Internal — read by `handlers/screenshot.ts` at capture time. */
+export function getRegisteredMaskQuery(): MaskQuery | null {
+  return _query;
+}

package/src/native.ts

@@ -11,6 +11,18 @@ type SentoriNativeModule = {
     release: string
     token: string
   }) => void
+  /**
+   * v0.7.3 — JS-triggered screenshot with consumer-supplied mask IDs.
+   * `maskedIds` are RN `nativeID` strings; native walks the view
+   * tree, finds each subview by identifier, and paints a black
+   * rectangle over its frame in the captured bitmap. Resolves to
+   * `null` if there's no key window / API < 24 (Android) / render
+   * timed out. Replaced the previous `react-native-view-shot`
+   * peer-dep path.
+   */
+  captureScreenshotWithMask?: (
+    maskedIds: string[],
+  ) => Promise<null | { base64: string; mediaType: string }>
   /**
    * Phase 22 sub-D / sub-E: cross-platform main-thread watchdog.
    * Android: 5 s / 1 s defaults (matches the OS ANR threshold).
@@ -114,3 +126,26 @@ export function stopAnrWatchdog(): void {
     // ignore
   }
 }
+
+/**
+ * v0.7.3 — drives the native screenshot path. JS side passes the
+ * current list of mask `nativeID`s (read from the consumer's
+ * registered mask query); native renders + redacts.
+ *
+ * Returns `null` on every failure mode: no native module bound
+ * (jest, bun test, web), method missing (older native build still
+ * deployed), capture failed (no key window, timed out, etc.).
+ * Callers must treat `null` as "no screenshot this round" — the
+ * error event still ships, just without a thumbnail.
+ */
+export async function captureNativeScreenshotWithMask(
+  maskedIds: string[],
+): Promise<null | { base64: string; mediaType: string }> {
+  const n = native()
+  if (!n?.captureScreenshotWithMask) return null
+  try {
+    return await n.captureScreenshotWithMask(maskedIds)
+  } catch {
+    return null
+  }
+}

package/src/mask.tsx

@@ -1,150 +0,0 @@
-// Phase 42 sub-D.09/10 + Phase 48 sub-B — mark UI regions as "do not
-// screenshot" AND actually redact them at capture time.
-//
-// `<MaskRegion>` renders its children normally, plus a black overlay
-// `<View>` that sits on top of them with `opacity: 0`. Right before
-// `captureScreenshot()` calls into react-native-view-shot, the SDK
-// flips every registered overlay to `opacity: 1` (black square covers
-// the children), captures, then flips back to `opacity: 0` so the
-// user never sees the overlay. The overlay uses `pointerEvents="none"`
-// so it never intercepts touches.
-//
-// `setMaskedNode(ref)` is the imperative escape hatch for views you
-// can't wrap. We can't inject an overlay into a foreign view, so the
-// imperative path falls back to setting the registered view's own
-// `opacity: 0` for the capture window — content underneath may show
-// through, but that beats sending the sensitive content to the server.
-// Prefer `<MaskRegion>` when you control the subtree.
-
-import React, { type ReactNode, useEffect, useRef } from 'react';
-import { StyleSheet, View, type ViewProps } from 'react-native';
-
-/** What we drive in the capture window: any handle with
- *  `setNativeProps({ opacity })`. RN's View instance satisfies this. */
-type Maskable = {
-  setNativeProps?: (props: { style?: { opacity?: number } }) => void;
-};
-
-const _maskedRefs = new Set<Maskable>();
-const _maskedOverlays = new Set<Maskable>();
-const _maskedNativeIds = new Set<string>();
-
-/**
- * Imperative registration: pass a ref obtained via `useRef()` /
- * `createRef()` to a `<View>` you want hidden from screenshots.
- */
-export function setMaskedNode(node: null | Maskable | unknown): void {
-  if (!node || typeof (node as Maskable).setNativeProps !== 'function') return;
-  _maskedRefs.add(node as Maskable);
-}
-
-export function unsetMaskedNode(node: null | Maskable | unknown): void {
-  if (!node) return;
-  _maskedRefs.delete(node as Maskable);
-}
-
-/** Returns the current set of registered masked nodes + nativeIDs.
- *  Read by the native screenshotter layer (iOS / Android sub-E / F). */
-export function getMaskedRegions(): {
-  nativeIds: Set<string>;
-  overlays: Set<Maskable>;
-  refs: Set<Maskable>;
-} {
-  return { nativeIds: _maskedNativeIds, overlays: _maskedOverlays, refs: _maskedRefs };
-}
-
-/**
- * Phase 48 sub-B — engage masking right before screenshot capture.
- * Returns a function the caller must invoke once capture is done so
- * the user never sees the black overlays.
- *
- * Two paths:
- *   - Overlays from `<MaskRegion>`: flip opacity 0 → 1 (cover children).
- *   - Imperative refs from `setMaskedNode`: flip opacity 1 → 0 on the
- *     view itself (whole subtree disappears for one frame).
- *
- * All `setNativeProps` calls are best-effort — a failure on one
- * doesn't block the others or the capture.
- */
-export function engageMasks(): () => void {
-  const overlaysEngaged: Maskable[] = [];
-  for (const o of _maskedOverlays) {
-    try {
-      o.setNativeProps?.({ style: { opacity: 1 } });
-      overlaysEngaged.push(o);
-    } catch {
-      // skip
-    }
-  }
-  const refsEngaged: Maskable[] = [];
-  for (const r of _maskedRefs) {
-    try {
-      r.setNativeProps?.({ style: { opacity: 0 } });
-      refsEngaged.push(r);
-    } catch {
-      // skip
-    }
-  }
-  return () => {
-    for (const o of overlaysEngaged) {
-      try {
-        o.setNativeProps?.({ style: { opacity: 0 } });
-      } catch {
-        // skip
-      }
-    }
-    for (const r of refsEngaged) {
-      try {
-        r.setNativeProps?.({ style: { opacity: 1 } });
-      } catch {
-        // skip
-      }
-    }
-  };
-}
-
-/**
- * Declarative redaction. `<MaskRegion>{children}</MaskRegion>` keeps
- * the children visible in normal flight; under capture the overlay's
- * opacity is flipped to 1 and the children are hidden behind a black
- * square in the rendered screenshot.
- */
-export function MaskRegion({
-  children,
-  nativeID,
-  ...rest
-}: { children: ReactNode; nativeID?: string } & ViewProps): React.JSX.Element {
-  const idRef = useRef<string>(
-    nativeID ?? `sentori-mask-${Math.random().toString(36).slice(2, 10)}`,
-  );
-  const overlayRef = useRef<null | View>(null);
-
-  useEffect(() => {
-    const id = idRef.current;
-    _maskedNativeIds.add(id);
-    const overlay = overlayRef.current as null | Maskable;
-    if (overlay) _maskedOverlays.add(overlay);
-    return () => {
-      _maskedNativeIds.delete(id);
-      if (overlay) _maskedOverlays.delete(overlay);
-    };
-  }, []);
-
-  return (
-    <View collapsable={false} nativeID={idRef.current} {...rest}>
-      {children}
-      <View
-        pointerEvents="none"
-        ref={overlayRef}
-        style={[StyleSheet.absoluteFill, { backgroundColor: '#000', opacity: 0 }]}
-      />
-    </View>
-  );
-}
-
-/** Test-only — flush registration tables. */
-export function __resetMaskedRegionsForTests(): void {
-  _maskedRefs.clear();
-  _maskedOverlays.clear();
-  _maskedNativeIds.clear();
-}