@nascentdigital/funnel-apps 4.4.18

package/dist/react/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/react/bridge/core/BridgeMethod.js

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

package/dist/react/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/react/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/react/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/react/bridge/core/BridgeMethods.js

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

package/dist/react/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/react/bridge/core/BridgeState.js

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

package/dist/react/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/react/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);

package/dist/react/bridge/web/Bridge.d.ts

@@ -0,0 +1,32 @@
+import './BridgeGlobals';
+import { JsonValue, StringKeyOf } from 'type-fest';
+import { BridgeConnection, BridgeMethods, BridgeState } from '../core';
+export declare class Bridge<TState extends BridgeState.Custom = BridgeState.Custom, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native> {
+    private readonly _webViewId?;
+    private readonly _connection$;
+    private readonly _stateChange$;
+    private _state;
+    private readonly _deferredCalls;
+    private readonly _onNativeMethod;
+    constructor(args: Bridge.ConstructorArgs<TState, TNativeMethods>);
+    get isNative(): boolean;
+    get stateChange$(): import("rxjs").Observable<BridgeState.Change<TState, BridgeState.Key<TState>>>;
+    get connection$(): import("rxjs").Observable<BridgeConnection>;
+    get connection(): BridgeConnection;
+    private set connection(value);
+    get connected(): boolean;
+    get state(): BridgeState<TState>;
+    connect(): void;
+    disconnect(): 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;
+    call<TMethodName extends StringKeyOf<TNativeMethods>>(method: TMethodName, args?: BridgeMethods.Args<TNativeMethods, TMethodName>): Promise<BridgeMethods.Result<TNativeMethods, TMethodName>>;
+    onEvent(event: JsonValue): void;
+    private raiseEvent;
+}
+export declare namespace Bridge {
+    type ConstructorArgs<TState extends BridgeState.Custom = BridgeState.Custom, TNativeMethods extends BridgeMethods.Native = BridgeMethods.Native> = {
+        initialState: TState;
+        onNativeMethod: BridgeMethods.Handler<TNativeMethods>;
+    };
+}

