@nascentdigital/funnel-apps 4.4.18

package/dist/react/app/domain/AppService.d.ts

@@ -0,0 +1,19 @@
+import { JsonValue } from 'type-fest';
+import type { Identity } from '../../identity/domain';
+export interface AppService<TRequest extends AppService.Request = AppService.Request> {
+    readonly id: TRequest['id'];
+    readonly name: string;
+    readonly authenticated: boolean;
+    execute(request: TRequest, identity?: Identity): Promise<JsonValue>;
+}
+export declare namespace AppService {
+    type Request<TId extends string = string, TMethod extends string = string, TData extends JsonValue = JsonValue> = {
+        apiToken?: string;
+        id: TId;
+        method: TMethod;
+        data: TData;
+    };
+    namespace Request {
+        function filter<TId extends string = string, TMethod extends string = string, TData extends JsonValue = JsonValue>(request: any): request is Request<TId, TMethod, TData>;
+    }
+}

package/dist/react/app/domain/AppService.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppService = void 0;
+// extension
+var AppService;
+(function (AppService) {
+    let Request;
+    (function (Request) {
+        // guard
+        function filter(request) {
+            return !!request
+                && typeof request === 'object'
+                && !Array.isArray(request)
+                && 'id' in request && typeof request.id === 'string'
+                && 'method' in request && typeof request.method === 'string';
+        }
+        Request.filter = filter;
+    })(Request = AppService.Request || (AppService.Request = {}));
+})(AppService || (exports.AppService = AppService = {}));

package/dist/react/app/domain/AppServiceClient.d.ts

@@ -0,0 +1,7 @@
+import type { AppService } from './AppService';
+export declare namespace AppServiceClient {
+    type PostArgs<TRequest extends AppService.Request> = TRequest & {
+        baseUrl?: string;
+    };
+    function post<TRequest extends AppService.Request>({ baseUrl, apiToken, id, method, data }: PostArgs<TRequest>): Promise<any>;
+}

package/dist/react/app/domain/AppServiceClient.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServiceClient = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// namespace
+var AppServiceClient;
+(function (AppServiceClient) {
+    async function post({ baseUrl = '', apiToken, id, method, data }) {
+        var _a;
+        // try to send request
+        try {
+            // build headers
+            const headers = {};
+            if (apiToken) {
+                headers['Authorization'] = `Bearer ${apiToken}`;
+            }
+            // resolve api url
+            let url = '/api/app';
+            if (baseUrl) {
+                url = new URL(url, baseUrl).href;
+            }
+            console.log('[AppServiceCall/post] sending', { apiToken, id, method, data, url });
+            // send request
+            const response = await fetch(url, {
+                method: 'POST',
+                credentials: 'same-origin',
+                headers,
+                body: JSON.stringify({
+                    id,
+                    method,
+                    data
+                }),
+            });
+            console.log('[AppServiceCall/post] sent', { id, method });
+            // throw if response failed
+            await funnel_core_1.IsometricErrorUtils.checkResponse(response);
+            // parse response
+            const json = await response.json();
+            // return response (assume it's a result)
+            return funnel_core_1.Value.typeOf(json) === 'object'
+                ? (_a = json.data) !== null && _a !== void 0 ? _a : undefined
+                : undefined;
+        }
+        // restore errors
+        catch (e) {
+            // forward iso-errors
+            if (e instanceof funnel_core_1.IsometricError) {
+                throw e;
+            }
+            // or assume it's offline
+            else {
+                throw new funnel_core_1.OfflineError();
+            }
+        }
+    }
+    AppServiceClient.post = post;
+})(AppServiceClient || (exports.AppServiceClient = AppServiceClient = {}));

package/dist/react/app/domain/AppState.d.ts

@@ -0,0 +1 @@
+export type AppState = 'initializing' | 'unauthenticated' | 'authenticated' | 'pausing' | 'paused' | 'resuming' | 'error.identity' | 'error.profile';

package/dist/react/app/domain/AppState.js

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

