@nascentdigital/funnel-apps 4.4.18

package/dist/reactnative/bridge/rn/BridgeProxy.d.ts

@@ -0,0 +1,35 @@
+import { WebView } from 'react-native-webview';
+import { BridgeEvent, BridgeMethodCall, BridgeMethods, BridgeState } from '../core';
+export declare class BridgeProxy<TState extends BridgeState.Custom = BridgeState.Custom, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native> {
+    private readonly _webViews$;
+    private readonly _webViews;
+    private readonly _stateChange$;
+    private _state;
+    private readonly _nativeCalls$;
+    constructor(args: BridgeProxy.ConstructorArgs<TState>);
+    get webViews$(): import("rxjs").Observable<readonly BridgeProxy.WebViewContext[]>;
+    get webViews(): ReadonlyArray<BridgeProxy.WebViewContext>;
+    private set webViews(value);
+    get stateChange$(): import("rxjs").Observable<BridgeState.Change<TState, BridgeState.Key<TState>>>;
+    get state(): BridgeState<TState>;
+    get nativeCalls$(): import("rxjs").Observable<readonly BridgeMethodCall<import("../core").BridgeMethod>[]>;
+    get nativeCalls(): readonly BridgeMethodCall<import("../core").BridgeMethod>[];
+    getWebViewPreLoadScript(id: string, customScript?: string): string;
+    getWebViewPostLoadScript(customScript?: string): string;
+    connect(id: string, webView: WebView): void;
+    disconnect(webView: WebView): void;
+    setState<TKey extends BridgeState.Key<TState>>(key: TKey, value: BridgeState.Value<TState, TKey>): boolean;
+    updateState<TKey extends BridgeState.Key<TState>>(key: TKey, value: BridgeState.Value<TState, TKey>): boolean;
+    propagate(event: BridgeEvent, webViewId?: string): void;
+    onEvent(event: BridgeEvent): void;
+}
+export declare namespace BridgeProxy {
+    type WebViewContext = {
+        webView: WebView;
+        id: string;
+        connected: boolean;
+    };
+    type ConstructorArgs<TState extends BridgeState.Custom = BridgeState.Custom> = {
+        initialState: TState & Partial<BridgeState.Core>;
+    };
+}

