@nascentdigital/funnel-apps 4.4.18

package/dist/react/auth0/server/Auth0ProfileStore.d.ts

@@ -0,0 +1,17 @@
+import { ManagementClient } from 'auth0';
+import { ProfileStore } from '../../profile/domain';
+export declare class Auth0ProfileStore<TData extends ProfileStore.Data = ProfileStore.Data> extends ProfileStore<TData> {
+    private readonly _managementClient;
+    private readonly _internalKeyPrefix?;
+    constructor({ managementClient, internalKeyPrefix, ...args }: Auth0ProfileStore.ConstructorArgs<TData>);
+    protected get internalStoreKey(): string;
+    save(): Promise<void>;
+}
+export declare namespace Auth0ProfileStore {
+    type ConstructorArgs<TData extends ProfileStore.Data> = ProfileStore.ConstructorArgs<TData> & {
+        internalKeyPrefix?: string;
+        managementClient: ManagementClient;
+    };
+    function toInternalKey(logicalKey: string, prefix?: string): string;
+    function toExternalKey(internalKey: string, prefix?: string): string;
+}

package/dist/react/auth0/server/Auth0ProfileStore.js

@@ -0,0 +1,83 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileStore = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const domain_1 = require("../../profile/domain");
+// class
+class Auth0ProfileStore extends domain_1.ProfileStore {
+    constructor(_a) {
+        var { managementClient, internalKeyPrefix } = _a, args = __rest(_a, ["managementClient", "internalKeyPrefix"]);
+        // construct base
+        super(args);
+        // initialize instance variables
+        this._managementClient = managementClient;
+        this._internalKeyPrefix = internalKeyPrefix;
+    }
+    get internalStoreKey() {
+        return Auth0ProfileStore.toInternalKey(this.id, this._internalKeyPrefix);
+    }
+    async save() {
+        var _a;
+        // bail if there is nothing to save
+        if (this._edits.size === 0 && this._deletes.size === 0) {
+            return;
+        }
+        // get store data to save
+        // NOTE: only want to store custom data & __internals, so we ignore id, profileId when saving
+        const _b = this.toData(), { id, profileId } = _b, storeData = __rest(_b, ["id", "profileId"]);
+        // try to save
+        try {
+            // execute save request
+            // NOTE: management client merges app_metadata for us
+            const updatedData = await this._managementClient.users.update(this.profileId, {
+                app_metadata: {
+                    [this.internalStoreKey]: Object.entries(storeData).length === 0
+                        ? null
+                        : storeData
+                }
+            });
+            // update store data
+            const updatedStoreData = (_a = updatedData.app_metadata) === null || _a === void 0 ? void 0 : _a[this.internalStoreKey];
+            this._data = Object.assign(Object.assign({}, updatedStoreData), { profileId,
+                id });
+            // clear changes
+            this._edits.clear();
+            this._deletes.clear();
+            // raise event
+            this.raiseEvent('saved');
+        }
+        // handle error
+        catch (e) {
+            console.error(`Error saving profile store "${this.id}"`, e);
+            throw new funnel_core_1.ServerError(`Error saving profile store "${this.id}"`);
+        }
+    }
+}
+exports.Auth0ProfileStore = Auth0ProfileStore;
+// extension
+(function (Auth0ProfileStore) {
+    // helpers
+    function toInternalKey(logicalKey, prefix) {
+        prefix = prefix
+            ? `${prefix}-`
+            : '';
+        return prefix + logicalKey;
+    }
+    Auth0ProfileStore.toInternalKey = toInternalKey;
+    function toExternalKey(internalKey, prefix) {
+        const start = prefix ? prefix.length + 1 : 0;
+        return internalKey.substring(start);
+    }
+    Auth0ProfileStore.toExternalKey = toExternalKey;
+})(Auth0ProfileStore || (exports.Auth0ProfileStore = Auth0ProfileStore = {}));

package/dist/react/auth0/server/Auth0ProfileUserService.d.ts

@@ -0,0 +1,16 @@
+import { Identity } from '../../identity/server';
+import { Profile, ProfileUserService } from '../../profile/server';
+export declare class Auth0ProfileUserService implements ProfileUserService {
+    private readonly _managementClient;
+    private readonly _internalStoreKeyPrefix?;
+    constructor(args: Auth0ProfileUserService.ConstructorArgs);
+    getProfile(identity: Identity): Promise<Profile>;
+}
+export declare namespace Auth0ProfileUserService {
+    type ConstructorArgs = {
+        domain: string;
+        clientId: string;
+        clientSecret: string;
+        internalStoreKeyPrefix?: string;
+    };
+}

