@nascentdigital/funnel-apps 4.4.18

package/dist/reactnative/auth0/rn/Auth0IdentityClient.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth0IdentityClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const react_native_auth0_1 = require("react-native-auth0");
+const rn_1 = require("../../identity/rn");
+// class
+class Auth0IdentityClient extends rn_1.AbstractIdentityClient {
+    constructor(args) {
+        var _a;
+        // construct base
+        super();
+        // initialize instance variables
+        this.scope = args.scope;
+        this.customScheme = args.customScheme;
+        this.ephemeralSession = (_a = args.ephemeralSession) !== null && _a !== void 0 ? _a : false;
+        this.audience = args.audience;
+        this.userDb = args.userDb;
+        this.connections = new Map(Object.entries(args.connections));
+        console.log('[Auth0IdentityClient] constructed with userDb', this.userDb);
+    }
+    get availableMethods() {
+        return rn_1.IdentityClient.Method.all;
+    }
+    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) {
+        console.debug('[Auth0IdentityClient] setting auth0');
+        // bind context (needed for methods)
+        this._auth0 = auth0;
+        // update identity
+        const { user, isLoading } = auth0;
+        if (!isLoading) {
+            // get api token (if required)
+            if (user) {
+                this.getApiToken()
+                    .then(apiToken => {
+                    var _a, _b;
+                    if (apiToken) {
+                        console.log('[Auth0IdentityClient] creating authenticated user', { user, apiToken });
+                        this.identity = new rn_1.AuthenticatedIdentity({
+                            id: user.sub,
+                            verified: (_b = (_a = user.emailVerified) !== null && _a !== void 0 ? _a : user.phoneNumberVerified) !== null && _b !== void 0 ? _b : false,
+                            email: user.email,
+                            nickname: user.nickname,
+                            name: user.name,
+                            apiToken
+                        });
+                    }
+                    else {
+                        console.log('[Auth0IdentityClient] no token for user', user);
+                        this.identity = new rn_1.AnonymousIdentity({ id: 'test' });
+                    }
+                })
+                    .catch(e => {
+                    console.error('[Auth0IdentityClient] failed to fetch token', e);
+                    this.identity = new rn_1.AnonymousIdentity({ id: 'test' });
+                });
+            }
+            else {
+                console.log('[Auth0IdentityClient] no user is logged in', user);
+                this.identity = new rn_1.AnonymousIdentity({ id: 'test' });
+            }
+        }
+    }
+    async getApiToken() {
+        // skip if there's no audience
+        const { audience } = this;
+        if (!audience) {
+            return undefined;
+        }
+        // TODO: invalidate after some threshold
+        // create new promise if required
+        let { _apiTokenPromise } = this;
+        if (!_apiTokenPromise) {
+            _apiTokenPromise = new Promise((resolve, reject) => {
+                this.auth0
+                    .getApiCredentials(audience, undefined, undefined, { audience })
+                    .then(credentials => resolve(credentials.accessToken))
+                    .catch(e => {
+                    console.error('[Auth0IdentityClient] failed to fetch API token', e);
+                    reject(new funnel_core_1.NotAuthenticatedError('Unable to fetch API token'));
+                });
+            });
+        }
+        // return promise
+        return _apiTokenPromise;
+    }
+    async login(method) {
+        var _a;
+        // determine connection
+        const { auth0, scope, audience, customScheme, ephemeralSession, connections } = this;
+        let connection = method
+            ? (_a = connections.get(method)) !== null && _a !== void 0 ? _a : undefined
+            : undefined;
+        switch (method) {
+            case 'google':
+                connection = connection !== null && connection !== void 0 ? connection : 'google-oauth2';
+                break;
+            case 'apple':
+                connection = connection !== null && connection !== void 0 ? connection : 'apple';
+                break;
+            case 'facebook':
+                connection = connection !== null && connection !== void 0 ? connection : 'facebook';
+                break;
+            case 'linkedin':
+                connection = connection !== null && connection !== void 0 ? connection : 'linkedin';
+                break;
+        }
+        console.log('[Auth0IdentityClient] signing in with connection', connection);
+        // authenticate (profile comes later)
+        try {
+            await auth0.authorize({ scope, audience, connection }, { customScheme, ephemeralSession });
+        }
+        // handle errors
+        catch (e) {
+            // handle web auth error
+            if (e instanceof react_native_auth0_1.WebAuthError) {
+                switch (e.code) {
+                    // ignore cancellation
+                    case react_native_auth0_1.WebAuthErrorCodes.USER_CANCELLED:
+                        console.log('[Auth0IdentityClient] login cancelled');
+                        break;
+                    // TODO: or display an error
+                    default:
+                        console.error('[Auth0IdentityClient] login failed', e.code);
+                        break;
+                }
+            }
+            // or unexpected errors
+            else {
+                console.error('[Auth0IdentityClient] failed to authenticate', e);
+            }
+        }
+    }
+    async loginWithEmail(email, password) {
+        // try to login
+        const { auth0, scope, audience, userDb = '' } = this;
+        try {
+            await auth0.loginWithPasswordRealm({
+                username: email,
+                password,
+                scope,
+                audience,
+                realm: userDb
+            });
+            console.log(`[Auth0IdentityClient] login success for ${email}`);
+        }
+        // handle errors
+        catch (e) {
+            console.error('[Auth0IdentityClient] email login failed', e);
+        }
+    }
+    async logout() {
+        const { auth0, customScheme, ephemeralSession } = this;
+        if (ephemeralSession) {
+            await auth0.clearCredentials();
+        }
+        else {
+            await auth0.clearSession({}, { customScheme });
+        }
+    }
+    async createAccount(email, password) {
+        // try to create account
+        const { auth0, scope, userDb = '' } = this;
+        try {
+            console.log(`[Auth0IdentityClient] creating mail account for ${email} in ${userDb}`);
+            const user = await auth0.createUser({
+                email,
+                password,
+                connection: userDb,
+                scope
+            });
+            console.log('[Auth0IdentityClient] user created', user);
+        }
+        // handle errors
+        catch (e) {
+            // handle web auth error
+            if (e instanceof react_native_auth0_1.AuthError) {
+                switch (e.code) {
+                    // email issues
+                    case 'user_exists':
+                    case 'invalid_signup':
+                        console.log('[Auth0IdentityClient] email already exists');
+                        break;
+                    // password issues
+                    case 'invalid_password':
+                        console.log('[Auth0IdentityClient] password isn\'t strong enough');
+                        break;
+                    case 'password_leaked':
+                        console.log('[Auth0IdentityClient] password has been leaked and can\'t be used');
+                        break;
+                    // TODO: or display an error
+                    default:
+                        console.error('[Auth0IdentityClient] email create account failed', e.code);
+                        break;
+                }
+            }
+            else if (e instanceof Error) {
+                console.error(`[Auth0IdentityClient] email create account failed for ${e.constructor.name}`, e);
+            }
+            // or unexpected errors
+            else {
+                console.error('[Auth0IdentityClient] email create account failed', e);
+            }
+        }
+    }
+    async resetAccount(email) {
+        // try to reset password
+        const { auth0, scope, userDb = '' } = this;
+        try {
+            await auth0.resetPassword({
+                email,
+                connection: userDb,
+                scope
+            });
+        }
+        // handle errors
+        catch (e) {
+            console.error('[Auth0IdentityClient] email reset password failed', e);
+        }
+    }
+    async deleteAccount() {
+        throw new funnel_core_1.NotImplementedError();
+    }
+}
+exports.Auth0IdentityClient = Auth0IdentityClient;