package/dist/react/app/domain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AppService';
+export * from './AppServiceClient';
+export * from './AppState';

package/dist/react/app/domain/index.js

@@ -0,0 +1,19 @@
+"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("./AppService"), exports);
+__exportStar(require("./AppServiceClient"), exports);
+__exportStar(require("./AppState"), exports);

package/dist/react/app/server/AbstractAppService.d.ts

@@ -0,0 +1,17 @@
+import { JsonValue } from 'type-fest';
+import { Identity } from '../../identity/domain';
+import type { AppService } from '../domain';
+export declare abstract class AbstractAppService<TRequest extends AppService.Request = AppService.Request> implements AppService<TRequest> {
+    readonly id: TRequest['id'];
+    readonly name: string;
+    protected constructor(args: AbstractAppService.ConstructorArgs<TRequest>);
+    get authenticated(): boolean;
+    execute(request: TRequest, identity?: Identity): Promise<JsonValue>;
+    abstract onExecute(request: TRequest, identity?: Identity): Promise<JsonValue>;
+}
+export declare namespace AbstractAppService {
+    type ConstructorArgs<TRequest extends AppService.Request> = {
+        id: TRequest['id'];
+        name: string;
+    };
+}

package/dist/react/app/server/AbstractAppService.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractAppService = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+// class
+class AbstractAppService {
+    constructor(args) {
+        // initialize instance variables
+        this.id = args.id;
+        this.name = args.name;
+    }
+    get authenticated() {
+        return true;
+    }
+    async execute(request, identity) {
+        // authenticate (if required)
+        if (this.authenticated && !identity) {
+            throw new funnel_core_1.NotAuthenticatedError();
+        }
+        // or forward
+        return this.onExecute(request, identity);
+    }
+}
+exports.AbstractAppService = AbstractAppService;

package/dist/react/app/server/AppServices.d.ts

@@ -0,0 +1,11 @@
+import 'server-only';
+import type { NextRequest, NextResponse as NextResponseType } from 'next/server';
+import { AbstractAppService } from './AbstractAppService';
+export declare namespace AppServices {
+    function bind(...services: ReadonlyArray<AbstractAppService>): void;
+    function process(nextRequest: NextRequest, NextResponse: typeof NextResponseType): Promise<NextResponseType<{
+        data: import("type-fest").JsonValue;
+    }> | NextResponseType<{
+        error: import("@nascentdigital/funnel-core").SerializedIsometricError;
+    }>>;
+}