package/dist/react/bridge/web/Bridge.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bridge = void 0;
+require("./BridgeGlobals");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const core_1 = require("../core");
+// class
+class Bridge {
+    constructor(args) {
+        // initialize instances
+        this._webViewId = window[core_1.BridgeConstants.Window.bridgeId];
+        this._connection$ = new rxjs_1.BehaviorSubject('uninitialized');
+        this._stateChange$ = new rxjs_1.Subject();
+        this._state = Object.assign({ identityData: null, profileData: null, safeArea: funnel_core_1.Insets.none }, args.initialState);
+        this._deferredCalls = new Map();
+        this._onNativeMethod = args.onNativeMethod;
+    }
+    get isNative() {
+        return !!this._webViewId;
+    }
+    get stateChange$() {
+        return this._stateChange$.asObservable();
+    }
+    get connection$() {
+        return this._connection$.asObservable();
+    }
+    get connection() {
+        return this._connection$.getValue();
+    }
+    set connection(connection) {
+        this._connection$.next(connection);
+    }
+    get connected() {
+        return this.connection === 'ready';
+    }
+    get state() {
+        return this._state;
+    }
+    connect() {
+        console.debug('[Bridge] connecting bridge');
+        // throw if there's no webview
+        const { _webViewId } = this;
+        if (!_webViewId) {
+            throw new funnel_core_1.InvalidOperationError('Cannot connect() outside of RN application');
+        }
+        // update connection state
+        this.connection = 'initializing';
+        // bind bridge
+        window[core_1.BridgeConstants.Window.bridge] = this;
+        // sync state if it exists
+        const initialState = window[core_1.BridgeConstants.Window.initialState];
+        if (initialState) {
+            // TODO: update each different value
+            Object.entries(initialState).forEach(([key, value]) => {
+                this.updateState(key, value);
+            });
+        }
+        console.debug('[Bridge] registering with remote proxy');
+        // send connect message to proxy
+        this.call('app.connect', { webViewId: _webViewId })
+            .then(() => {
+            console.debug('[Bridge] connecting bridge');
+            this.connection = 'ready';
+        })
+            .catch(e => {
+            console.error('[Bridge] bridge connection failed', e);
+            this.connection = 'error';
+        });
+    }
+    disconnect() {
+        console.log('[Bridge] disconnecting bridge');
+        // remove webview
+        // TODO: clear out any additional connections
+        // mark disconnected
+        this.connection = 'uninitialized';
+    }
+    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.raiseEvent({
+            __type: 'state.set',
+            key,
+            value
+        });
+        // indicate change
+        return true;
+    }
+    updateState(key, value) {
+        // skip if unchanged
+        const { _state, _stateChange$ } = this;
+        if (funnel_core_1.Value.equals(_state[key], value)) {
+            return false;
+        }
+        // update local state
+        this._state = Object.assign(Object.assign({}, _state), { [key]: value });
+        _stateChange$.next({ key, value });
+        // indicate change
+        return true;
+    }
+    async call(method, args = {}) {
+        // throw if not native
+        const { _webViewId, _deferredCalls } = this;
+        if (!_webViewId) {
+            console.error('[Bridge] cannot find valid webview id');
+            throw new funnel_core_1.InvalidOperationError('Cannot call native methods on unbound proxy');
+        }
+        // wait until connected
+        // await firstValueFrom(this.connected$.pipe(filter(value => value)))
+        // create new deferral
+        const id = funnel_core_1.Value.uuid();
+        const deferral = new funnel_core_1.Deferral();
+        _deferredCalls.set(id, deferral);
+        // try to make the call
+        try {
+            console.debug(`[Bridge] invoking "${method}" with args`, args);
+            // send method call via event
+            this.raiseEvent({
+                __type: 'call.invocation',
+                webViewId: _webViewId,
+                id,
+                method,
+                args
+            });
+            // wait on the deferral (throw if it's an error)
+            const resultOrError = await deferral.promise;
+            if (resultOrError.__type === 'call.error') {
+                console.debug(`[Bridge] throwing completion for "${method}"`, resultOrError.error);
+                throw funnel_core_1.IsometricErrorUtils.deserializeError(resultOrError.error);
+            }
+            // or return result
+            else {
+                console.debug(`[Bridge] returning completion for "${method}"`, resultOrError.result);
+                return resultOrError.result;
+            }
+        }
+        // forward any thrown error
+        catch (e) {
+            console.error('[Bridge/call] call failed', e);
+            throw funnel_core_1.IsometricErrorUtils.coerceError(e);
+        }
+    }
+    onEvent(event) {
+        // parse event (or skip if invalid)
+        if (!core_1.BridgeEvent.filter(event)) {
+            console.error('[Bridge] invalid bridge event', event);
+            return;
+        }
+        console.log('[Bridge] handling onEvent:', event);
+        // process event
+        switch (event.__type) {
+            // capture state changes
+            case 'state.set':
+                this.setState(event.key, event.value);
+                break;
+            // call: resolve/throw
+            case 'call.result':
+            case 'call.error': {
+                // handle if originating from this bridge
+                const deferral = this._deferredCalls.get(event.id);
+                if (deferral) {
+                    // clear deferral
+                    this._deferredCalls.delete(event.id);
+                    // resolve call
+                    deferral.resolve(event);
+                }
+                // stop processing
+                break;
+            }
+        }
+    }
+    raiseEvent(event) {
+        var _a;
+        if ((_a = window.ReactNativeWebView) === null || _a === void 0 ? void 0 : _a.postMessage) {
+            console.debug('[Bridge] raising event', event);
+            window.ReactNativeWebView.postMessage(JSON.stringify(event));
+        }
+    }
+}
+exports.Bridge = Bridge;

package/dist/react/bridge/web/BridgeContext.d.ts

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

package/dist/react/bridge/web/BridgeContext.js

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

package/dist/react/bridge/web/BridgeGlobals.d.ts

@@ -0,0 +1,12 @@
+import { BridgeConstants, BridgeState } from '../core';
+import type { Bridge } from './Bridge';
+declare global {
+    interface Window {
+        [BridgeConstants.Window.initialState]?: BridgeState;
+        [BridgeConstants.Window.bridgeId]?: string;
+        [BridgeConstants.Window.bridge]?: Bridge<any, any>;
+        ReactNativeWebView: {
+            postMessage?: (data: string) => void;
+        };
+    }
+}

package/dist/react/bridge/web/BridgeGlobals.js

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

package/dist/react/bridge/web/BridgeProvider.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+import { BridgeState } from '../core';
+import { Bridge } from './Bridge';
+export declare function BridgeProvider<TState extends BridgeState.Custom = BridgeState.Custom>({ children, ...bridgePropsRaw }: BridgeProvider.Props<TState>): import("react/jsx-runtime").JSX.Element;
+export declare namespace BridgeProvider {
+    type Props<TState extends BridgeState.Custom = BridgeState.Custom> = PropsWithChildren & Bridge.ConstructorArgs<TState>;
+}