package/dist/reactnative/bridge/rn/BridgeProxy.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeProxy = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const core_1 = require("../core");
+// class
+class BridgeProxy {
+    constructor(args) {
+        // initialize instances
+        this._webViews$ = new rxjs_1.BehaviorSubject([]);
+        this._webViews = new Map();
+        this._stateChange$ = new rxjs_1.Subject();
+        this._state = Object.assign({ identityData: null, profileData: null, safeArea: funnel_core_1.Insets.none }, args.initialState);
+        this._nativeCalls$ = new rxjs_1.BehaviorSubject([]);
+    }
+    get webViews$() {
+        return this._webViews$.asObservable();
+    }
+    get webViews() {
+        return this._webViews$.getValue();
+    }
+    set webViews(webViews) {
+        this._webViews$.next(webViews);
+    }
+    get stateChange$() {
+        return this._stateChange$.asObservable();
+    }
+    get state() {
+        return this._state;
+    }
+    get nativeCalls$() {
+        return this._nativeCalls$.asObservable();
+    }
+    get nativeCalls() {
+        return this._nativeCalls$.getValue();
+    }
+    getWebViewPreLoadScript(id, customScript) {
+        return `
+      // bind logging
+      (function() {
+
+        // helper
+        function __nd_log(stdout, level, args) {
+          
+          // log in webview
+          stdout.apply(console, args);
+        
+          // log across bridge (if mounted)
+          var postMessage = window.ReactNativeWebView?.postMessage;
+          if (postMessage) {
+          
+            // try to post
+            try {
+              postMessage(JSON.stringify({
+                __type: "log", 
+                level, 
+                args: Array.from(args)
+              }));
+            }
+            
+            // handle errors
+            catch (e) {
+              postMessage(JSON.stringify({
+                __type: "log", 
+                level, 
+                args: [
+                  "Failed to post cyclical message payload:", 
+                  new Error().stack
+                ]
+              }));
+            }
+          }
+        }
+
+        // error      
+        const consoleError = console.error;
+        console.error = function() {
+          __nd_log(consoleError, "error", arguments);
+        };
+      
+        // warn
+        const consoleWarn = console.warn;
+        console.warn = function() {
+          __nd_log(consoleWarn, "warn", arguments);
+        };
+
+        // log
+        const consoleLog = console.log;
+        console.log = function() {
+          __nd_log(consoleLog, "info", arguments);
+        };
+
+        // info
+        const consoleInfo = console.info;
+        console.info = function() {
+          __nd_log(consoleInfo, "info", arguments);
+        };
+
+        // debug
+        const consoleDebug = console.debug;
+        console.debug = function() {
+          __nd_log(consoleDebug, "debug", arguments);
+        };
+      })();
+      
+      // setup globals
+      (function() {
+          window.${core_1.BridgeConstants.Window.initialState} = ${JSON.stringify(this.state)};
+          window.${core_1.BridgeConstants.Window.bridgeId} = "${id}";
+      })();
+      
+      // run custom script
+      (function() {
+        ${customScript}
+      })();
+      true;
+    `;
+    }
+    getWebViewPostLoadScript(customScript) {
+        return `
+      (function() {
+        ${customScript}
+      })();
+      true;
+    `;
+    }
+    connect(id, webView) {
+        // fail if already connected
+        const { _webViews } = this;
+        if (_webViews.has(webView)) {
+            console.warn('[BridgeProxy] ignoring redundant call to bind webView');
+            return;
+        }
+        // create context
+        const context = {
+            id,
+            webView,
+            connected: false
+        };
+        console.debug('[BridgeProxy] connecting webview: ', context.id);
+        // track context
+        _webViews.set(webView, context);
+        // TODO: set any additional connections
+    }
+    disconnect(webView) {
+        // get context
+        const { _webViews } = this;
+        const context = _webViews.get(webView);
+        if (!context) {
+            return;
+        }
+        console.log('[BridgeProxy] disconnecting webview: ', context.id);
+        // remove webview
+        _webViews.delete(webView);
+        // mark as disconnected
+        context.connected = false;
+        // update webview set
+        this.webViews = this.webViews.filter(({ id }) => id !== context.id);
+    }
+    setState(key, value) {
+        // skip if there's no local change
+        if (!this.updateState(key, value)) {
+            return false;
+        }
+        // update remote state (native and other browsers)
+        this.propagate({
+            __type: 'state.set',
+            key,
+            value
+        });
+        // indicate change
+        return true;
+    }
+    updateState(key, value) {
+        // skip if already set
+        const { _state, _stateChange$ } = this;
+        if (funnel_core_1.Value.equals(_state[key], value)) {
+            console.log('[BridgeProxy] ignoring redundant state change', { key, value });
+            return false;
+        }
+        console.log('[BridgeProxy] updating state', { key, value });
+        // update local state
+        this._state = Object.assign(Object.assign({}, _state), { [key]: value });
+        _stateChange$.next({ key, value });
+        // indicate change
+        return true;
+    }
+    propagate(event, webViewId) {
+        // create callback
+        const script = `
+      (function() {
+      
+        // send message if bridge is bound
+        if (window["${core_1.BridgeConstants.Window.bridge}"]) {
+          console.warn("...event coming through");
+          window["${core_1.BridgeConstants.Window.bridge}"].onEvent(${JSON.stringify(event)});
+        } 
+          
+        // or defer it
+        else {
+          console.warn("...event deferring");
+        }
+      })();
+      true;
+    `;
+        // propagate to all targets
+        this._webViews.forEach(({ id, webView }) => {
+            if (!webViewId || webViewId === id) {
+                console.debug('[BridgeProxy] propagating script', { id, event });
+                webView.injectJavaScript(script);
+            }
+            else {
+                console.debug('[BridgeProxy] skipping propagating for', id);
+            }
+        });
+    }
+    onEvent(event) {
+        // handle event
+        switch (event.__type) {
+            // logging
+            case 'log': {
+                // resolve args
+                const { level, args } = event;
+                const [format, ...formatArgs] = args !== null && args !== void 0 ? args : ['undefined'];
+                const consoleArgs = typeof format === 'string'
+                    ? [`(BridgeWebview) ${format}`, ...formatArgs]
+                    : ['(BridgeWebView)', format, formatArgs];
+                // log based on level
+                switch (level) {
+                    case 'debug':
+                        console.debug(...consoleArgs);
+                        break;
+                    case 'info':
+                        console.log(...consoleArgs);
+                        break;
+                    case 'warn':
+                        console.warn(...consoleArgs);
+                        break;
+                    case 'error':
+                        console.error(...consoleArgs);
+                        break;
+                }
+                break;
+            }
+            // state
+            case 'state.set':
+                this.updateState(event.key, event.value);
+                break;
+            // native call
+            case 'call.invocation': {
+                // intercept webview connections
+                const { webViewId } = event;
+                if (event.method === 'app.connect') {
+                    // find view (or fail)
+                    const context = Array.from(this._webViews.values())
+                        .find(context => context.id === webViewId);
+                    if (!context) {
+                        console.error(`[BridgeProxy] unable to resolve webview context for "${webViewId}"`);
+                        // response with error
+                        this.propagate({
+                            __type: 'call.error',
+                            webViewId,
+                            id: event.id,
+                            method: event.method,
+                            error: new funnel_core_1.NotFoundError('Unable to resolve webView').serialize()
+                        }, webViewId);
+                        // stop processing
+                        break;
+                    }
+                    // or bind
+                    else {
+                        // respond with success
+                        this.propagate({
+                            __type: 'call.result',
+                            webViewId,
+                            id: event.id,
+                            method: event.method,
+                            result: true
+                        }, webViewId);
+                        // track webview (add it)
+                        this.webViews = [...this.webViews, context];
+                        // stop processing
+                        break;
+                    }
+                }
+                // create new call
+                const { _nativeCalls$ } = this;
+                const nativeCall = new core_1.BridgeMethodCall({
+                    call: event,
+                    onResolve: async (result) => {
+                        // update calls by removing callback
+                        _nativeCalls$.next(_nativeCalls$.getValue().filter(({ id }) => id !== event.id));
+                        // propagate response
+                        this.propagate({
+                            __type: 'call.result',
+                            webViewId,
+                            id: event.id,
+                            method: event.method,
+                            result
+                        }, webViewId);
+                    },
+                    onReject: async (error) => {
+                        // update calls by removing callback
+                        _nativeCalls$.next(_nativeCalls$.getValue().filter(({ id }) => id !== event.id));
+                        // propagate response
+                        this.propagate({
+                            __type: 'call.error',
+                            webViewId,
+                            id: event.id,
+                            method: event.method,
+                            error: error.serialize()
+                        }, webViewId);
+                    }
+                });
+                // add call
+                this._nativeCalls$.next([
+                    ..._nativeCalls$.getValue(),
+                    nativeCall
+                ]);
+                // stop processing
+                break;
+            }
+            // fallback
+            default:
+                console.warn('[BridgeProxy] unhandled event:', event);
+                break;
+        }
+    }
+}
+exports.BridgeProxy = BridgeProxy;

