@farcaster/frame-host-react-native 0.0.0-canary-20250508220243 → 0.0.0-canary-20250508234838

package/dist/rn-comlink-helpers.d.ts

@@ -0,0 +1,15 @@
+import { type Remote, type TransferHandler, type WireValue } from '@farcaster/frame-host';
+interface SerializedRnFunction {
+    __isRNProxiedFunction: true;
+    id: string;
+    type: 'function';
+}
+export interface ReactNativeWebViewProxy {
+    _callWebViewProxiedFunction: (id: string, args: WireValue[]) => Promise<WireValue>;
+}
+/**
+ * Creates a Comlink TransferHandler for deserializing functions proxied from WebView
+ * and serializing function stubs created by this handler.
+ */
+export declare function createReactNativeFunctionDeserializer(getWebViewProxy: () => Remote<ReactNativeWebViewProxy> | undefined): TransferHandler<Function, SerializedRnFunction>;
+export {};

package/dist/rn-comlink-helpers.js

@@ -0,0 +1,61 @@
+import { WireValueType, fromWireValue, toWireValue, } from '@farcaster/frame-host';
+function processArgumentsForRN(argumentList) {
+    const processed = argumentList.map((arg) => toWireValue(arg));
+    const wireValues = processed.map((p) => p[0]);
+    const transferables = processed.flatMap((p) => p[1]);
+    if (transferables.length > 0) {
+        console.warn('[RN Host Comlink] Transferables found in arguments to WebView proxied function are ignored.');
+    }
+    return [wireValues, []];
+}
+/**
+ * Creates a Comlink TransferHandler for deserializing functions proxied from WebView
+ * and serializing function stubs created by this handler.
+ */
+export function createReactNativeFunctionDeserializer(getWebViewProxy) {
+    return {
+        // canHandle checks if a given value is a Function stub that this handler can serialize.
+        canHandle: (value) => {
+            return (typeof value === 'function' &&
+                Object.hasOwn(value, '__functionId__') &&
+                typeof value.__functionId__ === 'string');
+        },
+        // deserialize converts the wire format (SerializedRnFunction) into a callable Function stub.
+        deserialize: (serializedValue) => {
+            const functionId = serializedValue.id;
+            console.debug(`[RN Host Comlink] Creating stub for WebView function ID: ${functionId}`);
+            const webViewFunctionStub = async (...args) => {
+                const webViewProxy = getWebViewProxy();
+                if (!webViewProxy || !webViewProxy._callWebViewProxiedFunction) {
+                    console.error('[RN Host Comlink] WebView proxy or _callWebViewProxiedFunction not available.');
+                    throw new Error('[RN Host Comlink] WebView proxy not available. Cannot call remote function.');
+                }
+                console.debug(`[RN Host Comlink] Calling WebView function ID: ${functionId} with args:`, args);
+                const [wireArgs] = processArgumentsForRN(args);
+                try {
+                    const typedProxy = webViewProxy;
+                    const wireResult = await typedProxy._callWebViewProxiedFunction(functionId, wireArgs);
+                    if (wireResult &&
+                        wireResult.type === WireValueType.HANDLER &&
+                        wireResult.name === 'throw') {
+                        return fromWireValue(wireResult);
+                    }
+                    return fromWireValue(wireResult);
+                }
+                catch (error) {
+                    console.error(`[RN Host Comlink] Error in stub for function ID ${functionId}:`, error);
+                    throw error;
+                }
+            };
+            webViewFunctionStub.__functionId__ = functionId;
+            return webViewFunctionStub;
+        },
+        // serialize converts a Function stub (that this handler knows about) into its wire format.
+        serialize: (fnStub) => {
+            // canHandle should have already verified this is one of our stubs.
+            const id = fnStub.__functionId__;
+            console.debug(`[RN Host Comlink] Serializing function stub ID: ${id}`);
+            return [{ __isRNProxiedFunction: true, id, type: 'function' }, []];
+        },
+    };
+}

package/dist/rn-comlink.d.ts

