@farcaster/frame-host 0.0.54 → 0.1.1

package/src/index.ts

@@ -1,4 +1,47 @@
-export * from '@farcaster/frame-core'
-export * from './types.ts'
-export * from './iframe.ts'
-export * from './helpers/endpoint.ts'
+// Deprecation warning
+if (typeof console !== 'undefined' && console.warn) {
+  console.warn(
+    '[DEPRECATION WARNING] @farcaster/frame-host is deprecated. Please migrate to @farcaster/miniapp-host. ' +
+      'See https://github.com/farcasterxyz/frames/blob/main/MIGRATION.md for migration guide.',
+  )
+}
+
+// Re-export everything from miniapp-host
+export * from '@farcaster/miniapp-host'
+
+// Backward compatibility - re-export exposeToIframe with old parameter name
+import { exposeToIframe as _exposeToIframe } from '@farcaster/miniapp-host'
+
+let exposeToIframeWarningShown = false
+export function exposeToIframe({
+  iframe,
+  sdk,
+  ethProvider,
+  frameOrigin,
+  debug = false,
+}: {
+  iframe: HTMLIFrameElement
+  sdk: Parameters<typeof _exposeToIframe>[0]['sdk']
+  frameOrigin: string
+  ethProvider?: Parameters<typeof _exposeToIframe>[0]['ethProvider']
+  debug?: boolean
+}) {
+  if (
+    !exposeToIframeWarningShown &&
+    typeof console !== 'undefined' &&
+    console.warn
+  ) {
+    console.warn(
+      '[DEPRECATION WARNING] The frameOrigin parameter is deprecated. Please use miniAppOrigin instead. ' +
+        'Import exposeToIframe from @farcaster/miniapp-host.',
+    )
+    exposeToIframeWarningShown = true
+  }
+  return _exposeToIframe({
+    iframe,
+    sdk,
+    ethProvider,
+    miniAppOrigin: frameOrigin,
+    debug,
+  })
+}

package/dist/comlink/comlink.d.ts