package/dist/reactnative/bridge/rn/BridgeProxyContext.d.ts

@@ -0,0 +1,8 @@
+import { BridgeMethods, BridgeState } from '../core';
+import { BridgeProxy } from './BridgeProxy';
+export declare const BridgeProxyContext: import("react").Context<BridgeProxyContext.Data<any, any>>;
+export declare namespace BridgeProxyContext {
+    type Data<TState extends BridgeState.Custom = BridgeState.Custom, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native> = {
+        bridgeProxy?: BridgeProxy<TState, TNativeMethods>;
+    };
+}

package/dist/reactnative/bridge/rn/BridgeProxyContext.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeProxyContext = void 0;
+const react_1 = require("react");
+// context
+exports.BridgeProxyContext = (0, react_1.createContext)({});

package/dist/reactnative/bridge/rn/BridgeProxyProvider.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import { BridgeMethods, BridgeState } from '../core';
+export declare function BridgeProxyProvider<TState extends BridgeState.Custom = BridgeState, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native>({ initialState: initialStateRaw, children }: BridgeProxyProvider.Props<TState, TNativeMethods>): import("react").JSX.Element;
+export declare namespace BridgeProxyProvider {
+    type Props<TState extends BridgeState.Custom = BridgeState.Custom, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native> = PropsWithChildren & {
+        initialState: TState & Partial<BridgeState.Core>;
+    };
+}