package/dist/react/app/server/AppServices.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppServices = void 0;
+require("server-only");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const ContentAppService_1 = require("../../content/server/ContentAppService");
+const server_1 = require("../../identity/server");
+const IdentityAppService_1 = require("../../identity/server/IdentityAppService");
+const IdentityService_1 = require("../../identity/server/IdentityService");
+const SpecService_1 = require("../../nav/server/SpecService");
+const ProfileAppService_1 = require("../../profile/server/ProfileAppService");
+const ProfileServices_1 = require("../../profile/server/ProfileServices");
+const domain_1 = require("../domain");
+// namespace
+var AppServices;
+(function (AppServices) {
+    const _services = [];
+    function bind(...services) {
+        // throw if already bound
+        if (_services.length > 0) {
+            throw new funnel_core_1.InvalidOperationError(`AppServices already bound`);
+        }
+        // register service
+        _services.push(...services);
+        // add spec service
+        const specService = new SpecService_1.SpecService();
+        if (_services.some(service => service.id === specService.id)) {
+            throw new funnel_core_1.IllegalStateError(`${specService.name} is already registered`);
+        }
+        _services.push(specService);
+        // add identity service
+        const identityService = new IdentityAppService_1.IdentityAppService(IdentityService_1.IdentityService.get());
+        if (_services.some(service => service.id === identityService.id)) {
+            throw new funnel_core_1.IllegalStateError(`${identityService.name} is already registered`);
+        }
+        _services.push(identityService);
+        // add profile service
+        const profileService = new ProfileAppService_1.ProfileAppService(ProfileServices_1.ProfileServices.get().getUserService());
+        if (_services.some(service => service.id === profileService.id)) {
+            throw new funnel_core_1.IllegalStateError(`${profileService.name} is already registered`);
+        }
+        _services.push(profileService);
+        // add content service
+        const contentService = new ContentAppService_1.ContentAppService();
+        if (_services.some(service => service.id === contentService.id)) {
+            throw new funnel_core_1.IllegalStateError(`${contentService.name} is already registered`);
+        }
+        _services.push(contentService);
+    }
+    AppServices.bind = bind;
+    async function process(nextRequest, NextResponse) {
+        // process request
+        try {
+            // extract payload
+            const request = await nextRequest.json();
+            if (!domain_1.AppService.Request.filter(request)) {
+                throw new funnel_core_1.InvalidOperationError();
+            }
+            // find service (or throw)
+            const service = _services.find(({ id }) => request.id === id);
+            if (!service) {
+                throw new funnel_core_1.NotFoundError(`Unrecognized AppService "${request.id}"`);
+            }
+            // resolve identity (if required)
+            const identity = await IdentityService_1.IdentityService.get().current(nextRequest);
+            if (service.authenticated && !(identity instanceof server_1.AuthenticatedIdentity)) {
+                throw new funnel_core_1.NotAuthenticatedError();
+            }
+            // handle request with service
+            const result = await service.execute(request, identity);
+            // return result
+            return NextResponse.json({ data: result }, { status: 200 });
+        }
+        // or return error on failure
+        catch (e) {
+            console.error('[AppServices] caught error processing request', e);
+            // handle API error
+            if (e instanceof funnel_core_1.ApiError) {
+                return NextResponse.json({ error: e.serialize() }, { status: e.status });
+            }
+            // or handle other isometric errors
+            else {
+                return NextResponse.json({
+                    error: e instanceof funnel_core_1.IsometricError
+                        ? e.serialize()
+                        : new funnel_core_1.ServerError().serialize()
+                }, { status: 500 });
+            }
+        }
+    }
+    AppServices.process = process;
+})(AppServices || (exports.AppServices = AppServices = {}));

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

@@ -0,0 +1,4 @@
+import 'server-only';
+export * from '../domain';
+export * from './AppServices';
+export * from './AbstractAppService';

package/dist/react/app/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("../domain"), exports);
+__exportStar(require("./AppServices"), exports);
+__exportStar(require("./AbstractAppService"), exports);

package/dist/react/app/web/App.d.ts

@@ -0,0 +1,38 @@
+import { EventBus, IsometricError } from '@nascentdigital/funnel-core';
+import { AuthenticatedIdentity, Identity } from '../../identity/web';
+import { Profile } from '../../profile/web';
+import { AppState } from '../domain';
+export declare class App {
+    private readonly _eventBus;
+    private readonly _state$;
+    private _identity?;
+    private _profile?;
+    private _profileError?;
+    private _identityError?;
+    constructor(_eventBus: EventBus);
+    get event$(): import("rxjs").Observable<App.Event>;
+    get state$(): import("rxjs").Observable<AppState>;
+    get state(): AppState;
+    set state(state: AppState);
+    get ready(): boolean;
+    get identity(): Identity | undefined;
+    get authenticatedIdentity(): AuthenticatedIdentity | undefined;
+    get identityError(): IsometricError | undefined;
+    get profile(): Profile<Profile.Stores> | undefined;
+    get profileError(): IsometricError | undefined;
+    onIdentityChanged(newIdentity: Identity): void;
+    onIdentityError(error: IsometricError): void;
+    onProfileChanged(newProfile: Profile): void;
+    onProfileError(error: IsometricError): void;
+    private raiseEvent;
+}
+export declare namespace App {
+    interface Event extends EventBus.Event<'App', Event.Type> {
+        app: App;
+    }
+    namespace Event {
+        type Type = 'changed';
+        function filter(event: EventBus.Event): event is Event;
+        function create(event: EventBus.Args<Event>): Event;
+    }
+}