package/dist/react/bridge/web/BridgeProvider.js

@@ -0,0 +1,36 @@
+"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.BridgeProvider = BridgeProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const Bridge_1 = require("./Bridge");
+const BridgeContext_1 = require("./BridgeContext");
+// component
+function BridgeProvider(_a) {
+    var { children } = _a, bridgePropsRaw = __rest(_a, ["children"]);
+    // bind context
+    const bridgeProps = (0, hooks_1.useLatestValue)(bridgePropsRaw);
+    const bridge = (0, react_1.useMemo)(() => new Bridge_1.Bridge(bridgeProps), [bridgeProps]);
+    const context = (0, react_1.useMemo)(() => ({ bridge }), [bridge]);
+    // bind bridge
+    (0, react_1.useEffect)(() => {
+        // connect bridge
+        bridge.connect();
+        // disconnect on unmount
+        return () => bridge.disconnect();
+    }, [bridge]);
+    // render
+    return ((0, jsx_runtime_1.jsx)(BridgeContext_1.BridgeContext.Provider, { value: context, children: children }));
+}

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

@@ -0,0 +1,6 @@
+export * from '../core';
+export * from './Bridge';
+export * from './BridgeProvider';
+export * from './useBridge';
+export * from './useBridgeState';
+export * from './useSafeArea';

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

@@ -0,0 +1,22 @@
+"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("./Bridge"), exports);
+__exportStar(require("./BridgeProvider"), exports);
+__exportStar(require("./useBridge"), exports);
+__exportStar(require("./useBridgeState"), exports);
+__exportStar(require("./useSafeArea"), exports);

package/dist/react/bridge/web/useBridge.d.ts

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

package/dist/react/bridge/web/useBridge.js

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

package/dist/react/bridge/web/useBridgeState.d.ts

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

package/dist/react/bridge/web/useBridgeState.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBridgeState = useBridgeState;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const BridgeContext_1 = require("./BridgeContext");
+// hook
+function useBridgeState(...keysRaw) {
+    // bind context
+    const keys = (0, hooks_1.useLatestValue)(keysRaw);
+    const { bridge } = (0, react_1.useContext)(BridgeContext_1.BridgeContext);
+    const [state, setState] = (0, react_1.useState)(() => {
+        var _a;
+        return Object.entries((_a = bridge === null || bridge === void 0 ? void 0 : bridge.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 (!bridge) {
+            return;
+        }
+        // update if value of key changes
+        const subscription = bridge.stateChange$.subscribe(change => setState(state => (Object.assign(Object.assign({}, state), { [change.key]: change.value }))));
+        // unsubscribe on unmount
+        return () => subscription.unsubscribe();
+    }, [bridge, keys]);
+    // throw if bridge isn't set
+    if (!bridge) {
+        throw new funnel_core_1.InvalidOperationError('Cannot access bridge outside of BridgeProvider');
+    }
+    // return state
+    return state;
+}

package/dist/react/bridge/web/useSafeArea.d.ts

@@ -0,0 +1 @@
+export declare function useSafeArea(): Readonly<import("@nascentdigital/funnel-core").Insets>;

package/dist/react/bridge/web/useSafeArea.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSafeArea = useSafeArea;
+const useBridgeState_1 = require("./useBridgeState");
+// hook
+function useSafeArea() {
+    // bind hooks
+    const { safeArea } = (0, useBridgeState_1.useBridgeState)('safeArea');
+    // return safe area
+    return safeArea;
+}

package/dist/react/content/core/AppContentClient.d.ts

@@ -0,0 +1,14 @@
+import { Pagination } from '@nascentdigital/funnel-cms';
+import { Schema } from '@nascentdigital/funnel-core';
+import type { ContentAppRequest } from '../domain';
+export declare class AppContentClient {
+    private readonly _apiToken?;
+    constructor(args: AppContentClient.ConstructorArgs);
+    getCollection<T extends Schema.Collection = Schema.Collection>(args: ContentAppRequest.GetCollection.Args): Promise<Schema.Collection.LinkedData.FromRef<T> | undefined>;
+    findCollection<T extends Schema.Collection = Schema.Collection>(args: ContentAppRequest.FindCollection.Args): Promise<Pagination.Paginated<Schema.Collection.LinkedData.FromRef<T>>>;
+}
+export declare namespace AppContentClient {
+    type ConstructorArgs = {
+        apiToken?: string;
+    };
+}