package/dist/reactnative/bridge/rn/BridgeProxyProvider.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeProxyProvider = BridgeProxyProvider;
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const react_native_safe_area_context_1 = require("react-native-safe-area-context");
+const rn_1 = require("../../identity/rn");
+const BridgeProxy_1 = require("./BridgeProxy");
+const BridgeProxyContext_1 = require("./BridgeProxyContext");
+// component
+function BridgeProxyProvider({ initialState: initialStateRaw, children }) {
+    var _a;
+    // bind hooks + context
+    const safeArea = (0, react_native_safe_area_context_1.useSafeAreaInsets)();
+    const { identity } = (0, rn_1.useIdentity)();
+    const coreStateRef = (0, react_1.useRef)({});
+    coreStateRef.current = {
+        identityData: (_a = identity === null || identity === void 0 ? void 0 : identity.toData()) !== null && _a !== void 0 ? _a : null,
+        safeArea
+    };
+    const initialState = (0, hooks_1.useLatestValue)(initialStateRaw);
+    const bridgeProxy = (0, react_1.useMemo)(() => new BridgeProxy_1.BridgeProxy({
+        initialState: Object.assign(Object.assign({}, initialState), coreStateRef.current)
+    }), [initialState]);
+    const context = (0, react_1.useMemo)(() => ({ bridgeProxy }), [bridgeProxy]);
+    // sync safe area
+    (0, react_1.useEffect)(() => {
+        bridgeProxy.setState('safeArea', safeArea);
+    }, [bridgeProxy, safeArea]);
+    // sync identity
+    (0, react_1.useEffect)(() => {
+        var _a;
+        bridgeProxy.setState('identityData', (_a = identity === null || identity === void 0 ? void 0 : identity.toData()) !== null && _a !== void 0 ? _a : null);
+    }, [bridgeProxy, identity]);
+    // render
+    return (<BridgeProxyContext_1.BridgeProxyContext.Provider value={context}>
+      {children}
+    </BridgeProxyContext_1.BridgeProxyContext.Provider>);
+}

package/dist/reactnative/bridge/rn/BridgeWebview.d.ts

@@ -0,0 +1,7 @@
+export declare function BridgeWebview({ className, url }: BridgeWebview.Props): import("react").JSX.Element;
+export declare namespace BridgeWebview {
+    type Props = {
+        className?: string;
+        url: string;
+    };
+}