package/dist/react/auth0/server/Auth0ProfileUserService.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0ProfileUserService = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const auth0_1 = require("auth0");
+const Auth0ProfileFactory_1 = require("./Auth0ProfileFactory");
+// service
+class Auth0ProfileUserService {
+    constructor(args) {
+        this._managementClient = new auth0_1.ManagementClient({
+            domain: args.domain,
+            clientId: args.clientId,
+            clientSecret: args.clientSecret
+        });
+        this._internalStoreKeyPrefix = args.internalStoreKeyPrefix;
+    }
+    async getProfile(identity) {
+        // try to get profile
+        try {
+            // fetch user data
+            const data = await this._managementClient.users.get(identity.id);
+            // create profile
+            return Auth0ProfileFactory_1.Auth0ProfileFactory.create({
+                data,
+                identity,
+                managementClient: this._managementClient,
+                internalStoreKeyPrefix: this._internalStoreKeyPrefix
+            });
+        }
+        // handle error
+        catch (e) {
+            // rethrow if ours
+            if (e instanceof funnel_core_1.IsometricError) {
+                throw e;
+            }
+            // profile not found
+            else if (e instanceof auth0_1.Management.NotFoundError) {
+                throw new funnel_core_1.NotAuthenticatedError(`Cannot find profile with id "${identity.id}"`);
+            }
+            // some other error
+            else {
+                console.error(`Error fetching profile "${identity.id}"`, e);
+                throw new funnel_core_1.ServerError(`Error fetching profile "${identity.id}"`);
+            }
+        }
+    }
+}
+exports.Auth0ProfileUserService = Auth0ProfileUserService;

package/dist/react/auth0/server/index.d.ts

@@ -0,0 +1,4 @@
+import 'server-only';
+export * from './Auth0IdentityService';
+export * from './Auth0ProfileServices';
+export * from './Auth0ProfileUserService';

package/dist/react/auth0/server/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("server-only");
+__exportStar(require("./Auth0IdentityService"), exports);
+__exportStar(require("./Auth0ProfileServices"), exports);
+__exportStar(require("./Auth0ProfileUserService"), exports);

package/dist/react/auth0/web/Auth0IdentityClient.d.ts

@@ -0,0 +1,34 @@
+import { Auth0ContextInterface, User } from '@auth0/auth0-react';
+import { AbstractIdentityClient, IdentityClient } from '../../identity/web';
+export declare class Auth0IdentityClient extends AbstractIdentityClient {
+    private _auth0?;
+    private readonly _webClient;
+    private readonly _audience;
+    private readonly _redirectUri;
+    private readonly _userDb;
+    private _triedCallback;
+    private _handledCallback;
+    constructor(args: Auth0IdentityClient.ConstructorArgs);
+    get auth0(): Auth0ContextInterface;
+    set auth0(auth0: Auth0ContextInterface);
+    get availableMethods(): ReadonlyArray<IdentityClient.Method>;
+    get handledCallback(): boolean;
+    bindUser(auth0User?: User): Promise<void>;
+    login(method?: IdentityClient.Method): Promise<void>;
+    loginWithEmail(email: string, password: string): Promise<void>;
+    logout(): Promise<void>;
+    createAccount(email: string, password: string): Promise<void>;
+    resetAccount(email: string): Promise<void>;
+    deleteAccount(): Promise<void>;
+    tryHandleCallback(): Promise<void>;
+}
+export declare namespace Auth0IdentityClient {
+    type ConstructorArgs = {
+        domain: string;
+        clientId: string;
+        audience: string;
+        redirectUri: string;
+        userDb: string;
+        scope: string;
+    };
+}