@@ -1,150 +0,0 @@
-import { type Endpoint, type EventSource, type PostMessageWithOrigin } from './protocol';
-export type { Endpoint };
-export declare const proxyMarker: unique symbol;
-export declare const createEndpoint: unique symbol;
-export declare const releaseProxy: unique symbol;
-export declare const finalizer: unique symbol;
-/**
- * Interface of values that were marked to be proxied with `comlink.proxy()`.
- * Can also be implemented by classes.
- */
-export interface ProxyMarked {
-    [proxyMarker]: true;
-}
-/**
- * Takes a type and wraps it in a Promise, if it not already is one.
- * This is to avoid `Promise<Promise<T>>`.
- *
- * This is the inverse of `Unpromisify<T>`.
- */
-type Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;
-/**
- * Takes a type that may be Promise and unwraps the Promise type.
- * If `P` is not a Promise, it returns `P`.
- *
- * This is the inverse of `Promisify<T>`.
- */
-type Unpromisify<P> = P extends Promise<infer T> ? T : P;
-/**
- * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.
- *
- * Note: This needs to be its own type alias, otherwise it will not distribute over unions.
- * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
- */
-type RemoteProperty<T> = T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;
-/**
- * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function
- * argument) and returns the type that the local thread has to supply.
- *
- * This is the inverse of `RemoteProperty<T>`.
- *
- * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See
- * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types
- */
-type LocalProperty<T> = T extends Function | ProxyMarked ? Local<T> : Unpromisify<T>;
-/**
- * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).
- */
-export type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;
-/**
- * Inverse of `ProxyOrClone<T>`.
- */
-export type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked> ? Local<T> : T;
-/**
- * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread
- * when proxied with `Comlink.proxy()`.
- *
- * This does not handle call signatures, which is handled by the more general `Remote<T>` type.
- *
- * @template T The raw type of a remote object as seen in the other thread.
- */
-export type RemoteObject<T> = {
-    [P in keyof T]: RemoteProperty<T[P]>;
-};
-/**
- * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function
- * argument) and returns the type that the local thread has to supply.
- *
- * This does not handle call signatures, which is handled by the more general `Local<T>` type.
- *
- * This is the inverse of `RemoteObject<T>`.
- *
- * @template T The type of a proxied object.
- */
-export type LocalObject<T> = {
-    [P in keyof T]: LocalProperty<T[P]>;
-};
-/**
- * Additional special comlink methods available on each proxy returned by `Comlink.wrap()`.
- */
-export interface ProxyMethods {
-    [createEndpoint]: () => Promise<MessagePort>;
-    [releaseProxy]: () => void;
-}
-/**
- * Takes the raw type of a remote object, function or class in the other thread and returns the type as it is visible to
- * the local thread from the proxy return value of `Comlink.wrap()` or `Comlink.proxy()`.
- */
-export type Remote<T> = RemoteObject<T> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
-    [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
-}) => Promisify<ProxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
-    new (...args: infer TArguments): infer TInstance;
-} ? {
-    new (...args: {
-        [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;
-    }): Promisify<Remote<TInstance>>;
-} : unknown) & ProxyMethods;
-/**
- * Expresses that a type can be either a sync or async.
- */
-type MaybePromise<T> = Promise<T> | T;
-/**
- * Takes the raw type of a remote object, function or class as a remote thread would see it through a proxy (e.g. when
- * passed in as a function argument) and returns the type the local thread has to supply.
- *
- * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.
- */
-export type Local<T> = Omit<LocalObject<T>, keyof ProxyMethods> & (T extends (...args: infer TArguments) => infer TReturn ? (...args: {
-    [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
-}) => MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>> : unknown) & (T extends {
-    new (...args: infer TArguments): infer TInstance;
-} ? {
-    new (...args: {
-        [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;
-    }): MaybePromise<Local<Unpromisify<TInstance>>>;
-} : unknown);
-/**
- * Customizes the serialization of certain values as determined by `canHandle()`.
- *
- * @template T The input type being handled by this transfer handler.
- * @template S The serialized type sent over the wire.
- */
-export interface TransferHandler<T, S> {
-    /**
-     * Gets called for every value to determine whether this transfer handler
-     * should serialize the value, which includes checking that it is of the right
-     * type (but can perform checks beyond that as well).
-     */
-    canHandle(value: unknown): value is T;
-    /**
-     * Gets called with the value if `canHandle()` returned `true` to produce a
-     * value that can be sent in a message, consisting of structured-cloneable
-     * values and/or transferrable objects.
-     */
-    serialize(value: T): [S, Transferable[]];
-    /**
-     * Gets called to deserialize an incoming value that was serialized in the
-     * other thread with this transfer handler (known through the name it was
-     * registered under).
-     */
-    deserialize(value: S): T;
-}
-/**
- * Allows customizing the serialization of certain values.
- */
-export declare const transferHandlers: Map<string, TransferHandler<unknown, unknown>>;
-export declare function expose(obj: any, ep?: Endpoint, allowedOrigins?: (string | RegExp)[]): () => void;
-export declare function wrap<T>(ep: Endpoint, target?: any): Remote<T>;
-export declare function transfer<T>(obj: T, transfers: Transferable[]): T;
-export declare function proxy<T extends {}>(obj: T): T & ProxyMarked;
-export declare function windowEndpoint(w: PostMessageWithOrigin, context?: EventSource, targetOrigin?: string): Endpoint;

package/dist/comlink/comlink.js

@@ -1,380 +0,0 @@
-import { MessageType, WireValueType, } from './protocol';
-export const proxyMarker = Symbol('Comlink.proxy');
-export const createEndpoint = Symbol('Comlink.endpoint');
-export const releaseProxy = Symbol('Comlink.releaseProxy');
-export const finalizer = Symbol('Comlink.finalizer');
-const throwMarker = Symbol('Comlink.thrown');
-const isObject = (val) => (typeof val === 'object' && val !== null) || typeof val === 'function';
-/**
- * Internal transfer handle to handle objects marked to proxy.
- */
-const proxyTransferHandler = {
-    canHandle: (val) => isObject(val) && val[proxyMarker],
-    serialize(obj) {
-        const { port1, port2 } = new MessageChannel();
-        expose(obj, port1);
-        return [port2, [port2]];
-    },
-    deserialize(port) {
-        port.start();
-        return wrap(port);
-    },
-};
-/**
- * Internal transfer handler to handle thrown exceptions.
- */
-const throwTransferHandler = {
-    canHandle: (value) => isObject(value) && throwMarker in value,
-    serialize({ value }) {
-        let serialized;
-        if (value instanceof Error) {
-            serialized = {
-                isError: true,
-                value: {
-                    message: value.message,
-                    name: value.name,
-                    stack: value.stack,
-                },
-            };
-        }
-        else {
-            serialized = { isError: false, value };
-        }
-        return [serialized, []];
-    },
-    deserialize(serialized) {
-        if (serialized.isError) {
-            throw Object.assign(new Error(serialized.value.message), serialized.value);
-        }
-        throw serialized.value;
-    },
-};
-/**
- * Allows customizing the serialization of certain values.
- */
-export const transferHandlers = new Map([
-    ['proxy', proxyTransferHandler],
-    ['throw', throwTransferHandler],
-]);
-function isAllowedOrigin(allowedOrigins, origin) {
-    for (const allowedOrigin of allowedOrigins) {
-        if (origin === allowedOrigin || allowedOrigin === '*') {
-            return true;
-        }
-        if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
-            return true;
-        }
-    }
-    return false;
-}
-export function expose(obj, ep = globalThis, allowedOrigins = ['*']) {
-    function callback(ev) {
-        if (!ev || !ev.data) {
-            return;
-        }
-        if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-            console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-            return;
-        }
-        const { id, type, path } = {
-            path: [],
-            ...ev.data,
-        };
-        const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-        let returnValue;
-        try {
-            switch (type) {
-                case MessageType.GET:
-                    if (path[0] === 'context') {
-                        returnValue = obj.context;
-                    }
-                    else {
-                        throw new Error(`Unsupported GET for ${path.join('/')}`);
-                    }
-                    break;
-                case MessageType.APPLY: {
-                    returnValue = (() => {
-                        switch (path[0]) {
-                            case 'close':
-                                return obj.close();
-                            case 'ready':
-                                return obj.ready(...argumentList);
-                            case 'openUrl':
-                                return obj.openUrl(...argumentList);
-                            case 'signIn':
-                                return obj.signIn(...argumentList);
-                            case 'setPrimaryButton':
-                                return obj.setPrimaryButton(...argumentList);
-                            case 'ethProviderRequest':
-                                return obj.ethProviderRequest(...argumentList);
-                            case 'ethProviderRequestV2':
-                                return obj.ethProviderRequestV2(...argumentList);
-                            case 'eip6963RequestProvider':
-                                return obj.eip6963RequestProvider(...argumentList);
-                            case 'addFrame':
-                                return obj.addFrame(...argumentList);
-                            case 'composeCast':
-                                return obj.composeCast(...argumentList);
-                            case 'viewCast':
-                                return obj.viewCast(...argumentList);
-                            case 'viewProfile':
-                                return obj.viewProfile(...argumentList);
-                            case 'viewToken':
-                                return obj.viewToken(...argumentList);
-                            case 'swapToken':
-                                return obj.swapToken(...argumentList);
-                            case 'sendToken':
-                                return obj.sendToken(...argumentList);
-                            case 'solanaProviderRequest':
-                                return obj.solanaProviderRequest(...argumentList);
-                            case 'getCapabilities':
-                                return obj.getCapabilities(...argumentList);
-                            case 'getChains':
-                                return obj.getChains(...argumentList);
-                            case 'impactOccurred':
-                                return obj.impactOccurred(...argumentList);
-                            case 'notificationOccurred':
-                                return obj.notificationOccurred(...argumentList);
-                            case 'selectionChanged':
-                                return obj.selectionChanged(...argumentList);
-                            case 'updateBackState':
-                                return obj.updateBackState(...argumentList);
-                            default:
-                                throw new Error(`Unsupported APPLY for ${path.join('/')}`);
-                        }
-                    })();
-                    break;
-                }
-                case MessageType.SET:
-                    throw new Error(`Unsupported SET for ${path.join('/')}`);
-                case MessageType.CONSTRUCT:
-                    throw new Error(`Unsupported CONSTRUCT for ${path.join('/')}`);
-                case MessageType.ENDPOINT:
-                    throw new Error(`Unsupported ENDPOINT for ${path.join('/')}`);
-                default:
-                    return;
-            }
-        }
-        catch (value) {
-            returnValue = { value, [throwMarker]: 0 };
-        }
-        Promise.resolve(returnValue)
-            .catch((value) => {
-            return { value, [throwMarker]: 0 };
-        })
-            .then((returnValue) => {
-            const [wireValue, transferables] = toWireValue(returnValue);
-            ep.postMessage({ ...wireValue, id }, transferables);
-            if (type === MessageType.RELEASE) {
-                // detach and deactive after sending release response above.
-                ep.removeEventListener('message', callback);
-                closeEndPoint(ep);
-                if (finalizer in obj && typeof obj[finalizer] === 'function') {
-                    obj[finalizer]();
-                }
-            }
-        })
-            .catch(() => {
-            // Send Serialization Error To Caller
-            const [wireValue, transferables] = toWireValue({
-                value: new TypeError('Unserializable return value'),
-                [throwMarker]: 0,
-            });
-            ep.postMessage({ ...wireValue, id }, transferables);
-        });
-    }
-    ep.addEventListener('message', callback);
-    if (ep.start) {
-        ep.start();
-    }
-    return () => {
-        ep.removeEventListener('message', callback);
-        closeEndPoint(ep);
-        if (finalizer in obj && typeof obj[finalizer] === 'function') {
-            obj[finalizer]();
-        }
-    };
-}
-function isMessagePort(endpoint) {
-    return endpoint.constructor.name === 'MessagePort';
-}
-function closeEndPoint(endpoint) {
-    if (isMessagePort(endpoint))
-        endpoint.close();
-}
-export function wrap(ep, target) {
-    const pendingListeners = new Map();
-    ep.addEventListener('message', function handleMessage(ev) {
-        const { data } = ev;
-        if (!data || !data.id) {
-            return;
-        }
-        const resolver = pendingListeners.get(data.id);
-        if (!resolver) {
-            return;
-        }
-        try {
-            resolver(data);
-        }
-        finally {
-            pendingListeners.delete(data.id);
-        }
-    });
-    return createProxy(ep, pendingListeners, [], target);
-}
-function throwIfProxyReleased(isReleased) {
-    if (isReleased) {
-        throw new Error('Proxy has been released and is not useable');
-    }
-}
-function releaseEndpoint(ep) {
-    return requestResponseMessage(ep, new Map(), {
-        type: MessageType.RELEASE,
-    }).then(() => {
-        closeEndPoint(ep);
-    });
-}
-const proxyCounter = new WeakMap();
-const proxyFinalizers = 'FinalizationRegistry' in globalThis &&
-    new FinalizationRegistry((ep) => {
-        const newCount = (proxyCounter.get(ep) || 0) - 1;
-        proxyCounter.set(ep, newCount);
-        if (newCount === 0) {
-            releaseEndpoint(ep);
-        }
-    });
-function registerProxy(proxy, ep) {
-    const newCount = (proxyCounter.get(ep) || 0) + 1;
-    proxyCounter.set(ep, newCount);
-    if (proxyFinalizers) {
-        proxyFinalizers.register(proxy, ep, proxy);
-    }
-}
-function unregisterProxy(proxy) {
-    if (proxyFinalizers) {
-        proxyFinalizers.unregister(proxy);
-    }
-}
-function createProxy(ep, pendingListeners, path = [], target = () => { }) {
-    let isProxyReleased = false;
-    const proxy = new Proxy(target, {
-        get(_target, prop) {
-            throwIfProxyReleased(isProxyReleased);
-            if (prop === releaseProxy) {
-                return () => {
-                    unregisterProxy(proxy);
-                    releaseEndpoint(ep);
-                    pendingListeners.clear();
-                    isProxyReleased = true;
-                };
-            }
-            if (prop === 'then') {
-                if (path.length === 0) {
-                    return { then: () => proxy };
-                }
-                const r = requestResponseMessage(ep, pendingListeners, {
-                    type: MessageType.GET,
-                    path: path.map((p) => p.toString()),
-                }).then(fromWireValue);
-                return r.then.bind(r);
-            }
-            return createProxy(ep, pendingListeners, [...path, prop]);
-        },
-        set(_target) {
-            throwIfProxyReleased(isProxyReleased);
-            throw new Error("Unsupported call to set");
-        },
-        apply(_target, _thisArg, rawArgumentList) {
-            throwIfProxyReleased(isProxyReleased);
-            const last = path[path.length - 1];
-            if (last === createEndpoint) {
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: MessageType.ENDPOINT,
-                }).then(fromWireValue);
-            }
-            // We just pretend that `bind()` didn’t happen.
-            if (last === 'bind') {
-                return createProxy(ep, pendingListeners, path.slice(0, -1));
-            }
-            const [argumentList, transferables] = processArguments(rawArgumentList);
-            return requestResponseMessage(ep, pendingListeners, {
-                type: MessageType.APPLY,
-                path: path.map((p) => p.toString()),
-                argumentList,
-            }, transferables).then(fromWireValue);
-        },
-        construct(_target) {
-            throw new Error("Unsupported call to construct");
-        },
-    });
-    registerProxy(proxy, ep);
-    return proxy;
-}
-function myFlat(arr) {
-    return Array.prototype.concat.apply([], arr);
-}
-function processArguments(argumentList) {
-    const processed = argumentList.map(toWireValue);
-    return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-}
-const transferCache = new WeakMap();
-export function transfer(obj, transfers) {
-    transferCache.set(obj, transfers);
-    return obj;
-}
-export function proxy(obj) {
-    return Object.assign(obj, { [proxyMarker]: true });
-}
-export function windowEndpoint(w, context = globalThis, targetOrigin = '*') {
-    return {
-        postMessage: (msg, transferables) => w.postMessage(msg, targetOrigin, transferables),
-        addEventListener: context.addEventListener.bind(context),
-        removeEventListener: context.removeEventListener.bind(context),
-    };
-}
-function toWireValue(value) {
-    for (const [name, handler] of transferHandlers) {
-        if (handler.canHandle(value)) {
-            const [serializedValue, transferables] = handler.serialize(value);
-            return [
-                {
-                    type: WireValueType.HANDLER,
-                    name,
-                    value: serializedValue,
-                },
-                transferables,
-            ];
-        }
-    }
-    return [
-        {
-            type: WireValueType.RAW,
-            value,
-        },
-        transferCache.get(value) || [],
-    ];
-}
-function fromWireValue(value) {
-    switch (value.type) {
-        case WireValueType.HANDLER:
-            return transferHandlers.get(value.name).deserialize(value.value);
-        case WireValueType.RAW:
-            return value.value;
-    }
-}
-function requestResponseMessage(ep, pendingListeners, msg, transfers) {
-    return new Promise((resolve) => {
-        const id = generateUUID();
-        pendingListeners.set(id, resolve);
-        if (ep.start) {
-            ep.start();
-        }
-        ep.postMessage({ id, ...msg }, transfers);
-    });
-}
-function generateUUID() {
-    return new Array(4)
-        .fill(0)
-        .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-        .join('-');
-}