package/dist/reactnative/auth0/rn/Auth0IdentityClientProvider.d.ts

@@ -0,0 +1,27 @@
+import { PropsWithChildren } from 'react';
+import { IdentityClient, RNIdentityClientProvider } from '../../identity/rn';
+import { Auth0IdentityClient } from './Auth0IdentityClient';
+export declare class Auth0IdentityClientProvider implements RNIdentityClientProvider {
+    readonly domain: string;
+    readonly clientId: string;
+    readonly scope: string;
+    readonly customScheme: string;
+    readonly ephemeralSession: boolean;
+    readonly audience?: string;
+    readonly userDb?: string;
+    readonly connections: Readonly<Partial<Record<IdentityClient.Method, string>>>;
+    constructor(args: Auth0IdentityClientProvider.ConstructorArgs);
+    createProvider(): ({ children }: PropsWithChildren) => import("react").JSX.Element;
+    readonly ProviderComponent: typeof Auth0IdentityProvider;
+}
+export declare namespace Auth0IdentityClientProvider {
+    type ConstructorArgs = Auth0IdentityClient.ConstructorArgs & {
+        domain: string;
+        clientId: string;
+    };
+}
+declare function Auth0IdentityProvider({ children, ...args }: Auth0IdentityProvider.Props): import("react").JSX.Element;
+export declare namespace Auth0IdentityProvider {
+    type Props = PropsWithChildren & Auth0IdentityClient.ConstructorArgs;
+}
+export {};