@@ -0,0 +1,29 @@
+import { type FrameHost, type Endpoint as FrameHostEndpoint, type Remote as FrameHostRemote, releaseProxy } from '@farcaster/frame-host';
+import type { Provider } from 'ox/Provider';
+import { type ReactNativeWebViewProxy } from './rn-comlink-helpers';
+export { releaseProxy };
+/**
+ * Ensures React Native specific Comlink transfer handlers are registered globally.
+ */
+export declare function ensureRnComlinkHandlers(): void;
+/**
+ * Wraps a WebView endpoint with Comlink, ensuring RN handlers are set up.
+ * Crucially, it sets the webViewProxyInstance needed by the deserializer's callback.
+ *
+ * If this is not called, deserializing the function will fail.
+ */
+export declare function wrapWebViewForRnComlink<T extends ReactNativeWebViewProxy>(endpoint: FrameHostEndpoint): FrameHostRemote<T>;
+/**
+ * Exposes the Host SDK object to the WebView, ensuring RN handlers are set up
+ * on the Comlink instance used for the exposure.
+ * Replicates logic from `@farcaster/frame-host`'s `exposeToEndpoint` helper
+ * but makes sure to set up the RN handlers first.
+ *
+ * @returns Cleanup function if any event listeners were added (e.g., provider events)
+ */
+export declare function exposeToWebViewWithRnComlink({ endpoint, sdk, ethProvider, debug, }: {
+    endpoint: FrameHostEndpoint;
+    sdk: Omit<FrameHost, 'ethProviderRequestV2'>;
+    ethProvider?: Provider;
+    debug?: boolean;
+}): (() => void) | undefined;

package/dist/rn-comlink.js

@@ -0,0 +1,73 @@
+import { expose, releaseProxy, transferHandlers, wrap, } from '@farcaster/frame-host';
+import { forwardProviderEvents, wrapProviderRequest, } from '@farcaster/frame-host/src/helpers/provider';
+import { wrapHandlers } from '@farcaster/frame-host/src/helpers/sdk';
+import { createReactNativeFunctionDeserializer, } from './rn-comlink-helpers';
+// Re-export releaseProxy symbol for use in cleanup
+export { releaseProxy };
+let rnHandlersInitialized = false;
+let webViewProxyInstance = null;
+let rnFunctionDeserializer = null;
+/**
+ * Ensures React Native specific Comlink transfer handlers are registered globally.
+ */
+export function ensureRnComlinkHandlers() {
+    if (rnHandlersInitialized) {
+        return;
+    }
+    const getWebViewProxy = () => {
+        return webViewProxyInstance === null ? undefined : webViewProxyInstance;
+    };
+    rnFunctionDeserializer =
+        createReactNativeFunctionDeserializer(getWebViewProxy);
+    transferHandlers.set('rn_function', rnFunctionDeserializer);
+    console.debug('[RN Host Comlink] Registered ReactNativeFunctionDeserializer via ensureRnComlinkHandlers.');
+    rnHandlersInitialized = true;
+}
+/**
+ * Wraps a WebView endpoint with Comlink, ensuring RN handlers are set up.
+ * Crucially, it sets the webViewProxyInstance needed by the deserializer's callback.
+ *
+ * If this is not called, deserializing the function will fail.
+ */
+export function wrapWebViewForRnComlink(endpoint) {
+    ensureRnComlinkHandlers();
+    const proxy = wrap(endpoint);
+    webViewProxyInstance = proxy;
+    return proxy;
+}
+/**
+ * Exposes the Host SDK object to the WebView, ensuring RN handlers are set up
+ * on the Comlink instance used for the exposure.
+ * Replicates logic from `@farcaster/frame-host`'s `exposeToEndpoint` helper
+ * but makes sure to set up the RN handlers first.
+ *
+ * @returns Cleanup function if any event listeners were added (e.g., provider events)
+ */
+export function exposeToWebViewWithRnComlink({ endpoint, sdk, ethProvider, debug = false, }) {
+    ensureRnComlinkHandlers();
+    const extendedSdk = wrapHandlers(sdk);
+    let providerCleanup;
+    if (ethProvider) {
+        extendedSdk.ethProviderRequestV2 = wrapProviderRequest({
+            provider: ethProvider,
+            debug,
+        });
+        try {
+            providerCleanup = forwardProviderEvents({
+                provider: ethProvider,
+                endpoint: endpoint,
+            });
+        }
+        catch (e) {
+            console.error('[RN Host Comlink] Error setting up provider event forwarding:', e);
+        }
+    }
+    try {
+        expose(extendedSdk, endpoint);
+        console.debug('[RN Host Comlink] Exposed SDK to WebView via exposeToWebViewWithRnComlink');
+    }
+    catch (e) {
+        console.warn('[RN Host Comlink] Error exposing API (may already be exposed):', e);
+    }
+    return providerCleanup;
+}