package/dist/reactnative/bridge/rn/BridgeWebview.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgeWebview = BridgeWebview;
+const classnames_1 = __importDefault(require("classnames"));
+const react_1 = require("react");
+const react_native_uuid_1 = __importDefault(require("react-native-uuid"));
+const react_native_webview_1 = require("react-native-webview");
+const core_1 = require("../core");
+const useBridgeProxy_1 = require("./useBridgeProxy");
+// component
+function BridgeWebview({ className, url }) {
+    // bind hooks
+    const [webView, setWebView] = (0, react_1.useState)(null);
+    const setWebViewRef = (0, react_1.useCallback)((webView) => {
+        setWebView(webView);
+    }, []);
+    const webViewId = (0, react_1.useMemo)(() => react_native_uuid_1.default.v4(), []);
+    const bridgeProxy = (0, useBridgeProxy_1.useBridgeProxy)();
+    // connect/disconnect webview from/to adapter
+    (0, react_1.useEffect)(() => {
+        // skip if adapter/webview are not ready
+        if (!webView) {
+            return;
+        }
+        // connect
+        bridgeProxy.connect(webViewId, webView);
+        // disconnect on unmount
+        return () => bridgeProxy.disconnect(webView);
+    }, [webViewId, webView, bridgeProxy]);
+    // helpers
+    const onMessage = ({ nativeEvent: { data } }) => {
+        // skip if message isn't an event
+        const event = core_1.BridgeEvent.parse(data);
+        if (!event) {
+            console.warn('[BridgeWebview] invalid browser message:', data);
+            return;
+        }
+        // forward to proxy
+        bridgeProxy.onEvent(event);
+    };
+    // render
+    return (<react_native_webview_1.WebView ref={setWebViewRef} className={(0, classnames_1.default)('flex-1', className)} injectedJavaScriptBeforeContentLoaded={bridgeProxy.getWebViewPreLoadScript(webViewId, `
+
+          // disable webview-isms
+          document.body.style.minWidth = 'calc(100dvw)';
+          document.body.style.touchAction = 'none'; 
+      `)} injectedJavaScript={bridgeProxy.getWebViewPostLoadScript()} onMessage={onMessage} source={{ uri: url }} showsVerticalScrollIndicator={false} showsHorizontalScrollIndicator={false} bounces={false}/>);
+}

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

@@ -0,0 +1,7 @@
+export * from '../core';
+export * from './BridgeProxy';
+export * from './BridgeProxyProvider';
+export * from './BridgeWebview';
+export * from './useBridgeProxy';
+export * from './useBridgeProxyCalls';
+export * from './useBridgeProxyState';

package/dist/reactnative/bridge/rn/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("../core"), exports);
+__exportStar(require("./BridgeProxy"), exports);
+__exportStar(require("./BridgeProxyProvider"), exports);
+__exportStar(require("./BridgeWebview"), exports);
+__exportStar(require("./useBridgeProxy"), exports);
+__exportStar(require("./useBridgeProxyCalls"), exports);
+__exportStar(require("./useBridgeProxyState"), exports);

package/dist/reactnative/bridge/rn/useBridgeProxy.d.ts

@@ -0,0 +1,3 @@
+import { BridgeProxy } from './BridgeProxy';
+export declare function usePossibleBridgeProxy(): BridgeProxy<any, any> | undefined;
+export declare function useBridgeProxy(): BridgeProxy<any, any>;

package/dist/reactnative/bridge/rn/useBridgeProxy.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePossibleBridgeProxy = usePossibleBridgeProxy;
+exports.useBridgeProxy = useBridgeProxy;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const BridgeProxyContext_1 = require("./BridgeProxyContext");
+// hook
+function usePossibleBridgeProxy() {
+    // bind context
+    const { bridgeProxy } = (0, react_1.useContext)(BridgeProxyContext_1.BridgeProxyContext);
+    const touch = (0, hooks_1.useTouch)();
+    // sync changes
+    (0, react_1.useEffect)(() => {
+        // skip if there's no proxy
+        if (!bridgeProxy) {
+            return;
+        }
+        // refresh when state changes
+        const subscriptions = [
+            bridgeProxy.stateChange$.subscribe(touch)
+        ];
+        // unsubscribe on unmount
+        return () => subscriptions.forEach(subscription => subscription.unsubscribe());
+    }, [bridgeProxy, touch]);
+    // return proxy (might be undefined)
+    return bridgeProxy;
+}
+function useBridgeProxy() {
+    // resolve proxy (or throw)
+    const bridgeProxy = usePossibleBridgeProxy();
+    if (!bridgeProxy) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access BridgeProxy outside of BridgeProxyProvider');
+    }
+    // forward result
+    return bridgeProxy;
+}