package/dist/react/app/web/App.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const rxjs_1 = require("rxjs");
+const web_1 = require("../../identity/web");
+// class
+class App {
+    constructor(_eventBus) {
+        this._eventBus = _eventBus;
+        // initialize instance variables
+        this._state$ = new rxjs_1.BehaviorSubject('initializing');
+        console.debug('[App/new] created new App');
+    }
+    get event$() {
+        return this._eventBus.events$.pipe((0, rxjs_1.filter)(App.Event.filter));
+    }
+    get state$() {
+        return this._state$.asObservable();
+    }
+    get state() {
+        return this._state$.getValue();
+    }
+    set state(state) {
+        console.debug(`[App/state] updating state from "${this.state}" to "${state}"`);
+        this._state$.next(state);
+        this.raiseEvent('changed');
+    }
+    get ready() {
+        return this.state === 'authenticated';
+    }
+    get identity() {
+        return this._identity;
+    }
+    get authenticatedIdentity() {
+        const { _identity } = this;
+        return _identity instanceof web_1.AuthenticatedIdentity
+            ? _identity
+            : undefined;
+    }
+    get identityError() {
+        return this._identityError;
+    }
+    get profile() {
+        return this._profile;
+    }
+    get profileError() {
+        return this._profileError;
+    }
+    onIdentityChanged(newIdentity) {
+        // capture identity
+        const previousIdentity = this._identity;
+        this._identity = newIdentity;
+        console.debug('[App/onIdentityChanged] updating identity', { from: previousIdentity, to: newIdentity });
+        // FIXME: think through the workflow
+        // update based on current state
+        switch (this.state) {
+            case 'initializing':
+                if (!newIdentity.authenticated) {
+                    this.state = 'unauthenticated';
+                }
+                break;
+            default:
+                console.debug(`[App/onIdentityChanged] deferring state update while ${this.state}`);
+                break;
+        }
+    }
+    onIdentityError(error) {
+        // capture error
+        this._identityError = error;
+        console.error('[App] identity error', error);
+        // update state
+        this.state = 'error.identity';
+    }
+    onProfileChanged(newProfile) {
+        // capture profile
+        const previousProfile = this._profile;
+        this._profile = newProfile;
+        console.debug('[App/onProfileChanged] updating profile', { from: previousProfile, to: newProfile });
+        switch (this.state) {
+            case 'initializing':
+            case 'unauthenticated':
+                this.state = 'authenticated';
+                break;
+            default:
+                console.debug(`[App/onProfileChanged] deferring state update while ${this.state}`);
+                break;
+        }
+    }
+    onProfileError(error) {
+        // capture error
+        this._profileError = error;
+        console.error('[App] profile error', error);
+        // update state
+        this.state = 'error.profile';
+    }
+    raiseEvent(type) {
+        this._eventBus.publish(App.Event.create({ type, app: this }));
+    }
+}
+exports.App = App;
+// extension
+(function (App) {
+    let Event;
+    (function (Event) {
+        // methods
+        function filter(event) {
+            return event.domain === 'App';
+        }
+        Event.filter = filter;
+        function create(event) {
+            return funnel_core_1.EventBus.createEvent(Object.assign({ domain: 'App' }, event));
+        }
+        Event.create = create;
+    })(Event = App.Event || (App.Event = {}));
+})(App || (exports.App = App = {}));

package/dist/react/app/web/AppContainer.d.ts

@@ -0,0 +1,16 @@
+import { EventBus, IsometricError } from '@nascentdigital/funnel-core';
+import { FunctionComponent, PropsWithChildren } from 'react';
+export declare function AppContainer({ eventBus, SplashScreen, LoginScreen, ErrorScreen, children }: AppContainer.Props): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppContainer {
+    type ScreenProps = {
+        SplashScreen: FunctionComponent<PropsWithChildren>;
+        LoginScreen: FunctionComponent<PropsWithChildren>;
+        ErrorScreen: FunctionComponent<PropsWithChildren & {
+            identityError?: IsometricError;
+            profileError?: IsometricError;
+        }>;
+    };
+    type Props = PropsWithChildren & ScreenProps & {
+        eventBus: EventBus;
+    };
+}