package/dist/react/auth0/web/Auth0IdentityClient.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0IdentityClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const auth0_js_1 = require("auth0-js");
+const web_1 = require("../../app/web");
+const web_2 = require("../../identity/web");
+// class
+class Auth0IdentityClient extends web_2.AbstractIdentityClient {
+    constructor(args) {
+        // construct base
+        super();
+        // initialize instance variables
+        this._webClient = new auth0_js_1.WebAuth({
+            domain: args.domain,
+            clientID: args.clientId,
+            redirectUri: args.redirectUri,
+            scope: args.scope,
+            responseType: 'id_token'
+        });
+        this._audience = args.audience;
+        this._redirectUri = args.redirectUri;
+        this._userDb = args.userDb;
+        this._triedCallback = false;
+        this._handledCallback = false;
+    }
+    get auth0() {
+        // throw if not bound
+        const { _auth0 } = this;
+        if (!_auth0) {
+            throw new funnel_core_1.InvalidOperationError('Attempt to access auth0 before being bount');
+        }
+        // return interface
+        return _auth0;
+    }
+    set auth0(auth0) {
+        // bind context (needed for methods)
+        this._auth0 = auth0;
+    }
+    get availableMethods() {
+        return web_2.IdentityClient.Method.all;
+    }
+    get handledCallback() {
+        return this._handledCallback;
+    }
+    async bindUser(auth0User) {
+        var _a, _b;
+        // anonymous identity if no user
+        if (!auth0User || !auth0User.sub) {
+            this.identity = new web_2.AnonymousIdentity({ id: '' });
+            return;
+        }
+        // get api token
+        const apiToken = await this.auth0.getAccessTokenSilently({
+            authorizationParams: { audience: this._audience }
+        });
+        // create authenticated identity
+        this.identity = new web_2.AuthenticatedIdentity({
+            apiToken,
+            id: auth0User.sub,
+            email: auth0User.email,
+            verified: auth0User.email_verified || false,
+            nickname: auth0User.nickname || undefined,
+            name: auth0User.name || `${(_a = auth0User.given_name) !== null && _a !== void 0 ? _a : ''} ${(_b = auth0User.family_name) !== null && _b !== void 0 ? _b : ''}`.trim() || undefined
+        });
+    }
+    async login(method) {
+        // TODO: hoist mapping from method to connection
+        let connection = undefined;
+        switch (method) {
+            case 'google':
+                connection = 'google-oauth2';
+                break;
+            case 'apple':
+                connection = 'apple';
+                break;
+            case 'facebook':
+                connection = 'facebook';
+                break;
+            case 'linkedin':
+                connection = 'linkedin';
+                break;
+        }
+        // login with popup
+        await this.auth0.loginWithPopup({
+            authorizationParams: { connection, prompt: 'select_account' }
+        });
+    }
+    async loginWithEmail(email, password) {
+        return new Promise((resolve, reject) => {
+            this._webClient.login({
+                email,
+                password,
+                realm: this._userDb
+            }, error => {
+                // bail if no error
+                console.error('[Auth0IdentityClient] loginWithEmail', error);
+                if (!error) {
+                    resolve();
+                }
+                // throw isometric error
+                else if (error.code === 'access_denied') {
+                    reject(new funnel_core_1.NotAuthenticatedError('Invalid email or password'));
+                }
+                else if (error.code === 'too_many_attempts') {
+                    reject(new funnel_core_1.TimeoutError('Too many attempts'));
+                }
+                else {
+                    reject(new funnel_core_1.ServerError('Something went wrong, please try again'));
+                }
+            });
+        });
+    }
+    async logout() {
+        await this.auth0.logout({
+            logoutParams: { returnTo: this._redirectUri }
+        });
+    }
+    async createAccount(email, password) {
+        return new Promise((resolve, reject) => {
+            this._webClient.signup({
+                email,
+                password,
+                connection: this._userDb
+            }, error => {
+                // bail if no error
+                console.error('[Auth0IdentityClient] createAccount', error);
+                if (!error) {
+                    resolve();
+                }
+                // throw isometric error
+                else {
+                    reject(new funnel_core_1.ServerError(error.description));
+                }
+            });
+        });
+    }
+    async resetAccount(email) {
+        throw new funnel_core_1.NotImplementedError();
+    }
+    async deleteAccount() {
+        // make sure identity is authenticated
+        const { identity } = this;
+        if (!(identity instanceof web_2.AuthenticatedIdentity)) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // try to delete identity
+        try {
+            // send request to delete
+            await web_1.AppServiceClient.post({
+                apiToken: identity.apiToken,
+                id: '_nd-identity',
+                method: 'delete',
+                data: null
+            });
+            // logout
+            await this.logout();
+        }
+        // handle error
+        catch (e) {
+            console.error('[Auth0IdentityClient] error deleting identity', e);
+            throw e;
+        }
+    }
+    async tryHandleCallback() {
+        // only execute this once
+        if (this._triedCallback) {
+            return;
+        }
+        this._triedCallback = true;
+        // mark as handled if there is a hash with id_token
+        if (window.location.hash.includes('id_token')) {
+            this._handledCallback = true;
+        }
+        // bail if there is nothing to handle
+        else {
+            return;
+        }
+        // handle parsing of id_token value in window.location.hash
+        return new Promise((resolve) => {
+            this._webClient.parseHash((error, data) => {
+                // throw if error from parsing hash
+                if (error) {
+                    console.error('Issue handling Auth0 callback', error);
+                    throw new funnel_core_1.NotAuthenticatedError('Issue handling Auth0 callback');
+                }
+                // throw error if no token payload
+                if (!(data === null || data === void 0 ? void 0 : data.idTokenPayload)) {
+                    resolve();
+                    return;
+                }
+                // remove hash from window location
+                window.location.hash = '';
+                // bind user and resolve
+                this.bindUser(data.idTokenPayload).then(resolve);
+            });
+        });
+    }
+}
+exports.Auth0IdentityClient = Auth0IdentityClient;