package/dist/reactnative/auth0/rn/Auth0IdentityClientProvider.js

@@ -0,0 +1,60 @@
+"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.Auth0IdentityClientProvider = void 0;
+const react_1 = require("react");
+const react_native_auth0_1 = require("react-native-auth0");
+const rn_1 = require("../../identity/rn");
+const Auth0IdentityClient_1 = require("./Auth0IdentityClient");
+// class
+class Auth0IdentityClientProvider {
+    constructor(args) {
+        var _a, _b;
+        this.ProviderComponent = Auth0IdentityProvider;
+        // initialize instance variables
+        this.domain = args.domain;
+        this.clientId = args.clientId;
+        this.scope = args.scope;
+        this.customScheme = args.customScheme;
+        this.ephemeralSession = (_a = args.ephemeralSession) !== null && _a !== void 0 ? _a : false;
+        this.audience = args.audience;
+        this.userDb = args.userDb;
+        this.connections = (_b = args.connections) !== null && _b !== void 0 ? _b : {};
+    }
+    createProvider() {
+        // bind props
+        const { domain, clientId, scope, customScheme, ephemeralSession, audience, userDb, connections } = this;
+        // return provider
+        return function Provider({ children }) {
+            return (<react_native_auth0_1.Auth0Provider domain={domain} clientId={clientId}>
+          <Auth0IdentityProvider scope={scope} customScheme={customScheme} ephemeralSession={ephemeralSession} audience={audience} userDb={userDb} connections={connections}>
+            {children}
+          </Auth0IdentityProvider>
+        </react_native_auth0_1.Auth0Provider>);
+        };
+    }
+}
+exports.Auth0IdentityClientProvider = Auth0IdentityClientProvider;
+// provider
+function Auth0IdentityProvider(_a) {
+    var { children } = _a, args = __rest(_a, ["children"]);
+    // bind context
+    const identityClient = (0, react_1.useMemo)(() => new Auth0IdentityClient_1.Auth0IdentityClient(args), [args]);
+    const context = (0, react_1.useMemo)(() => ({ identityClient }), [identityClient]);
+    // bind auth0
+    identityClient.auth0 = (0, react_native_auth0_1.useAuth0)();
+    // render
+    return (<rn_1.IdentityClientContext.Provider value={context}>
+      {children}
+    </rn_1.IdentityClientContext.Provider>);
+}

package/dist/reactnative/auth0/rn/index.d.ts

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

package/dist/reactnative/auth0/rn/index.js