package/dist/react/app/web/AppContainer.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppContainer = AppContainer;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const classnames_1 = __importDefault(require("classnames"));
+const react_1 = require("motion/react");
+const head_1 = __importDefault(require("next/head"));
+const router_1 = require("next/router");
+const react_2 = require("react");
+const rxjs_1 = require("rxjs");
+const web_1 = require("../../bridge/web");
+const web_2 = require("../../identity/web");
+const web_3 = require("../../profile/web");
+const App_1 = require("./App");
+const AppContext_1 = require("./AppContext");
+const useApp_1 = require("./useApp");
+// container
+function AppContainer({ eventBus, SplashScreen, LoginScreen, ErrorScreen, children }) {
+    // bind memos + hooks
+    const [splashing, setSplashing] = (0, react_2.useState)(true);
+    const router = (0, router_1.useRouter)();
+    const app = (0, react_2.useMemo)(() => new App_1.App(eventBus), [eventBus]);
+    const context = (0, react_2.useMemo)(() => ({ app }), [app]);
+    const { identity, error: identityError } = (0, web_2.useIdentity)();
+    const { profile, error: profileError } = (0, web_3.useProfile)();
+    const bridge = (0, web_1.useBridge)();
+    const initializing = app.state === 'initializing';
+    // watch app
+    (0, useApp_1.useApp)(app);
+    // bind identity when active
+    (0, react_2.useEffect)(() => {
+        if (identity) {
+            console.debug('[AppContainer] binding identity:', identity.toData());
+            app.onIdentityChanged(identity);
+        }
+        else {
+            console.debug('[AppContainer] waiting for identity to sync');
+        }
+    }, [app, identity]);
+    // bind identity error
+    (0, react_2.useEffect)(() => {
+        if (identityError) {
+            console.debug('[AppContainer] identity error:', identityError.serialize());
+            app.onIdentityError(identityError);
+        }
+    }, [app, identityError]);
+    // bind profile
+    (0, react_2.useEffect)(() => {
+        if (profile) {
+            console.debug('[AppContainer] binding identity:', profile.toData());
+            app.onProfileChanged(profile);
+        }
+        else {
+            console.debug('[AppContainer] waiting for profile to sync');
+        }
+    }, [app, profile]);
+    // bind profile error
+    (0, react_2.useEffect)(() => {
+        if (profileError) {
+            console.debug('[AppContainer] profile error:', profileError.serialize());
+            app.onProfileError(profileError);
+        }
+    }, [app, profileError]);
+    // hide splash when it's done initializing
+    (0, react_2.useEffect)(() => {
+        if (!initializing) {
+            console.debug('[AppContainer] initialization complete');
+            (0, rxjs_1.firstValueFrom)((0, rxjs_1.timer)(1000))
+                .then(() => setSplashing(false));
+        }
+    }, [initializing]);
+    // show splash if still initializing app
+    let contentKey = undefined;
+    let content;
+    const isNative = bridge.isNative;
+    if (isNative) {
+        content = identity ? children : null;
+    }
+    // or render error
+    else if (app.identityError || app.profileError) {
+        content = (0, jsx_runtime_1.jsx)(ErrorScreen, { identityError: app.identityError, profileError: app.profileError });
+    }
+    // or render splash if web app is still authenticating
+    else if (!identity || splashing) {
+        contentKey = 'splash';
+        content = (0, jsx_runtime_1.jsx)(SplashScreen, {});
+    }
+    // or render login if anonymous
+    else if (!identity.authenticated) {
+        contentKey = 'login';
+        content = (0, jsx_runtime_1.jsx)(LoginScreen, {});
+    }
+    // or render page
+    else {
+        content = children;
+    }
+    // render
+    return ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)(head_1.default, { children: (0, jsx_runtime_1.jsx)("link", { rel: "icon", type: "image/svg+xml", href: "/manifest/favicon.svg" }) }), (0, jsx_runtime_1.jsx)(AppContext_1.AppContext.Provider, { value: context, children: (0, jsx_runtime_1.jsx)(react_1.AnimatePresence, { mode: "wait", children: (0, jsx_runtime_1.jsx)(react_1.motion.div, { className: (0, classnames_1.default)('nd-App will-change-[opacity,filter]', {
+                            'nd-App-web': !bridge.isNative,
+                            'nd-App-native': bridge.isNative
+                        }), initial: "initial", animate: "animate", exit: "exit", variants: {
+                            initial: { opacity: 0, filter: 'blur(3px)' },
+                            animate: { opacity: 1, filter: 'blur(0px)' },
+                            exit: { opacity: 0, filter: 'blur(3px)' }
+                        }, transition: { duration: 0.2 }, children: content }, contentKey !== null && contentKey !== void 0 ? contentKey : router.pathname) }) })] }));
+}