package/dist/react/auth0/web/Auth0IdentityClientProvider.d.ts

@@ -0,0 +1,35 @@
+import { PropsWithChildren } from 'react';
+import { WebIdentityClientProvider } from '../../identity/web';
+export declare class Auth0IdentityClientProvider implements WebIdentityClientProvider {
+    private readonly _domain;
+    private readonly _clientId;
+    private readonly _audience;
+    private readonly _redirectUri;
+    private readonly _userDb;
+    private readonly _scope;
+    constructor(args: Auth0IdentityClientProvider.ConstructorArgs);
+    createProvider(): ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+    readonly ProviderComponent: typeof Auth0IdentityProvider;
+}
+export declare namespace Auth0IdentityClientProvider {
+    type ConstructorArgs = {
+        domain: string;
+        clientId: string;
+        audience: string;
+        redirectUri: string;
+        userDb: string;
+        scope?: string;
+    };
+}
+declare function Auth0IdentityProvider({ domain, clientId, audience, redirectUri, userDb, scope, children }: Auth0IdentityProvider.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace Auth0IdentityProvider {
+    type Props = PropsWithChildren & {
+        domain: string;
+        clientId: string;
+        audience: string;
+        redirectUri: string;
+        userDb: string;
+        scope: string;
+    };
+}
+export {};

package/dist/react/auth0/web/Auth0IdentityClientProvider.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0IdentityClientProvider = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const auth0_react_1 = require("@auth0/auth0-react");
+const react_1 = require("react");
+const web_1 = require("../../identity/web");
+const Auth0IdentityClient_1 = require("./Auth0IdentityClient");
+// class
+class Auth0IdentityClientProvider {
+    constructor(args) {
+        var _a;
+        this.ProviderComponent = Auth0IdentityProvider;
+        // initialize instance variables
+        this._domain = args.domain;
+        this._clientId = args.clientId;
+        this._audience = args.audience;
+        this._redirectUri = args.redirectUri;
+        this._userDb = args.userDb;
+        this._scope = (_a = args.scope) !== null && _a !== void 0 ? _a : 'openid profile email offline_access';
+    }
+    createProvider() {
+        // bind props
+        const { _domain, _clientId, _audience, _redirectUri, _userDb, _scope } = this;
+        // return provider
+        return function Provider({ children }) {
+            return ((0, jsx_runtime_1.jsx)(auth0_react_1.Auth0Provider, { domain: _domain, clientId: _clientId, authorizationParams: { redirect_uri: _redirectUri, scope: _scope }, children: (0, jsx_runtime_1.jsx)(Auth0IdentityProvider, { domain: _domain, clientId: _clientId, audience: _audience, redirectUri: _redirectUri, userDb: _userDb, scope: _scope, children: children }) }));
+        };
+    }
+}
+exports.Auth0IdentityClientProvider = Auth0IdentityClientProvider;
+// provider
+function Auth0IdentityProvider({ domain, clientId, audience, redirectUri, userDb, scope, children }) {
+    // bind context
+    const auth0 = (0, auth0_react_1.useAuth0)();
+    const identityClient = (0, react_1.useMemo)(() => new Auth0IdentityClient_1.Auth0IdentityClient({ domain, clientId, audience, redirectUri, userDb, scope }), [domain, clientId, audience, redirectUri, userDb, scope]);
+    const context = (0, react_1.useMemo)(() => ({ identityClient }), [identityClient]);
+    // bind auth0
+    identityClient.auth0 = auth0;
+    // handle auth0 embedded login callback
+    (0, react_1.useEffect)(() => {
+        // try to handle callback
+        identityClient.tryHandleCallback()
+            .catch(e => identityClient.error = e);
+    }, [identityClient]);
+    // try to bind user on mount if already logged in
+    (0, react_1.useEffect)(() => {
+        // bail if handling auth0 callback
+        // when logging in, auth0 react context shouldn't be used
+        if (identityClient.handledCallback) {
+            return;
+        }
+        // bail if loading
+        if (auth0.isLoading) {
+            return;
+        }
+        // bind user when done loading
+        identityClient.bindUser(auth0.user)
+            .catch(e => identityClient.error = e);
+        // auth0.user is left out of dependency array on purpose.
+        // The useAuth0 hook returns new object each render for some reason.
+        // Depending on isLoading is enough: if isLoading changes then user should be changed too.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [identityClient, auth0.isLoading]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(web_1.IdentityClientContext.Provider, { value: context, children: children }));
+}

package/dist/react/auth0/web/index.d.ts

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

package/dist/react/auth0/web/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Auth0IdentityClientProvider"), exports);

package/dist/react/bridge/core/BridgeConnection.d.ts

@@ -0,0 +1,6 @@
+export type BridgeConnection = 'uninitialized' | 'initializing' | 'ready' | 'error';
+export declare namespace BridgeConnection {
+    type ConnectArgs = {
+        webViewId: string;
+    };
+}

package/dist/react/bridge/core/BridgeConnection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/react/bridge/core/BridgeConstants.d.ts

@@ -0,0 +1,7 @@
+export declare namespace BridgeConstants {
+    namespace Window {
+        const initialState: "__nd_bridge_initialState";
+        const bridgeId: "__nd_bridgeId";
+        const bridge: "__nd_bridge";
+    }
+}

package/dist/react/bridge/core/BridgeConstants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeConstants = void 0;
+// namespace
+var BridgeConstants;
+(function (BridgeConstants) {
+    // internals
+    let Window;
+    (function (Window) {
+        // global variables
+        Window.initialState = '__nd_bridge_initialState';
+        Window.bridgeId = '__nd_bridgeId';
+        Window.bridge = '__nd_bridge';
+    })(Window = BridgeConstants.Window || (BridgeConstants.Window = {}));
+})(BridgeConstants || (exports.BridgeConstants = BridgeConstants = {}));

package/dist/react/bridge/core/BridgeEvent.d.ts

@@ -0,0 +1,52 @@
+import { SerializedIsometricError } from '@nascentdigital/funnel-core';
+import { JsonValue } from 'type-fest';
+import { BridgeMethod } from './BridgeMethod';
+import { BridgeState } from './BridgeState';
+export type BridgeEvent = BridgeEvent.Log | BridgeEvent.State.Sync | BridgeEvent.State.Set | BridgeEvent.Call.Invoke | BridgeEvent.Call.Result | BridgeEvent.Call.Error;
+export declare namespace BridgeEvent {
+    type Log = {
+        __type: 'log';
+        webViewId: string;
+        level: Log.Level;
+        args: JsonValue[];
+    };
+    namespace Log {
+        type Level = 'debug' | 'info' | 'warn' | 'error';
+    }
+    namespace State {
+        type Sync = {
+            __type: 'state.sync';
+            state: BridgeState;
+        };
+        type Set = {
+            __type: 'state.set';
+            key: string;
+            value: JsonValue;
+        };
+    }
+    namespace Call {
+        type Invoke<TMethod extends BridgeMethod = BridgeMethod> = {
+            __type: 'call.invocation';
+            webViewId: string;
+            id: string;
+            method: TMethod['name'];
+            args: TMethod['args'];
+        };
+        type Result<TMethod extends BridgeMethod = BridgeMethod> = {
+            __type: 'call.result';
+            webViewId: string;
+            id: string;
+            method: TMethod['name'];
+            result: TMethod['result'];
+        };
+        type Error<TMethod extends BridgeMethod = BridgeMethod> = {
+            __type: 'call.error';
+            webViewId: string;
+            id: string;
+            method: TMethod['name'];
+            error: SerializedIsometricError;
+        };
+    }
+    function filter(event: any): event is BridgeEvent;
+    function parse(eventData: string): BridgeEvent | undefined;
+}

package/dist/react/bridge/core/BridgeEvent.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeEvent = void 0;
+// extension
+var BridgeEvent;
+(function (BridgeEvent) {
+    // methods
+    function filter(event) {
+        return !!event
+            && typeof event === 'object'
+            && !Array.isArray(event)
+            && '__type' in event && typeof event.__type === 'string';
+    }
+    BridgeEvent.filter = filter;
+    function parse(eventData) {
+        // convert event
+        try {
+            // bail if not
+            const event = JSON.parse(eventData);
+            return filter(event) ? event : undefined;
+        }
+        // handle failure
+        catch (_a) {
+            return undefined;
+        }
+    }
+    BridgeEvent.parse = parse;
+})(BridgeEvent || (exports.BridgeEvent = BridgeEvent = {}));