@@ -0,0 +1,18 @@
+"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("./Auth0IdentityClient"), exports);
+__exportStar(require("./Auth0IdentityClientProvider"), exports);

package/dist/reactnative/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/reactnative/bridge/core/BridgeConnection.js

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

package/dist/reactnative/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/reactnative/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/reactnative/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/reactnative/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 = {}));

package/dist/reactnative/bridge/core/BridgeMethod.d.ts

@@ -0,0 +1,12 @@
+import { Transform } from '@nascentdigital/funnel-core';
+import { JsonValue } from 'type-fest';
+export type BridgeMethod<TMethodName extends string = string> = {
+    name: TMethodName;
+    args: BridgeMethod.Args;
+    result: BridgeMethod.Result;
+};
+export declare namespace BridgeMethod {
+    type Args = Record<string, JsonValue>;
+    type Result = JsonValue;
+    type Signature<TMethod extends BridgeMethod = BridgeMethod> = Transform.Async<TMethod['args'], TMethod['result']>;
+}

package/dist/reactnative/bridge/core/BridgeMethod.js

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

package/dist/reactnative/bridge/core/BridgeMethodCall.d.ts

@@ -0,0 +1,23 @@
+import { Callback, IsometricError } from '@nascentdigital/funnel-core';
+import { BridgeEvent } from './BridgeEvent';
+import { BridgeMethod } from './BridgeMethod';
+export declare class BridgeMethodCall<TMethod extends BridgeMethod = BridgeMethod> {
+    readonly call: BridgeEvent.Call.Invoke<TMethod>;
+    private readonly _onResolve;
+    private readonly _onReject;
+    private _status;
+    constructor(args: BridgeMethodCall.ConstructorArgs<TMethod>);
+    get id(): string;
+    get method(): TMethod["name"];
+    get status(): BridgeMethodCall.Status;
+    resolve(result: TMethod['result']): Promise<void>;
+    reject(error: IsometricError): Promise<void>;
+}
+export declare namespace BridgeMethodCall {
+    type Status = 'pending' | 'resolved' | 'rejected';
+    type ConstructorArgs<TMethod extends BridgeMethod = BridgeMethod> = {
+        call: BridgeEvent.Call.Invoke<TMethod>;
+        onResolve: Callback.Async<TMethod['result']>;
+        onReject: Callback.Async<IsometricError>;
+    };
+}

package/dist/reactnative/bridge/core/BridgeMethodCall.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeMethodCall = void 0;
+// class
+class BridgeMethodCall {
+    constructor(args) {
+        // initialize instance variables
+        this.call = args.call;
+        this._onResolve = args.onResolve;
+        this._onReject = args.onReject;
+        this._status = 'pending';
+    }
+    get id() {
+        return this.call.id;
+    }
+    get method() {
+        return this.call.method;
+    }
+    get status() {
+        return this._status;
+    }
+    async resolve(result) {
+        console.debug('[BridgeMethodCall] resolving call with:', result);
+        // mark as resolved
+        this._status = 'resolved';
+        // resolve
+        await this._onResolve(result);
+    }
+    async reject(error) {
+        console.debug('[BridgeMethodCall] rejecting call with:', error);
+        // mark as resolved
+        this._status = 'rejected';
+        // resolve
+        await this._onReject(error);
+    }
+}
+exports.BridgeMethodCall = BridgeMethodCall;

package/dist/reactnative/bridge/core/BridgeMethods.d.ts