package/dist/react/app/web/AppContext.d.ts

@@ -0,0 +1,7 @@
+import { App } from './App';
+export declare const AppContext: import("react").Context<AppContext.Data>;
+export declare namespace AppContext {
+    type Data = {
+        app?: App;
+    };
+}

package/dist/react/app/web/AppContext.js

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

package/dist/react/app/web/AppLayout.d.ts

@@ -0,0 +1,7 @@
+import { BridgeProvider, BridgeState } from '../../bridge/web';
+import { AppContainer } from './AppContainer';
+export declare function AppLayout<TCustom extends BridgeState.Custom = BridgeState.Custom>({ SplashScreen, LoginScreen, ErrorScreen, children, ...bridgeProps }: AppLayout.Props<TCustom>): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppLayout {
+    type ScreenProps = AppContainer.ScreenProps;
+    type Props<TCustom extends BridgeState.Custom = BridgeState.Custom> = BridgeProvider.Props<TCustom> & ScreenProps;
+}

package/dist/react/app/web/AppLayout.js

@@ -0,0 +1,34 @@
+"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.AppLayout = AppLayout;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const funnel_core_1 = require("@nascentdigital/funnel-core");
+const hooks_1 = require("@nascentdigital/funnel-ui/hooks");
+const react_1 = require("react");
+const web_1 = require("../../bridge/web");
+const web_2 = require("../../content/web");
+const web_3 = require("../../cookies/web");
+const web_4 = require("../../identity/web");
+const web_5 = require("../../profile/web");
+const web_6 = require("../../nav/web");
+const web_7 = require("../../push/web");
+const AppContainer_1 = require("./AppContainer");
+// container
+function AppLayout(_a) {
+    var { SplashScreen, LoginScreen, ErrorScreen, children } = _a, bridgeProps = __rest(_a, ["SplashScreen", "LoginScreen", "ErrorScreen", "children"]);
+    // bind data + hooks
+    const eventBus = (0, react_1.useMemo)(() => new funnel_core_1.EventBus(), []);
+    // render
+    return ((0, jsx_runtime_1.jsx)(web_3.CookieServiceProvider, { eventBus: eventBus, children: (0, jsx_runtime_1.jsx)(web_1.BridgeProvider, Object.assign({}, bridgeProps, { children: (0, jsx_runtime_1.jsx)(web_4.WebIdentityProvider, { children: (0, jsx_runtime_1.jsx)(web_5.WebProfileProvider, { children: (0, jsx_runtime_1.jsx)(web_6.WebSpecProvider, { children: (0, jsx_runtime_1.jsx)(web_2.ContentProvider, { children: (0, jsx_runtime_1.jsx)(web_7.PushProvider, { children: (0, jsx_runtime_1.jsx)(hooks_1.BreakpointContainer, { children: (0, jsx_runtime_1.jsx)(AppContainer_1.AppContainer, { SplashScreen: SplashScreen, LoginScreen: LoginScreen, ErrorScreen: ErrorScreen, eventBus: eventBus, children: children }) }) }) }) }) }) }) })) }));
+}