package/dist/comlink/index.d.ts

@@ -1 +0,0 @@
-export * from './comlink.ts';

package/dist/comlink/index.js

@@ -1 +0,0 @@
-export * from "./comlink.js";

package/dist/comlink/node-adapter.d.ts

@@ -1,13 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import type { Endpoint } from './protocol';
-export interface NodeEndpoint {
-    postMessage(message: any, transfer?: any[]): void;
-    on(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
-    off(type: string, listener: EventListenerOrEventListenerObject, options?: {}): void;
-    start?: () => void;
-}
-export default function nodeEndpoint(nep: NodeEndpoint): Endpoint;

package/dist/comlink/node-adapter.js

@@ -1,32 +0,0 @@
-/**
- * @license
- * Copyright 2019 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-export default function nodeEndpoint(nep) {
-    const listeners = new WeakMap();
-    return {
-        postMessage: nep.postMessage.bind(nep),
-        addEventListener: (_, eh) => {
-            const l = (data) => {
-                if ('handleEvent' in eh) {
-                    eh.handleEvent({ data });
-                }
-                else {
-                    eh({ data });
-                }
-            };
-            nep.on('message', l);
-            listeners.set(eh, l);
-        },
-        removeEventListener: (_, eh) => {
-            const l = listeners.get(eh);
-            if (!l) {
-                return;
-            }
-            nep.off('message', l);
-            listeners.delete(eh);
-        },
-        start: nep.start?.bind(nep),
-    };
-}