@@ -0,0 +1,35 @@
+import { StringKeyOf } from 'type-fest';
+import type { NavigationCommand } from '../../nav/domain';
+import { BridgeConnection } from './BridgeConnection';
+import { BridgeMethod } from './BridgeMethod';
+export type BridgeMethods<TMethod extends BridgeMethod = BridgeMethod> = {
+    [TMethodName in TMethod['name']]: BridgeMethod<TMethodName>;
+};
+export declare namespace BridgeMethods {
+    type Signatures<TMethods extends BridgeMethods = BridgeMethods> = {
+        [TMethodName in StringKeyOf<TMethods>]: BridgeMethod.Signature<TMethods[TMethodName]>;
+    };
+    type ForName<TMethods extends BridgeMethods = BridgeMethods, TMethodName extends StringKeyOf<TMethods> = StringKeyOf<TMethods>> = ({
+        [TKey in TMethodName]: TMethods[TKey];
+    })[TMethodName];
+    type Handler<TMethods extends BridgeMethods = BridgeMethods, TMethodName extends StringKeyOf<TMethods> = StringKeyOf<TMethods>> = (method: TMethodName, args: Args<TMethods, TMethodName>) => Promise<Result<TMethods, TMethodName>>;
+    type Args<TMethods extends BridgeMethods, TMethodName extends StringKeyOf<TMethods>> = TMethods[TMethodName]['args'];
+    type Result<TMethods extends BridgeMethods, TMethodName extends StringKeyOf<TMethods>> = TMethods[TMethodName]['result'];
+    type Native<TMethods extends BridgeMethods = BridgeMethods> = TMethods & {
+        'app.connect': {
+            name: 'app.connect';
+            args: BridgeConnection.ConnectArgs;
+            result: true;
+        };
+        'app.hideSplash': {
+            name: 'app.hideSplash';
+            args: {};
+            result: true;
+        };
+        'app.navigate': {
+            name: 'app.navigate';
+            args: NavigationCommand;
+            result: true;
+        };
+    };
+}

package/dist/reactnative/bridge/core/BridgeMethods.js

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

package/dist/reactnative/bridge/core/BridgeState.d.ts

@@ -0,0 +1,24 @@
+import type { Insets } from '@nascentdigital/funnel-core';
+import { Jsonify, JsonValue, StringKeyOf } from 'type-fest';
+import type { Identity } from '../../identity/domain';
+import type { Profile } from '../../profile/domain';
+export type BridgeState<TState extends BridgeState.Custom = BridgeState.Custom> = BridgeState.Core & TState;
+export declare namespace BridgeState {
+    type Core = {
+        identityData: Identity.Data | null;
+        profileData: Jsonify<Profile.Data> | null;
+        safeArea: Readonly<Insets>;
+    };
+    type Custom = Omit<Record<string, JsonValue>, keyof Core>;
+    type Key<TState extends Custom = Custom> = StringKeyOf<Core> | StringKeyOf<TState>;
+    type Value<TState extends Custom, TKey extends Key<TState>> = TKey extends StringKeyOf<Core> ? Core[TKey] : TState[TKey];
+    type ValueBroken<TState extends Custom, TKey extends Key<TState>> = ({
+        [K in keyof TState]: TState[K];
+    } & {
+        [K in keyof Core]: Core[K];
+    })[TKey];
+    type Change<TState extends Custom, TKey extends Key<TState> = Key<TState>> = {
+        key: TKey;
+        value: Value<TState, TKey>;
+    };
+}

package/dist/reactnative/bridge/core/BridgeState.js

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

package/dist/reactnative/bridge/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BridgeConnection';
+export * from './BridgeConstants';
+export * from './BridgeEvent';
+export * from './BridgeMethod';
+export * from './BridgeMethodCall';
+export * from './BridgeMethods';
+export * from './BridgeState';

package/dist/reactnative/bridge/core/index.js

@@ -0,0 +1,23 @@
+"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("./BridgeConnection"), exports);
+__exportStar(require("./BridgeConstants"), exports);
+__exportStar(require("./BridgeEvent"), exports);
+__exportStar(require("./BridgeMethod"), exports);
+__exportStar(require("./BridgeMethodCall"), exports);
+__exportStar(require("./BridgeMethods"), exports);
+__exportStar(require("./BridgeState"), exports);