package/dist/reactnative/bridge/rn/useBridgeProxyCalls.d.ts

@@ -0,0 +1,3 @@
+import { StringKeyOf } from 'type-fest';
+import { BridgeMethodCall, BridgeMethods } from '../core';
+export declare function useBridgeProxyCalls<TMethodName extends StringKeyOf<TNativeMethods>, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native>(...methodNamesRaw: ReadonlyArray<TMethodName>): ReadonlyArray<BridgeMethodCall<TNativeMethods[TMethodName]>>;

package/dist/reactnative/bridge/rn/useBridgeProxyCalls.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBridgeProxyCalls = useBridgeProxyCalls;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const BridgeProxyContext_1 = require("./BridgeProxyContext");
+// hook
+function useBridgeProxyCalls(...methodNamesRaw) {
+    // bind context
+    const methodNames = (0, hooks_1.useLatestValue)(methodNamesRaw);
+    const { bridgeProxy } = (0, react_1.useContext)(BridgeProxyContext_1.BridgeProxyContext);
+    const [calls, setCalls] = (0, react_1.useState)([]);
+    // monitor calls
+    (0, react_1.useEffect)(() => {
+        // skip if there's no bridge
+        if (!bridgeProxy) {
+            return;
+        }
+        // update if value of key changes
+        const subscription = bridgeProxy.nativeCalls$
+            .subscribe(calls => setCalls(calls.filter(call => methodNames.length === 0 || methodNames.includes(call.call.method))));
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [bridgeProxy, methodNames]);
+    // throw if bridge isn't set
+    if (!bridgeProxy) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access bridge outside of BridgeProxyProvider');
+    }
+    // return state
+    return calls;
+}

package/dist/reactnative/bridge/rn/useBridgeProxyState.d.ts

@@ -0,0 +1,2 @@
+import { BridgeState } from '../core';
+export declare function useBridgeProxyState<TKey extends BridgeState.Key<TState>, TState extends BridgeState.Custom = BridgeState.Custom>(...keysRaw: ReadonlyArray<TKey>): Readonly<Pick<BridgeState<TState>, TKey>>;

package/dist/reactnative/bridge/rn/useBridgeProxyState.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBridgeProxyState = useBridgeProxyState;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const rxjs_1 = require("rxjs");
+const BridgeProxyContext_1 = require("./BridgeProxyContext");
+// hook
+function useBridgeProxyState(...keysRaw) {
+    // bind context
+    const keys = (0, hooks_1.useLatestValue)(keysRaw);
+    const { bridgeProxy } = (0, react_1.useContext)(BridgeProxyContext_1.BridgeProxyContext);
+    const [state, setState] = (0, react_1.useState)(() => {
+        var _a;
+        return Object.entries((_a = bridgeProxy === null || bridgeProxy === void 0 ? void 0 : bridgeProxy.state) !== null && _a !== void 0 ? _a : {})
+            .reduce((state, [keyRaw, value]) => {
+            // bind value (if mapped)
+            const key = keyRaw;
+            if (keys.includes(key)) {
+                state[key] = value;
+            }
+            // keep reducing
+            return state;
+        }, {});
+    });
+    // monitor keys
+    (0, react_1.useEffect)(() => {
+        // skip if there's no bridge
+        if (!bridgeProxy) {
+            return;
+        }
+        // update if value of key changes
+        const subscription = bridgeProxy.stateChange$
+            .pipe((0, rxjs_1.filter)(change => keys.length === 0 || keys.includes(change.key)))
+            .subscribe(change => setState(state => (Object.assign(Object.assign({}, state), { [change.key]: change.value }))));
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [bridgeProxy, keys]);
+    // throw if bridge isn't set
+    if (!bridgeProxy) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access bridge outside of BridgeProxyProvider');
+    }
+    // return state
+    return state;
+}